AlterTableCommand Class Reference

#include <DdlCommandExecutor.h>

Inheritance diagram for AlterTableCommand:

Collaboration diagram for AlterTableCommand:

Public Member Functions
	AlterTableCommand (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)

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 159 of file DdlCommandExecutor.h.

Constructor & Destructor Documentation

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

Definition at line 2741 of file DdlCommandExecutor.cpp.

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

    : DdlCommand(ddl_data, session_ptr) {
  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());
}

Here is the call graph for this function:

Member Function Documentation

ExecutionResult AlterTableCommand::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 3108 of file DdlCommandExecutor.cpp.

References CHECK, Parser::column_from_json(), DdlCommand::ddl_data_, anonymous_namespace{DdlCommandExecutor.cpp}::extractPayload(), logger::FATAL, json_i64(), json_str(), LOG, DdlCommand::session_ptr_, split(), and run_benchmark_import::type.

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

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

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

  CHECK(ddl_payload.HasMember("alterType"));
  auto type = json_str(ddl_payload["alterType"]);

  if (type == "RENAME_TABLE") {
    CHECK(ddl_payload.HasMember("newTableName"));
    auto newTableName = json_str(ddl_payload["newTableName"]);
    std::unique_ptr<Parser::DDLStmt>(
        new Parser::RenameTableStmt(new std::string(tableName),
                                    new std::string(newTableName)))
        ->execute(*session_ptr_, read_only_mode);
    return {};

  } else if (type == "RENAME_COLUMN") {
    CHECK(ddl_payload.HasMember("columnName"));
    auto columnName = json_str(ddl_payload["columnName"]);
    CHECK(ddl_payload.HasMember("newColumnName"));
    auto newColumnName = json_str(ddl_payload["newColumnName"]);
    std::unique_ptr<Parser::DDLStmt>(
        new Parser::RenameColumnStmt(new std::string(tableName),
                                     new std::string(columnName),
                                     new std::string(newColumnName)))
        ->execute(*session_ptr_, read_only_mode);
    return {};

  } else if (type == "ALTER_COLUMN") {
    return AlterTableAlterColumnCommand{ddl_data_, session_ptr_}.execute(read_only_mode);
  } else if (type == "ADD_COLUMN") {
    CHECK(ddl_payload.HasMember("columnData"));
    CHECK(ddl_payload["columnData"].IsArray());

    // New Columns go into this list
    std::list<Parser::ColumnDef*>* table_element_list_ =
        new std::list<Parser::ColumnDef*>;

    const auto elements = ddl_payload["columnData"].GetArray();
    for (const auto& element : elements) {
      CHECK(element.IsObject());
      CHECK(element.HasMember("type"));
      if (json_str(element["type"]) == "SQL_COLUMN_DECLARATION") {
        auto col_def = Parser::column_from_json(element);
        table_element_list_->emplace_back(col_def.release());
      } else {
        LOG(FATAL) << "Unsupported element type for ALTER TABLE: "
                   << element["type"].GetString();
      }
    }

    std::unique_ptr<Parser::DDLStmt>(
        new Parser::AddColumnStmt(new std::string(tableName), table_element_list_))
        ->execute(*session_ptr_, read_only_mode);
    return {};

  } else if (type == "DROP_COLUMN") {
    CHECK(ddl_payload.HasMember("columnData"));
    auto columnData = json_str(ddl_payload["columnData"]);
    // Convert columnData to std::list<std::string*>*
    //    allocate std::list<> as DropColumnStmt will delete it;
    std::list<std::string*>* cols = new std::list<std::string*>;
    std::vector<std::string> cols1;
    boost::split(cols1, columnData, boost::is_any_of(","));
    for (auto s : cols1) {
      // strip leading/trailing spaces/quotes/single quotes
      boost::algorithm::trim_if(s, boost::is_any_of(" \"'`"));
      std::string* str = new std::string(s);
      cols->emplace_back(str);
    }

    std::unique_ptr<Parser::DDLStmt>(
        new Parser::DropColumnStmt(new std::string(tableName), cols))
        ->execute(*session_ptr_, read_only_mode);
    return {};

  } else if (type == "ALTER_OPTIONS") {
    CHECK(ddl_payload.HasMember("options"));
    const auto& options = ddl_payload["options"];
    if (options.IsObject()) {
      for (auto itr = options.MemberBegin(); itr != options.MemberEnd(); ++itr) {
        std::string* option_name = new std::string(json_str(itr->name));
        Parser::Literal* literal_value;
        if (itr->value.IsString()) {
          std::string literal_string = json_str(itr->value);

          // iff this string can be converted to INT
          //   ... do so because it is necessary for AlterTableParamStmt
          std::size_t sz;
          int iVal = std::stoi(literal_string, &sz);
          if (sz == literal_string.size()) {
            literal_value = new Parser::IntLiteral(iVal);
          } else {
            literal_value = new Parser::StringLiteral(&literal_string);
          }
        } else if (itr->value.IsInt() || itr->value.IsInt64()) {
          literal_value = new Parser::IntLiteral(json_i64(itr->value));
        } else if (itr->value.IsNull()) {
          literal_value = new Parser::NullLiteral();
        } else {
          throw std::runtime_error("Unable to handle literal for " + *option_name);
        }
        CHECK(literal_value);
        Parser::NameValueAssign* nv =
            new Parser::NameValueAssign(option_name, literal_value);
        std::unique_ptr<Parser::DDLStmt>(
            new Parser::AlterTableParamStmt(new std::string(tableName), nv))
            ->execute(*session_ptr_, read_only_mode);
        return {};
      }
    } else {
      CHECK(options.IsNull());
    }
  }

  return ExecutionResult();
}

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