Parser::CreateTableStmt Class Reference

#include <ParserNode.h>

Inheritance diagram for Parser::CreateTableStmt:

Collaboration diagram for Parser::CreateTableStmt:

Public Member Functions
	CreateTableStmt (std::string *tab, const std::string *storage, std::list< TableElement * > *table_elems, bool is_temporary, bool if_not_exists, std::list< NameValueAssign * > *s)
	CreateTableStmt (const rapidjson::Value &payload)
const std::string *	get_table () const override
const std::list < std::unique_ptr < TableElement > > &	get_table_element_list () const override
void	execute (const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
void	executeDryRun (const Catalog_Namespace::SessionInfo &session, TableDescriptor &td, std::list< ColumnDescriptor > &columns, std::vector< SharedDictionaryDef > &shared_dict_defs)
Public Member Functions inherited from Parser::DDLStmt
void	setColumnDescriptor (ColumnDescriptor &cd, const ColumnDef *coldef)
Public Member Functions inherited from Parser::Node
virtual	~Node ()

Private Attributes
std::unique_ptr< std::string >	table_
std::list< std::unique_ptr < TableElement > >	table_element_list_
bool	is_temporary_
bool	if_not_exists_
std::list< std::unique_ptr < NameValueAssign > >	storage_options_

Detailed Description

Definition at line 986 of file ParserNode.h.

Constructor & Destructor Documentation

Parser::CreateTableStmt::CreateTableStmt ( std::string *  tab, const std::string *  storage, std::list< TableElement * > *  table_elems, bool  is_temporary, bool  if_not_exists, std::list< NameValueAssign * > *  s  )

inline

Definition at line 988 of file ParserNode.h.

References CHECK, storage_options_, and table_element_list_.

      : table_(tab), is_temporary_(is_temporary), if_not_exists_(if_not_exists) {
    CHECK(table_elems);
    for (const auto e : *table_elems) {
      table_element_list_.emplace_back(e);
    }
    delete table_elems;
    if (s) {
      for (const auto e : *s) {
        storage_options_.emplace_back(e);
      }
      delete s;
    }
  }

Parser::CreateTableStmt::CreateTableStmt

(

const rapidjson::Value &

payload

)

Definition at line 3250 of file ParserNode.cpp.

References CHECK, if_not_exists_, is_temporary_, json_bool(), json_str(), Parser::anonymous_namespace{ParserNode.cpp}::parse_elements(), Parser::anonymous_namespace{ParserNode.cpp}::parse_options(), storage_options_, table_, and table_element_list_.

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

  is_temporary_ = false;
  if (payload.HasMember("temporary")) {
    is_temporary_ = json_bool(payload["temporary"]);
  }

  if_not_exists_ = false;
  if (payload.HasMember("ifNotExists")) {
    if_not_exists_ = json_bool(payload["ifNotExists"]);
  }

  parse_elements(payload, "elements", *table_, table_element_list_);

  parse_options(payload, storage_options_);
}

Here is the call graph for this function:

Member Function Documentation

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

overridevirtual

Implements Parser::DDLStmt.

Definition at line 3329 of file ParserNode.cpp.

References Catalog_Namespace::SessionInfo::checkDBAccessPrivileges(), AccessPrivileges::CREATE_TABLE, executeDryRun(), Catalog_Namespace::SessionInfo::get_currentUser(), Catalog_Namespace::SessionInfo::getCatalog(), legacylockmgr::getExecuteWriteLock(), if_not_exists_, lockmgr::instance(), table_, TableDBObjectType, TableDescriptor::tableName, TableDescriptor::userId, and Catalog_Namespace::UserMetadata::userId.

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

                                                   {
  if (read_only_mode) {
    throw std::runtime_error("CREATE TABLE invalid in read only mode.");
  }
  auto& catalog = session.getCatalog();

  // Until we create the table we don't have a table descriptor to lock and guarantee
  // exclusive use of.  Because of that we need a global write lock to make sure we have
  // exclusive access to the system for now.
  const auto execute_write_lock = legacylockmgr::getExecuteWriteLock();

  // check access privileges
  if (!session.checkDBAccessPrivileges(DBObjectType::TableDBObjectType,
                                       AccessPrivileges::CREATE_TABLE)) {
    throw std::runtime_error("Table " + *table_ +
                             " will not be created. User has no create privileges.");
  }

  if (!catalog.validateNonExistentTableOrView(*table_, if_not_exists_)) {
    return;
  }

  TableDescriptor td;
  std::list<ColumnDescriptor> columns;
  std::vector<SharedDictionaryDef> shared_dict_defs;

  executeDryRun(session, td, columns, shared_dict_defs);
  td.userId = session.get_currentUser().userId;

  catalog.createShardedTable(td, columns, shared_dict_defs);
  // TODO (max): It's transactionally unsafe, should be fixed: we may create object w/o
  // privileges
  SysCatalog::instance().createDBObject(
      session.get_currentUser(), td.tableName, TableDBObjectType, catalog);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Parser::CreateTableStmt::executeDryRun	(	const Catalog_Namespace::SessionInfo &	session,
		TableDescriptor &	td,
		std::list< ColumnDescriptor > &	columns,
		std::vector< SharedDictionaryDef > &	shared_dict_defs
	)

Definition at line 3271 of file ParserNode.cpp.

References ColumnDescriptor::columnName, Data_Namespace::CPU_LEVEL, Data_Namespace::DISK_LEVEL, Parser::ColumnDef::get_column_name(), Parser::anonymous_namespace{ParserNode.cpp}::get_table_definitions(), Catalog_Namespace::SessionInfo::getCatalog(), is_temporary_, TableDescriptor::keyMetainfo, TableDescriptor::nShards, TableDescriptor::persistenceLevel, Parser::anonymous_namespace{ParserNode.cpp}::serialize_key_metainfo(), ddl_utils::set_default_table_attributes(), Parser::DDLStmt::setColumnDescriptor(), Parser::anonymous_namespace{ParserNode.cpp}::shard_column_index(), TableDescriptor::shardedColumnId, storage_options_, table_, table_element_list_, ddl_utils::validate_non_duplicate_column(), and validate_shared_dictionary().

Referenced by execute().

                                                                                      {
  std::unordered_set<std::string> uc_col_names;
  const auto& catalog = session.getCatalog();
  const ShardKeyDef* shard_key_def{nullptr};
  for (auto& e : table_element_list_) {
    if (dynamic_cast<SharedDictionaryDef*>(e.get())) {
      auto shared_dict_def = static_cast<SharedDictionaryDef*>(e.get());
      validate_shared_dictionary(
          this, shared_dict_def, columns, shared_dict_defs, catalog);
      shared_dict_defs.push_back(*shared_dict_def);
      continue;
    }
    if (dynamic_cast<ShardKeyDef*>(e.get())) {
      if (shard_key_def) {
        throw std::runtime_error("Specified more than one shard key");
      }
      shard_key_def = static_cast<const ShardKeyDef*>(e.get());
      continue;
    }
    if (!dynamic_cast<ColumnDef*>(e.get())) {
      throw std::runtime_error("Table constraints are not supported yet.");
    }
    ColumnDef* coldef = static_cast<ColumnDef*>(e.get());
    ColumnDescriptor cd;
    cd.columnName = *coldef->get_column_name();
    ddl_utils::validate_non_duplicate_column(cd.columnName, uc_col_names);
    setColumnDescriptor(cd, coldef);
    columns.push_back(cd);
  }

  ddl_utils::set_default_table_attributes(*table_, td, columns.size());

  if (shard_key_def) {
    td.shardedColumnId = shard_column_index(shard_key_def->get_column(), columns);
    if (!td.shardedColumnId) {
      throw std::runtime_error("Specified shard column " + shard_key_def->get_column() +
                               " doesn't exist");
    }
  }
  if (is_temporary_) {
    td.persistenceLevel = Data_Namespace::MemoryLevel::CPU_LEVEL;
  } else {
    td.persistenceLevel = Data_Namespace::MemoryLevel::DISK_LEVEL;
  }
  if (!storage_options_.empty()) {
    for (auto& p : storage_options_) {
      get_table_definitions(td, p, columns);
    }
  }
  if (td.shardedColumnId && !td.nShards) {
    throw std::runtime_error("SHARD_COUNT needs to be specified with SHARD_KEY.");
  }
  td.keyMetainfo = serialize_key_metainfo(shard_key_def, shared_dict_defs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const std::string* Parser::CreateTableStmt::get_table ( ) const

inlineoverridevirtual

Implements Parser::CreateTableBaseStmt.

Definition at line 1010 of file ParserNode.h.

References table_.

{ return table_.get(); }

const std::list<std::unique_ptr<TableElement> >& Parser::CreateTableStmt::get_table_element_list ( ) const

inlineoverridevirtual

Implements Parser::CreateTableBaseStmt.

Definition at line 1011 of file ParserNode.h.

References table_element_list_.

                     {
    return table_element_list_;
  }

Member Data Documentation

bool Parser::CreateTableStmt::if_not_exists_

private

Definition at line 1027 of file ParserNode.h.

Referenced by CreateTableStmt(), and execute().

bool Parser::CreateTableStmt::is_temporary_

private

Definition at line 1026 of file ParserNode.h.

Referenced by CreateTableStmt(), and executeDryRun().

std::list<std::unique_ptr<NameValueAssign> > Parser::CreateTableStmt::storage_options_

private

Definition at line 1028 of file ParserNode.h.

Referenced by CreateTableStmt(), and executeDryRun().

std::unique_ptr<std::string> Parser::CreateTableStmt::table_

private

Definition at line 1024 of file ParserNode.h.

Referenced by CreateTableStmt(), execute(), executeDryRun(), and get_table().

std::list<std::unique_ptr<TableElement> > Parser::CreateTableStmt::table_element_list_

private

Definition at line 1025 of file ParserNode.h.

Referenced by CreateTableStmt(), executeDryRun(), and get_table_element_list().

---

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