#include <ParserNode.h>

Inheritance diagram for Parser::InsertValuesStmt:

Collaboration diagram for Parser::InsertValuesStmt:

Public Member Functions
	InsertValuesStmt (std::string t, std::list< std::string > c, std::list< Expr > *v)

const std::list < std::unique_ptr< Expr > > &	get_value_list () const

void	analyze (const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const override

size_t	determineLeafIndex (const Catalog_Namespace::Catalog &catalog, size_t num_leafs)

void	execute (const Catalog_Namespace::SessionInfo &session)

Public Member Functions inherited from Parser::InsertStmt
	InsertStmt (std::string t, std::list< std::string > *c)

const std::string *	get_table () const

const std::list < std::unique_ptr< std::string > > &	get_column_list () const

Public Member Functions inherited from Parser::Node
virtual	~Node ()

Private Attributes
std::list< std::unique_ptr < Expr > >	value_list_

Additional Inherited Members
Protected Attributes inherited from Parser::InsertStmt
std::unique_ptr< std::string >	table_

std::list< std::unique_ptr < std::string > >	column_list_

Detailed Description

Definition at line 2055 of file ParserNode.h.

Constructor & Destructor Documentation

Parser::InsertValuesStmt::InsertValuesStmt	(	std::string *	t,
		std::list< std::string * > *	c,
		std::list< Expr * > *	v
	)

inline

Definition at line 2057 of file ParserNode.h.

References CHECK, and value_list_.

       : InsertStmt(t, c) {
     CHECK(v);
     for (const auto e : *v) {
       value_list_.emplace_back(e);
     }
     delete v;
   }

Member Function Documentation

void Parser::InsertValuesStmt::analyze	(	const Catalog_Namespace::Catalog &	catalog,
		Analyzer::Query &	query
	)		const

overridevirtual

Implements Parser::InsertStmt.

Definition at line 1799 of file ParserNode.cpp.

References CHECK, CHECK_EQ, ColumnDescriptor::columnId, ColumnDescriptor::columnName, ColumnDescriptor::columnType, Geospatial::compress_coords(), Datum::doubleval, SQLTypeInfo::get_notnull(), Analyzer::Query::get_result_col_list(), Analyzer::Query::get_result_table_id(), SQLTypeInfo::get_subtype(), Analyzer::Query::get_targetlist_nonconst(), SQLTypeInfo::get_type(), Catalog_Namespace::Catalog::getAllColumnMetadataForTable(), Geospatial::GeoTypesFactory::getGeoColumns(), Catalog_Namespace::Catalog::getMetadataForColumn(), Datum::intval, SQLTypeInfo::is_geometry(), is_null(), kARRAY, kCAST, kDOUBLE, kINT, kLINESTRING, kMULTIPOLYGON, kPOINT, kPOLYGON, kTINYINT, NULL_ARRAY_DOUBLE, NULL_DOUBLE, and Datum::tinyintval.

                                                            {
   InsertStmt::analyze(catalog, query);
   std::vector<std::shared_ptr<Analyzer::TargetEntry>>& tlist =
       query.get_targetlist_nonconst();
   const auto tableId = query.get_result_table_id();
   if (!column_list_.empty()) {
     if (value_list_.size() != column_list_.size()) {
       throw std::runtime_error(
           "Numbers of columns and values don't match for the "
           "insert.");
     }
   } else {
     const std::list<const ColumnDescriptor*> non_phys_cols =
         catalog.getAllColumnMetadataForTable(tableId, false, false, false);
     if (non_phys_cols.size() != value_list_.size()) {
       throw std::runtime_error(
           "Number of columns in table does not match the list of values given in the "
           "insert.");
     }
   }
   std::list<int>::const_iterator it = query.get_result_col_list().begin();
   for (auto& v : value_list_) {
     auto e = v->analyze(catalog, query);
     const ColumnDescriptor* cd =
         catalog.getMetadataForColumn(query.get_result_table_id(), *it);
     CHECK(cd);
     if (cd->columnType.get_notnull()) {
       auto c = std::dynamic_pointer_cast<Analyzer::Constant>(e);
       if (c != nullptr && c->get_is_null()) {
         throw std::runtime_error("Cannot insert NULL into column " + cd->columnName);
       }
     }
     e = e->add_cast(cd->columnType);
     tlist.emplace_back(new Analyzer::TargetEntry("", e, false));
     ++it;
 
     const auto& col_ti = cd->columnType;
     if (col_ti.get_physical_cols() > 0) {
       CHECK(cd->columnType.is_geometry());
       auto c = dynamic_cast<const Analyzer::Constant*>(e.get());
       if (!c) {
         auto uoper = std::dynamic_pointer_cast<Analyzer::UOper>(e);
         if (uoper && uoper->get_optype() == kCAST) {
           c = dynamic_cast<const Analyzer::Constant*>(uoper->get_operand());
         }
       }
       bool is_null = false;
       std::string* geo_string{nullptr};
       if (c) {
         is_null = c->get_is_null();
         if (!is_null) {
           geo_string = c->get_constval().stringval;
         }
       }
       if (!is_null && !geo_string) {
         throw std::runtime_error("Expecting a WKT or WKB hex string for column " +
                                  cd->columnName);
       }
       std::vector<double> coords;
       std::vector<double> bounds;
       std::vector<int> ring_sizes;
       std::vector<int> poly_rings;
       int render_group =
           0;  // @TODO simon.eves where to get render_group from in this context?!
       SQLTypeInfo import_ti{cd->columnType};
       if (!is_null) {
         if (!Geospatial::GeoTypesFactory::getGeoColumns(
                 *geo_string, import_ti, coords, bounds, ring_sizes, poly_rings)) {
           throw std::runtime_error("Cannot read geometry to insert into column " +
                                    cd->columnName);
         }
         if (coords.empty()) {
           // Importing from geo_string WKT resulted in empty coords: dealing with a NULL
           is_null = true;
         }
         if (cd->columnType.get_type() != import_ti.get_type()) {
           // allow POLYGON to be inserted into MULTIPOLYGON column
           if (!(import_ti.get_type() == SQLTypes::kPOLYGON &&
                 cd->columnType.get_type() == SQLTypes::kMULTIPOLYGON)) {
             throw std::runtime_error(
                 "Imported geometry doesn't match the type of column " + cd->columnName);
           }
         }
       } else {
         // Special case for NULL POINT, push NULL representation to coords
         if (cd->columnType.get_type() == kPOINT) {
           if (!coords.empty()) {
             throw std::runtime_error("NULL POINT with unexpected coordinates in column " +
                                      cd->columnName);
           }
           coords.push_back(NULL_ARRAY_DOUBLE);
           coords.push_back(NULL_DOUBLE);
         }
       }
 
       // TODO: check if import SRID matches columns SRID, may need to transform before
       // inserting
 
       int nextColumnOffset = 1;
 
       const ColumnDescriptor* cd_coords = catalog.getMetadataForColumn(
           query.get_result_table_id(), cd->columnId + nextColumnOffset);
       CHECK(cd_coords);
       CHECK_EQ(cd_coords->columnType.get_type(), kARRAY);
       CHECK_EQ(cd_coords->columnType.get_subtype(), kTINYINT);
       std::list<std::shared_ptr<Analyzer::Expr>> value_exprs;
       if (!is_null || cd->columnType.get_type() == kPOINT) {
         auto compressed_coords = Geospatial::compress_coords(coords, col_ti);
         for (auto cc : compressed_coords) {
           Datum d;
           d.tinyintval = cc;
           auto e = makeExpr<Analyzer::Constant>(kTINYINT, false, d);
           value_exprs.push_back(e);
         }
       }
       tlist.emplace_back(new Analyzer::TargetEntry(
           "",
           makeExpr<Analyzer::Constant>(cd_coords->columnType, is_null, value_exprs),
           false));
       ++it;
       nextColumnOffset++;
 
       if (cd->columnType.get_type() == kPOLYGON ||
           cd->columnType.get_type() == kMULTIPOLYGON) {
         // Put ring sizes array into separate physical column
         const ColumnDescriptor* cd_ring_sizes = catalog.getMetadataForColumn(
             query.get_result_table_id(), cd->columnId + nextColumnOffset);
         CHECK(cd_ring_sizes);
         CHECK_EQ(cd_ring_sizes->columnType.get_type(), kARRAY);
         CHECK_EQ(cd_ring_sizes->columnType.get_subtype(), kINT);
         std::list<std::shared_ptr<Analyzer::Expr>> value_exprs;
         if (!is_null) {
           for (auto c : ring_sizes) {
             Datum d;
             d.intval = c;
             auto e = makeExpr<Analyzer::Constant>(kINT, false, d);
             value_exprs.push_back(e);
           }
         }
         tlist.emplace_back(new Analyzer::TargetEntry(
             "",
             makeExpr<Analyzer::Constant>(cd_ring_sizes->columnType, is_null, value_exprs),
             false));
         ++it;
         nextColumnOffset++;
 
         if (cd->columnType.get_type() == kMULTIPOLYGON) {
           // Put poly_rings array into separate physical column
           const ColumnDescriptor* cd_poly_rings = catalog.getMetadataForColumn(
               query.get_result_table_id(), cd->columnId + nextColumnOffset);
           CHECK(cd_poly_rings);
           CHECK_EQ(cd_poly_rings->columnType.get_type(), kARRAY);
           CHECK_EQ(cd_poly_rings->columnType.get_subtype(), kINT);
           std::list<std::shared_ptr<Analyzer::Expr>> value_exprs;
           if (!is_null) {
             for (auto c : poly_rings) {
               Datum d;
               d.intval = c;
               auto e = makeExpr<Analyzer::Constant>(kINT, false, d);
               value_exprs.push_back(e);
             }
           }
           tlist.emplace_back(new Analyzer::TargetEntry(
               "",
               makeExpr<Analyzer::Constant>(
                   cd_poly_rings->columnType, is_null, value_exprs),
               false));
           ++it;
           nextColumnOffset++;
         }
       }
 
       if (cd->columnType.get_type() == kLINESTRING ||
           cd->columnType.get_type() == kPOLYGON ||
           cd->columnType.get_type() == kMULTIPOLYGON) {
         const ColumnDescriptor* cd_bounds = catalog.getMetadataForColumn(
             query.get_result_table_id(), cd->columnId + nextColumnOffset);
         CHECK(cd_bounds);
         CHECK_EQ(cd_bounds->columnType.get_type(), kARRAY);
         CHECK_EQ(cd_bounds->columnType.get_subtype(), kDOUBLE);
         std::list<std::shared_ptr<Analyzer::Expr>> value_exprs;
         if (!is_null) {
           for (auto b : bounds) {
             Datum d;
             d.doubleval = b;
             auto e = makeExpr<Analyzer::Constant>(kDOUBLE, false, d);
             value_exprs.push_back(e);
           }
         }
         tlist.emplace_back(new Analyzer::TargetEntry(
             "",
             makeExpr<Analyzer::Constant>(cd_bounds->columnType, is_null, value_exprs),
             false));
         ++it;
         nextColumnOffset++;
       }
 
       if (cd->columnType.get_type() == kPOLYGON ||
           cd->columnType.get_type() == kMULTIPOLYGON) {
         // Put render group into separate physical column
         const ColumnDescriptor* cd_render_group = catalog.getMetadataForColumn(
             query.get_result_table_id(), cd->columnId + nextColumnOffset);
         CHECK(cd_render_group);
         CHECK_EQ(cd_render_group->columnType.get_type(), kINT);
         Datum d;
         d.intval = render_group;
         tlist.emplace_back(new Analyzer::TargetEntry(
             "",
             makeExpr<Analyzer::Constant>(cd_render_group->columnType, is_null, d),
             false));
         ++it;
         nextColumnOffset++;
       }
     }
   }
 }

Here is the call graph for this function:

size_t Parser::InsertValuesStmt::determineLeafIndex	(	const Catalog_Namespace::Catalog &	catalog,
		size_t	num_leafs
	)

Definition at line 1688 of file ParserNode.cpp.

References Datum::bigintval, CHECK, CHECK_EQ, ColumnDescriptor::columnName, ColumnDescriptor::columnType, run_benchmark_import::con, SQLTypeInfo::get_comp_param(), Analyzer::Constant::get_constval(), Analyzer::Constant::get_is_null(), SQLTypeInfo::get_logical_size(), SQLTypeInfo::get_size(), Catalog_Namespace::Catalog::getAllColumnMetadataForTable(), Catalog_Namespace::Catalog::getMetadataForDict(), Catalog_Namespace::Catalog::getMetadataForTable(), Catalog_Namespace::Catalog::getShardColumnMetadataForTable(), inline_fixed_encoding_null_val(), Datum::intval, SQLTypeInfo::is_string(), TableDescriptor::isView, kCAST, TableDescriptor::nShards, TableDescriptor::partitions, SHARD_FOR_KEY, Datum::smallintval, DictDescriptor::stringDict, Datum::stringval, TableDescriptor::tableId, Datum::tinyintval, and foreign_storage::validate_non_foreign_table_write().

                                                               {
   const TableDescriptor* td = catalog.getMetadataForTable(*table_);
   if (td == nullptr) {
     throw std::runtime_error("Table " + *table_ + " does not exist.");
   }
   if (td->isView) {
     throw std::runtime_error("Insert to views is not supported yet.");
   }
   foreign_storage::validate_non_foreign_table_write(td);
   if (td->partitions == "REPLICATED") {
     throw std::runtime_error("Cannot determine leaf on replicated table.");
   }
 
   if (0 == td->nShards) {
     std::random_device rd;
     std::mt19937_64 gen(rd());
     std::uniform_int_distribution<size_t> dis;
     const auto leaf_idx = dis(gen) % num_leafs;
     return leaf_idx;
   }
 
   size_t indexOfShardColumn = 0;
   const ColumnDescriptor* shardColumn = catalog.getShardColumnMetadataForTable(td);
   CHECK(shardColumn);
   auto shard_count = td->nShards * num_leafs;
   int64_t shardId = 0;
 
   if (column_list_.empty()) {
     auto all_cols =
         catalog.getAllColumnMetadataForTable(td->tableId, false, false, false);
     auto iter = std::find(all_cols.begin(), all_cols.end(), shardColumn);
     CHECK(iter != all_cols.end());
     indexOfShardColumn = std::distance(all_cols.begin(), iter);
   } else {
     for (auto& c : column_list_) {
       if (*c == shardColumn->columnName) {
         break;
       }
       indexOfShardColumn++;
     }
 
     if (indexOfShardColumn == column_list_.size()) {
       shardId = SHARD_FOR_KEY(inline_fixed_encoding_null_val(shardColumn->columnType),
                               shard_count);
       return shardId / td->nShards;
     }
   }
 
   if (indexOfShardColumn >= value_list_.size()) {
     throw std::runtime_error("No value defined for shard column.");
   }
 
   auto& shardColumnValueExpr = *(std::next(value_list_.begin(), indexOfShardColumn));
 
   Analyzer::Query query;
   auto e = shardColumnValueExpr->analyze(catalog, query);
   e = e->add_cast(shardColumn->columnType);
   const Analyzer::Constant* con = dynamic_cast<Analyzer::Constant*>(e.get());
   if (!con) {
     auto col_cast = dynamic_cast<const Analyzer::UOper*>(e.get());
     CHECK(col_cast);
     CHECK_EQ(kCAST, col_cast->get_optype());
     con = dynamic_cast<const Analyzer::Constant*>(col_cast->get_operand());
   }
   CHECK(con);
 
   Datum d = con->get_constval();
   if (con->get_is_null()) {
     shardId = SHARD_FOR_KEY(inline_fixed_encoding_null_val(shardColumn->columnType),
                             shard_count);
   } else if (shardColumn->columnType.is_string()) {
     auto dictDesc =
         catalog.getMetadataForDict(shardColumn->columnType.get_comp_param(), true);
     auto str_id = dictDesc->stringDict->getOrAdd(*d.stringval);
     bool invalid = false;
 
     if (4 == shardColumn->columnType.get_size()) {
       invalid = str_id > max_valid_int_value<int32_t>();
     } else if (2 == shardColumn->columnType.get_size()) {
       invalid = str_id > max_valid_int_value<uint16_t>();
     } else if (1 == shardColumn->columnType.get_size()) {
       invalid = str_id > max_valid_int_value<uint8_t>();
     }
 
     if (invalid || str_id == inline_int_null_value<int32_t>()) {
       str_id = inline_fixed_encoding_null_val(shardColumn->columnType);
     }
     shardId = SHARD_FOR_KEY(str_id, shard_count);
   } else {
     switch (shardColumn->columnType.get_logical_size()) {
       case 8:
         shardId = SHARD_FOR_KEY(d.bigintval, shard_count);
         break;
       case 4:
         shardId = SHARD_FOR_KEY(d.intval, shard_count);
         break;
       case 2:
         shardId = SHARD_FOR_KEY(d.smallintval, shard_count);
         break;
       case 1:
         shardId = SHARD_FOR_KEY(d.tinyintval, shard_count);
         break;
       default:
         CHECK(false);
     }
   }
 
   return shardId / td->nShards;
 }

Here is the call graph for this function:

void Parser::InsertValuesStmt::execute ( const Catalog_Namespace::SessionInfo & session )

Definition at line 2017 of file ParserNode.cpp.

References CHECK, Catalog_Namespace::SessionInfo::checkDBAccessPrivileges(), RelAlgExecutor::executeSimpleInsert(), legacylockmgr::ExecutorOuterLock, Catalog_Namespace::SessionInfo::getCatalog(), Executor::getExecutor(), legacylockmgr::LockMgr< MutexType, KeyType >::getMutex(), AccessPrivileges::INSERT_INTO_TABLE, TableDBObjectType, Executor::UNITARY_EXECUTOR_ID, and foreign_storage::validate_non_foreign_table_write().

Referenced by omnisci.cursor.Cursor::executemany(), and QueryRunner::QueryRunner::runSQL().

                                                                           {
   auto& catalog = session.getCatalog();
 
   if (!session.checkDBAccessPrivileges(DBObjectType::TableDBObjectType,
                                        AccessPrivileges::INSERT_INTO_TABLE,
                                        *table_)) {
     throw std::runtime_error("User has no insert privileges on " + *table_ + ".");
   }
 
   auto execute_write_lock = mapd_unique_lock<mapd_shared_mutex>(
       *legacylockmgr::LockMgr<mapd_shared_mutex, bool>::getMutex(
           legacylockmgr::ExecutorOuterLock, true));
 
   Analyzer::Query query;
   analyze(catalog, query);
 
   //  Acquire schema write lock -- leave data lock so the fragmenter can checkpoint. For
   //  singleton inserts we just take a write lock on the schema, which prevents concurrent
   //  inserts.
   auto result_table_id = query.get_result_table_id();
   const auto td_with_lock =
       lockmgr::TableSchemaLockContainer<lockmgr::WriteLock>::acquireTableDescriptor(
           catalog, result_table_id);
   // NOTE(max): we do the same checks as below just a few calls earlier in analyze().
   // Do we keep those intentionally to make sure nothing changed in between w/o
   // catalog locks or is it just a duplicate work?
   auto td = td_with_lock();
   CHECK(td);
   if (td->isView) {
     throw std::runtime_error("Singleton inserts on views is not supported.");
   }
   foreign_storage::validate_non_foreign_table_write(td);
 
   auto executor = Executor::getExecutor(Executor::UNITARY_EXECUTOR_ID);
   RelAlgExecutor ra_executor(executor.get(), catalog);
 
   ra_executor.executeSimpleInsert(query);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const std::list<std::unique_ptr<Expr> >& Parser::InsertValuesStmt::get_value_list ( ) const

inline

Definition at line 2065 of file ParserNode.h.

References value_list_.

2065 { return value_list_; }

Parser::InsertValuesStmt::value_list_

std::list< std::unique_ptr< Expr > > value_list_

Definition: ParserNode.h:2074

Member Data Documentation

std::list<std::unique_ptr<Expr> > Parser::InsertValuesStmt::value_list_

private

Definition at line 2074 of file ParserNode.h.

Referenced by get_value_list(), and InsertValuesStmt().

The documentation for this class was generated from the following files:

/home/jenkins-slave/workspace/core-os-doxygen/Parser/ParserNode.h
/home/jenkins-slave/workspace/core-os-doxygen/Parser/ParserNode.cpp

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation