AlterForeignTableCommand Class Reference

#include <DdlCommandExecutor.h>

Inheritance diagram for AlterForeignTableCommand:

Collaboration diagram for AlterForeignTableCommand:

Public Member Functions
	AlterForeignTableCommand (const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
ExecutionResult	execute (bool read_only_mode) override
Public Member Functions inherited from DdlCommand
	DdlCommand (const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)

Private Member Functions
void	alterOptions (const foreign_storage::ForeignTable &foreign_table)
void	renameTable (const foreign_storage::ForeignTable *foreign_table)
void	renameColumn (const foreign_storage::ForeignTable *foreign_table)

Additional Inherited Members
Protected Attributes inherited from DdlCommand
const DdlCommandData &	ddl_data_
std::shared_ptr < Catalog_Namespace::SessionInfo const >	session_ptr_

Detailed Description

Definition at line 166 of file DdlCommandExecutor.h.

Constructor & Destructor Documentation

AlterForeignTableCommand::AlterForeignTableCommand	(	const DdlCommandData &	ddl_data,
		std::shared_ptr< Catalog_Namespace::SessionInfo const >	session_ptr
	)

Definition at line 3230 of file DdlCommandExecutor.cpp.

References CHECK, DdlCommand::ddl_data_, anonymous_namespace{DdlCommandExecutor.cpp}::extractPayload(), g_enable_fsi, and UNREACHABLE.

    : DdlCommand(ddl_data, session_ptr) {
  if (!g_enable_fsi) {
    throw std::runtime_error("Unsupported command: ALTER FOREIGN TABLE");
  }
  auto& ddl_payload = extractPayload(ddl_data_);
  CHECK(ddl_payload.HasMember("tableName"));
  CHECK(ddl_payload["tableName"].IsString());
  CHECK(ddl_payload.HasMember("alterType"));
  CHECK(ddl_payload["alterType"].IsString());
  if (ddl_payload["alterType"] == "RENAME_TABLE") {
    CHECK(ddl_payload.HasMember("newTableName"));
    CHECK(ddl_payload["newTableName"].IsString());
  } else if (ddl_payload["alterType"] == "RENAME_COLUMN") {
    CHECK(ddl_payload.HasMember("oldColumnName"));
    CHECK(ddl_payload["oldColumnName"].IsString());
    CHECK(ddl_payload.HasMember("newColumnName"));
    CHECK(ddl_payload["newColumnName"].IsString());
  } else if (ddl_payload["alterType"] == "ALTER_OPTIONS") {
    CHECK(ddl_payload.HasMember("options"));
    CHECK(ddl_payload["options"].IsObject());
  } else {
    UNREACHABLE() << "Not a valid alter foreign table command: "
                  << ddl_payload["alterType"].GetString();
  }
}

Here is the call graph for this function:

Member Function Documentation

void AlterForeignTableCommand::alterOptions ( const foreign_storage::ForeignTable &  foreign_table )

private

Definition at line 3344 of file DdlCommandExecutor.cpp.

References cat(), foreign_storage::ForeignTable::createOptionsMap(), DdlCommand::ddl_data_, anonymous_namespace{DdlCommandExecutor.cpp}::extractPayload(), DdlCommand::session_ptr_, foreign_storage::ForeignTable::validateAlterOptions(), and foreign_storage::ForeignTable::validateSupportedOptionKeys().

Referenced by execute().

                                                      {
  auto& ddl_payload = extractPayload(ddl_data_);
  const std::string& table_name = ddl_payload["tableName"].GetString();
  auto& cat = session_ptr_->getCatalog();
  auto new_options_map =
      foreign_storage::ForeignTable::createOptionsMap(ddl_payload["options"]);
  foreign_table.validateSupportedOptionKeys(new_options_map);
  foreign_table.validateAlterOptions(new_options_map);
  cat.setForeignTableOptions(table_name, new_options_map, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ExecutionResult AlterForeignTableCommand::execute ( bool  read_only_mode )

overridevirtual

Executes the DDL command corresponding to provided JSON payload.

Parameters

_return

result of DDL command execution (if applicable)

Implements DdlCommand.

Definition at line 3259 of file DdlCommandExecutor.cpp.

References AccessPrivileges::ALTER_TABLE, alterOptions(), CHECK, DdlCommand::ddl_data_, anonymous_namespace{DdlCommandExecutor.cpp}::extractPayload(), ddl_utils::FOREIGN_TABLE, legacylockmgr::getExecuteReadLock(), legacylockmgr::getExecuteWriteLock(), lockmgr::TableLockMgrImpl< TableDataLockMgr >::getWriteLockForTable(), renameColumn(), renameTable(), DdlCommand::session_ptr_, TableDBObjectType, and ddl_utils::validate_table_type().

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

                                                                     {
  if (read_only_mode) {
    throw std::runtime_error("ALTER FOREIGN TABLE invalid in read only mode.");
  }

  auto& ddl_payload = extractPayload(ddl_data_);
  std::string alter_type = ddl_payload["alterType"].GetString();

  // We only need a write lock if we are renaming a table, otherwise a read lock will do.
  legacylockmgr::ExecutorWriteLock write_lock;
  legacylockmgr::ExecutorReadLock read_lock;

  if (alter_type == "RENAME_TABLE") {
    write_lock = legacylockmgr::getExecuteWriteLock();
  } else {
    read_lock = legacylockmgr::getExecuteReadLock();
  }

  auto& catalog = session_ptr_->getCatalog();
  const std::string& table_name = ddl_payload["tableName"].GetString();
  auto [td, td_with_lock] =
      get_table_descriptor_with_lock<lockmgr::WriteLock>(catalog, table_name, false);

  ddl_utils::validate_table_type(td, ddl_utils::TableType::FOREIGN_TABLE, "ALTER");

  if (!session_ptr_->checkDBAccessPrivileges(
          DBObjectType::TableDBObjectType, AccessPrivileges::ALTER_TABLE, table_name)) {
    throw std::runtime_error(
        "Current user does not have the privilege to alter foreign table: " + table_name);
  }

  auto table_data_write_lock =
      lockmgr::TableDataLockMgr::getWriteLockForTable(catalog, table_name);
  auto foreign_table = dynamic_cast<const foreign_storage::ForeignTable*>(td);
  CHECK(foreign_table);

  // std::string alter_type = ddl_payload["alterType"].GetString();
  if (alter_type == "RENAME_TABLE") {
    renameTable(foreign_table);
  } else if (alter_type == "RENAME_COLUMN") {
    renameColumn(foreign_table);
  } else if (alter_type == "ALTER_OPTIONS") {
    alterOptions(*foreign_table);
  }

  return ExecutionResult();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AlterForeignTableCommand::renameColumn ( const foreign_storage::ForeignTable *  foreign_table )

private

Definition at line 3322 of file DdlCommandExecutor.cpp.

References cat(), DdlCommand::ddl_data_, anonymous_namespace{DdlCommandExecutor.cpp}::extractPayload(), DdlCommand::session_ptr_, and TableDescriptor::tableId.

Referenced by execute().

                                                      {
  auto& ddl_payload = extractPayload(ddl_data_);
  auto& cat = session_ptr_->getCatalog();
  const std::string& old_column_name = ddl_payload["oldColumnName"].GetString();
  const std::string& new_column_name = ddl_payload["newColumnName"].GetString();
  auto column = cat.getMetadataForColumn(foreign_table->tableId, old_column_name);
  if (!column) {
    throw std::runtime_error("Column with name \"" + old_column_name +
                             "\" can not be renamed to \"" + new_column_name + "\". " +
                             "Column with name \"" + old_column_name +
                             "\" does not exist.");
  }
  if (cat.getMetadataForColumn(foreign_table->tableId, new_column_name)) {
    throw std::runtime_error("Column with name \"" + old_column_name +
                             "\" can not be renamed to \"" + new_column_name + "\". " +
                             "A column with name \"" + new_column_name +
                             "\" already exists.");
  }
  cat.renameColumn(foreign_table, column, new_column_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AlterForeignTableCommand::renameTable ( const foreign_storage::ForeignTable *  foreign_table )

private

Definition at line 3307 of file DdlCommandExecutor.cpp.

References cat(), DdlCommand::ddl_data_, anonymous_namespace{DdlCommandExecutor.cpp}::extractPayload(), and DdlCommand::session_ptr_.

Referenced by execute().

                                                      {
  auto& ddl_payload = extractPayload(ddl_data_);
  auto& cat = session_ptr_->getCatalog();
  const std::string& table_name = ddl_payload["tableName"].GetString();
  const std::string& new_table_name = ddl_payload["newTableName"].GetString();
  if (cat.getForeignTable(new_table_name)) {
    throw std::runtime_error("Foreign table with name \"" + table_name +
                             "\" can not be renamed to \"" + new_table_name + "\". " +
                             "A different table with name \"" + new_table_name +
                             "\" already exists.");
  }
  cat.renameTable(foreign_table, new_table_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• /home/jenkins-slave/workspace/core-os-doxygen/Catalog/DdlCommandExecutor.h
• /home/jenkins-slave/workspace/core-os-doxygen/Catalog/DdlCommandExecutor.cpp