Parser::DropColumnStmt Class Reference

#include <ParserNode.h>

Inheritance diagram for Parser::DropColumnStmt:

Collaboration diagram for Parser::DropColumnStmt:

Public Member Functions
	DropColumnStmt (std::string *tab, std::list< std::string * > *cols)
void	execute (const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
const std::string *	get_table () const
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 < std::string > >	columns_

Detailed Description

Definition at line 1392 of file ParserNode.h.

Constructor & Destructor Documentation

Parser::DropColumnStmt::DropColumnStmt ( std::string *  tab, std::list< std::string * > *  cols  )

inline

Definition at line 1394 of file ParserNode.h.

References columns_.

                                                            : table_(tab) {
    for (const auto col : *cols) {
      this->columns_.emplace_back(col);
    }
    delete cols;
  }

Member Function Documentation

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

overridevirtual

Implements Parser::DDLStmt.

Definition at line 5214 of file ParserNode.cpp.

References CHECK, Parser::check_alter_table_privilege(), Executor::clearExternalCaches(), ColumnDescriptor::columnId, ColumnDescriptor::columnName, columns_, ColumnDescriptor::columnType, Data_Namespace::DISK_LEVEL, legacylockmgr::ExecutorOuterLock, g_test_drop_column_rollback, SQLTypeInfo::get_physical_cols(), Catalog_Namespace::SessionInfo::getCatalog(), legacylockmgr::LockMgr< MutexType, KeyType >::getMutex(), TableDescriptor::hasDeletedCol, TableDescriptor::isView, TableDescriptor::nColumns, TableDescriptor::nShards, TableDescriptor::persistenceLevel, TableDescriptor::shardedColumnId, ddl_utils::TABLE, table_, table_is_temporary(), TableDescriptor::tableId, and ddl_utils::validate_table_type().

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

                                                  {
  if (read_only_mode) {
    throw std::runtime_error("DROP COLUMN invalid in read only mode.");
  }
  // TODO: Review add and drop column implementation
  const auto execute_write_lock =
      heavyai::unique_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::WriteLock>::acquireTableDescriptor(
          catalog, *table_, true);
  const auto td = td_with_lock();
  if (!td) {
    throw std::runtime_error("Table " + *table_ + " does not exist.");
  }
  validate_table_type(td, ddl_utils::TableType::TABLE, "ALTER");
  if (td->isView) {
    throw std::runtime_error("Dropping a column from a view is not supported.");
  }
  if (table_is_temporary(td)) {
    throw std::runtime_error(
        "Dropping a column from a temporary table is not yet supported.");
  }

  check_alter_table_privilege(session, td);

  for (const auto& column : columns_) {
    if (nullptr == catalog.getMetadataForColumn(td->tableId, *column)) {
      throw std::runtime_error("Column " + *column + " does not exist.");
    }
  }

  if (td->nColumns <= (td->hasDeletedCol ? 3 : 2)) {
    throw std::runtime_error("Table " + *table_ + " has only one column.");
  }

  // invalidate cached item
  Executor::clearExternalCaches(false, td, catalog.getCurrentDB().dbId);

  catalog.getSqliteConnector().query("BEGIN TRANSACTION");
  try {
    std::vector<int> columnIds;
    for (const auto& column : columns_) {
      ColumnDescriptor cd = *catalog.getMetadataForColumn(td->tableId, *column);
      if (td->nShards > 0 && td->shardedColumnId == cd.columnId) {
        throw std::runtime_error("Dropping sharding column " + cd.columnName +
                                 " is not supported.");
      }
      catalog.dropColumn(*td, cd);
      columnIds.push_back(cd.columnId);
      for (int i = 0; i < cd.columnType.get_physical_cols(); i++) {
        const auto pcd = catalog.getMetadataForColumn(td->tableId, cd.columnId + i + 1);
        CHECK(pcd);
        catalog.dropColumn(*td, *pcd);
        columnIds.push_back(cd.columnId + i + 1);
      }
    }

    for (auto shard : catalog.getPhysicalTablesDescriptors(td)) {
      shard->fragmenter->dropColumns(columnIds);
    }
    // if test forces to rollback
    if (g_test_drop_column_rollback) {
      throw std::runtime_error("lol!");
    }
    catalog.roll(true);
    if (td->persistenceLevel == Data_Namespace::MemoryLevel::DISK_LEVEL) {
      catalog.resetTableEpochFloor(td->tableId);
      catalog.checkpoint(td->tableId);
    }
    catalog.getSqliteConnector().query("END TRANSACTION");
  } catch (...) {
    catalog.setForReload(td->tableId);
    catalog.roll(false);
    catalog.getSqliteConnector().query("ROLLBACK TRANSACTION");
    throw;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

inline

Definition at line 1402 of file ParserNode.h.

References table_.

{ return table_.get(); }

Member Data Documentation

std::list<std::unique_ptr<std::string> > Parser::DropColumnStmt::columns_

private

Definition at line 1406 of file ParserNode.h.

Referenced by DropColumnStmt(), and execute().

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

private

Definition at line 1405 of file ParserNode.h.

Referenced by execute(), and get_table().

---

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