Parser::InsertValuesStmt Class Reference

#include <ParserNode.h>

Inheritance diagram for Parser::InsertValuesStmt:

Collaboration diagram for Parser::InsertValuesStmt:

Public Member Functions
	InsertValuesStmt (const rapidjson::Value &payload)
	InsertValuesStmt (std::string *t, std::list< std::string * > *c, std::list< Expr * > *v)
const std::vector < std::unique_ptr< ValuesList > > &	get_value_lists () const
void	analyze (const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const override
void	execute (const Catalog_Namespace::SessionInfo &session, bool read_only_mode)
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 ()

Public Attributes
std::unique_ptr < Fragmenter_Namespace::InsertDataLoader::InsertConnector >	leafs_connector_

Private Attributes
std::vector< std::unique_ptr < ValuesList > >	values_lists_

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 2079 of file ParserNode.h.

Constructor & Destructor Documentation

Parser::InsertValuesStmt::InsertValuesStmt

(

const rapidjson::Value &

payload

)

Definition at line 2423 of file ParserNode.cpp.

References CHECK, Parser::InsertStmt::column_list_, json_str(), Parser::anonymous_namespace{ParserNode.cpp}::parse_insert_array_literal(), Parser::anonymous_namespace{ParserNode.cpp}::parse_insert_literal(), Parser::InsertStmt::table_, and values_lists_.

    : InsertStmt(nullptr, nullptr) {
  CHECK(payload.HasMember("name"));
  table_ = std::make_unique<std::string>(json_str(payload["name"]));

  if (payload.HasMember("columns")) {
    CHECK(payload["columns"].IsArray());
    for (auto& column : payload["columns"].GetArray()) {
      std::string s = json_str(column);
      column_list_.emplace_back(std::make_unique<std::string>(s));
    }
  }

  CHECK(payload.HasMember("values") && payload["values"].IsArray());
  auto tuples = payload["values"].GetArray();
  if (tuples.Empty()) {
    throw std::runtime_error("Values statement cannot be empty");
  }
  values_lists_.reserve(tuples.Size());
  for (const auto& json_tuple : tuples) {
    auto values_list = std::make_unique<ValuesList>();
    CHECK(json_tuple.IsArray());
    auto tuple = json_tuple.GetArray();
    for (const auto& value : tuple) {
      CHECK(value.IsObject());
      if (value.HasMember("array")) {
        values_list->push_back(parse_insert_array_literal(value["array"]));
      } else {
        values_list->push_back(parse_insert_literal(value));
      }
    }
    values_lists_.push_back(std::move(values_list));
  }
}

Here is the call graph for this function:

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

inline

Definition at line 2082 of file ParserNode.h.

References UNREACHABLE.

      : InsertStmt(t, c) {
    UNREACHABLE() << "Legacy inserts should not be called anymore";
  }

Member Function Documentation

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

overridevirtual

Implements Parser::InsertStmt.

Definition at line 2458 of file ParserNode.cpp.

References Parser::InsertStmt::analyze(), CHECK, CHECK_EQ, Parser::InsertStmt::column_list_, Geospatial::compress_coords(), Datum::doubleval, Analyzer::Query::get_result_col_list(), Analyzer::Query::get_result_table_id(), Analyzer::Query::get_values_lists(), Catalog_Namespace::Catalog::getAllColumnMetadataForTable(), Geospatial::GeoTypesFactory::getGeoColumns(), Catalog_Namespace::Catalog::getMetadataForColumn(), Datum::intval, is_null(), kARRAY, kCAST, kDOUBLE, kINT, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kPOINT, kPOLYGON, kTINYINT, NULL_ARRAY_DOUBLE, NULL_DOUBLE, Datum::tinyintval, to_string(), and values_lists_.

Referenced by execute().

                                                           {
  InsertStmt::analyze(catalog, query);
  size_t list_size = values_lists_[0]->get_value_list().size();
  if (!column_list_.empty()) {
    if (list_size != column_list_.size()) {
      throw std::runtime_error(
          "Numbers of columns and values don't match for the "
          "insert.");
    }
  } else {
    const auto tableId = query.get_result_table_id();
    const std::list<const ColumnDescriptor*> non_phys_cols =
        catalog.getAllColumnMetadataForTable(tableId, false, false, false);
    if (non_phys_cols.size() != list_size) {
      throw std::runtime_error(
          "Number of columns in table does not match the list of values given in the "
          "insert.");
    }
  }
  std::vector<const ColumnDescriptor*> cds;
  cds.reserve(query.get_result_col_list().size());
  for (auto id : query.get_result_col_list()) {
    const auto* cd = catalog.getMetadataForColumn(query.get_result_table_id(), id);
    CHECK(cd);
    cds.push_back(cd);
  }
  auto& query_values_lists = query.get_values_lists();
  query_values_lists.resize(values_lists_.size());
  for (size_t i = 0; i < values_lists_.size(); ++i) {
    const auto& values_list = values_lists_[i]->get_value_list();
    if (values_list.size() != list_size) {
      throw std::runtime_error(
          "Insert values lists should be of the same size. Expected: " +
          std::to_string(list_size) + ", Got: " + std::to_string(values_list.size()));
    }
    auto& query_values_list = query_values_lists[i];
    size_t cds_id = 0;
    for (auto& v : values_list) {
      auto e = v->analyze(catalog, query);
      const auto* cd = cds[cds_id];
      const auto& col_ti = cd->columnType;
      if (col_ti.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(col_ti);
      query_values_list.emplace_back(new Analyzer::TargetEntry("", e, false));
      ++cds_id;

      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

        const auto* cd_coords = cds[cds_id];
        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);
          }
        }
        query_values_list.emplace_back(new Analyzer::TargetEntry(
            "",
            makeExpr<Analyzer::Constant>(cd_coords->columnType, is_null, value_exprs),
            false));
        ++cds_id;

        if (cd->columnType.get_type() == kMULTILINESTRING ||
            cd->columnType.get_type() == kPOLYGON ||
            cd->columnType.get_type() == kMULTIPOLYGON) {
          // Put [linest]ring sizes array into separate physical column
          const auto* cd_ring_sizes = cds[cds_id];
          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);
            }
          }
          query_values_list.emplace_back(new Analyzer::TargetEntry(
              "",
              makeExpr<Analyzer::Constant>(
                  cd_ring_sizes->columnType, is_null, value_exprs),
              false));
          ++cds_id;

          if (cd->columnType.get_type() == kMULTIPOLYGON) {
            // Put poly_rings array into separate physical column
            const auto* cd_poly_rings = cds[cds_id];
            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);
              }
            }
            query_values_list.emplace_back(new Analyzer::TargetEntry(
                "",
                makeExpr<Analyzer::Constant>(
                    cd_poly_rings->columnType, is_null, value_exprs),
                false));
            ++cds_id;
          }
        }

        if (cd->columnType.get_type() == kMULTIPOINT ||
            cd->columnType.get_type() == kLINESTRING ||
            cd->columnType.get_type() == kMULTILINESTRING ||
            cd->columnType.get_type() == kPOLYGON ||
            cd->columnType.get_type() == kMULTIPOLYGON) {
          const auto* cd_bounds = cds[cds_id];
          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);
            }
          }
          query_values_list.emplace_back(new Analyzer::TargetEntry(
              "",
              makeExpr<Analyzer::Constant>(cd_bounds->columnType, is_null, value_exprs),
              false));
          ++cds_id;
        }

        if (cd->columnType.get_type() == kPOLYGON ||
            cd->columnType.get_type() == kMULTIPOLYGON) {
          // Put render group into separate physical column
          const auto* cd_render_group = cds[cds_id];
          CHECK(cd_render_group);
          CHECK_EQ(cd_render_group->columnType.get_type(), kINT);
          Datum d;
          d.intval = render_group;
          query_values_list.emplace_back(new Analyzer::TargetEntry(
              "",
              makeExpr<Analyzer::Constant>(cd_render_group->columnType, is_null, d),
              false));
          ++cds_id;
        }
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 2682 of file ParserNode.cpp.

References analyze(), CHECK, Catalog_Namespace::SessionInfo::checkDBAccessPrivileges(), logger::ERROR, legacylockmgr::ExecutorOuterLock, Catalog_Namespace::SessionInfo::getCatalog(), Executor::getExecutor(), legacylockmgr::LockMgr< MutexType, KeyType >::getMutex(), lockmgr::TableLockMgrImpl< T >::getWriteLockForTable(), AccessPrivileges::INSERT_INTO_TABLE, leafs_connector_, LOG, Parser::InsertStmt::table_, TableDBObjectType, Executor::UNITARY_EXECUTOR_ID, and foreign_storage::validate_non_foreign_table_write().

Referenced by heavydb.cursor.Cursor::executemany().

                                                    {
  if (read_only_mode) {
    throw std::runtime_error("INSERT values invalid in read only mode.");
  }
  auto execute_read_lock =
      heavyai::shared_lock<legacylockmgr::WrapperType<heavyai::shared_mutex>>(
          *legacylockmgr::LockMgr<heavyai::shared_mutex, bool>::getMutex(
              legacylockmgr::ExecutorOuterLock, true));
  auto& catalog = session.getCatalog();
  const auto td_with_lock =
      lockmgr::TableSchemaLockContainer<lockmgr::ReadLock>::acquireTableDescriptor(
          catalog, *table_);
  if (!session.checkDBAccessPrivileges(DBObjectType::TableDBObjectType,
                                       AccessPrivileges::INSERT_INTO_TABLE,
                                       *table_)) {
    throw std::runtime_error("User has no insert privileges on " + *table_ + ".");
  }
  Analyzer::Query query;
  analyze(catalog, query);

  // Take an insert data write lock, which prevents concurrent inserts.
  const auto insert_data_lock =
      lockmgr::InsertDataLockMgr::getWriteLockForTable(catalog, *table_);

  // 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());

  if (!leafs_connector_) {
    leafs_connector_ = std::make_unique<Fragmenter_Namespace::LocalInsertConnector>();
  }
  Fragmenter_Namespace::InsertDataLoader insert_data_loader(*leafs_connector_);
  try {
    ra_executor.executeSimpleInsert(query, insert_data_loader, session);
  } catch (...) {
    try {
      leafs_connector_->rollback(session, td->tableId);
    } catch (std::exception& e) {
      LOG(ERROR) << "An error occurred during insert rollback attempt. Table id: "
                 << td->tableId << ", Error: " << e.what();
    }
    throw;
  }
  if (!td->isTemporaryTable()) {
    leafs_connector_->checkpoint(session, td->tableId);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const std::vector<std::unique_ptr<ValuesList> >& Parser::InsertValuesStmt::get_value_lists ( ) const

inline

Definition at line 2087 of file ParserNode.h.

References values_lists_.

                                                                      {
    return values_lists_;
  }

Member Data Documentation

std::unique_ptr<Fragmenter_Namespace::InsertDataLoader::InsertConnector> Parser::InsertValuesStmt::leafs_connector_

Definition at line 2097 of file ParserNode.h.

Referenced by execute().

std::vector<std::unique_ptr<ValuesList> > Parser::InsertValuesStmt::values_lists_

private

Definition at line 2100 of file ParserNode.h.

Referenced by analyze(), get_value_lists(), 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