#include <DdlCommandExecutor.h>

Inheritance diagram for AlterTableAlterColumnCommand:

Collaboration diagram for AlterTableAlterColumnCommand:

Public Types
using	TypePairs = alter_column_shared::TypePairs

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

void	populateAndWriteRecoveryInfo (const TableDescriptor *td, const TypePairs &src_dst_cds)

void	cleanupRecoveryInfo (const TableDescriptor *td)

void	alterColumnTypes (const TableDescriptor *td, const TypePairs &src_dst_cds)

void	collectExpectedCatalogChanges (const TableDescriptor *td, const TypePairs &src_dst_cds)

std::list< std::list < ColumnDescriptor > >	prepareGeoColumns (const TableDescriptor *td, const TypePairs &src_dst_cds)

std::list< const ColumnDescriptor * >	prepareColumns (const TableDescriptor *td, const TypePairs &src_dst_cds)

void	alterColumns (const TableDescriptor *td, const TypePairs &src_dst_cds)

void	alterNonGeoColumnData (const TableDescriptor td, const std::list< const ColumnDescriptor > &cds)

void	alterGeoColumnData (const TableDescriptor td, const std::list< std::pair< const ColumnDescriptor , std::list< const ColumnDescriptor * >>> &geo_src_dst_cds)

void	clearInMemoryData (const TableDescriptor *td, const TypePairs &src_dst_cds)

Private Attributes
AlterTableAlterColumnCommandRecoveryMgr::RecoveryInfo	recovery_info_

AlterTableAlterColumnCommandRecoveryMgr	recovery_mgr_

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

Member Typedef Documentation

using AlterTableAlterColumnCommand::TypePairs = alter_column_shared::TypePairs

Definition at line 122 of file DdlCommandExecutor.h.

Constructor & Destructor Documentation

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

Definition at line 2754 of file DdlCommandExecutor.cpp.

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

     : DdlCommand(ddl_data, session_ptr)
     , recovery_mgr_(session_ptr->getCatalog())
 
 {
   auto& ddl_payload = extractPayload(ddl_data_);
 
   CHECK_EQ(std::string(ddl_payload["alterType"].GetString()), "ALTER_COLUMN");
 
   CHECK(ddl_payload.HasMember("alterData"));
   CHECK(ddl_payload["alterData"].IsArray());
 
   const auto elements = ddl_payload["alterData"].GetArray();
   for (const auto& element : elements) {
     CHECK(element.HasMember("type"));
     CHECK(element["type"].IsString());
     CHECK_EQ(std::string(element["type"].GetString()), "SQL_COLUMN_DECLARATION");
 
     CHECK(element.HasMember("name"));
     CHECK(element["name"].IsString());
 
     CHECK(element.HasMember("default"));
 
     CHECK(element.HasMember("nullable"));
     CHECK(element["nullable"].IsBool());
 
     CHECK(element.HasMember("encodingType"));
     CHECK(element.HasMember("encodingSize"));
 
     CHECK(element.HasMember("sqltype"));
     CHECK(element["sqltype"].IsString());
   }
 }

Here is the call graph for this function:

Member Function Documentation

void AlterTableAlterColumnCommand::alterColumn ( )

private

Definition at line 3030 of file DdlCommandExecutor.cpp.

References alterColumnTypes(), CHECK, Parser::check_alter_table_privilege(), DdlCommand::ddl_data_, anonymous_namespace{DdlCommandExecutor.cpp}::extractPayload(), anonymous_namespace{DdlCommandExecutor.cpp}::get_alter_column_pairs_from_src_dst_cds(), anonymous_namespace{DdlCommandExecutor.cpp}::get_alter_column_src_dst_cds(), Parser::get_columns_from_json_payload(), DdlCommand::session_ptr_, ddl_utils::TABLE, table_is_temporary(), and ddl_utils::validate_table_type().

Referenced by execute().

                                                {
   auto& ddl_payload = extractPayload(ddl_data_);
   const auto tableName = std::string(ddl_payload["tableName"].GetString());
 
   auto columns = Parser::get_columns_from_json_payload("alterData", ddl_payload);
 
   auto& catalog = session_ptr_->getCatalog();
   const auto td_with_lock =
       lockmgr::TableSchemaLockContainer<lockmgr::WriteLock>::acquireTableDescriptor(
           catalog, tableName, true);
   const auto td = td_with_lock();
 
   if (!td) {
     throw std::runtime_error("Table " + tableName + " does not exist.");
   } else {
     if (td->isView) {
       throw std::runtime_error("Altering columns in a view is not supported.");
     }
     validate_table_type(td, ddl_utils::TableType::TABLE, "ALTER");
     if (table_is_temporary(td)) {
       throw std::runtime_error("Altering columns in temporary tables is not supported.");
     }
   }
 
   Parser::check_alter_table_privilege(*session_ptr_, td);
 
   for (const auto& coldef : columns) {
     const auto& column_name = *coldef.get_column_name();
     if (catalog.getMetadataForColumn(td->tableId, column_name) == nullptr) {
       throw std::runtime_error("Column " + column_name + " does not exist.");
     }
   }
 
   CHECK(td->fragmenter);
   if (td->sortedColumnId) {
     throw std::runtime_error(
         "Altering columns to a table is not supported when using the \"sort_column\" "
         "option.");
   }
 
   auto [src_cds, dst_cds] = get_alter_column_src_dst_cds(columns, catalog, td);
   alterColumnTypes(td, get_alter_column_pairs_from_src_dst_cds(src_cds, dst_cds));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AlterTableAlterColumnCommand::alterColumns	(	const TableDescriptor *	td,
		const TypePairs &	src_dst_cds
	)

private

Definition at line 2790 of file DdlCommandExecutor.cpp.

References CHECK, ddl_utils::alter_column_utils::compare_column_descriptors(), and DdlCommand::session_ptr_.

Referenced by alterColumnTypes().

                                                                               {
   auto& catalog = session_ptr_->getCatalog();
 
   for (auto& [src_cd, dst_cd] : src_dst_cds) {
     if (dst_cd->columnType.is_geometry()) {
       continue;
     }
     auto compare_result =
         ddl_utils::alter_column_utils::compare_column_descriptors(src_cd, dst_cd);
     CHECK(!compare_result.sql_types_match || !compare_result.defaults_match);
 
     catalog.alterColumnTypeTransactional(*dst_cd);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AlterTableAlterColumnCommand::alterColumnTypes	(	const TableDescriptor *	td,
		const TypePairs &	src_dst_cds
	)

private

Definition at line 2980 of file DdlCommandExecutor.cpp.

References alterColumns(), alterGeoColumnData(), alterNonGeoColumnData(), AlterTableAlterColumnCommandRecoveryMgr::checkpoint(), AlterTableAlterColumnCommandRecoveryMgr::cleanup(), cleanupRecoveryInfo(), clearInMemoryData(), logger::FATAL, anonymous_namespace{DdlCommandExecutor.cpp}::get_alter_column_geo_pairs_from_src_dst_pairs_phys_cds(), LOG, populateAndWriteRecoveryInfo(), prepareColumns(), prepareGeoColumns(), recovery_info_, recovery_mgr_, AlterTableAlterColumnCommandRecoveryMgr::rollback(), DdlCommand::session_ptr_, TableDescriptor::tableId, and anonymous_namespace{DdlCommandExecutor.cpp}::vacuum_table_if_required().

Referenced by alterColumn().

                                                                                   {
   auto& catalog = session_ptr_->getCatalog();
 
   auto table_epochs = catalog.getTableEpochs(catalog.getDatabaseId(), td->tableId);
 
   populateAndWriteRecoveryInfo(td, src_dst_cds);
 
   try {
     // Apply a vacuum operation prior to alter column when applicable
     vacuum_table_if_required(catalog, td);
 
     auto physical_columns = prepareGeoColumns(td, src_dst_cds);
     auto geo_src_dst_column_pairs =
         get_alter_column_geo_pairs_from_src_dst_pairs_phys_cds(src_dst_cds,
                                                                physical_columns);
 
     auto non_geo_cds = prepareColumns(td, src_dst_cds);
 
     alterGeoColumnData(td, geo_src_dst_column_pairs);
     alterNonGeoColumnData(td, non_geo_cds);
 
     alterColumns(td, src_dst_cds);
 
     // First checkpoint is for added/altered data, rollback is possible
     recovery_mgr_.checkpoint(td, src_dst_cds);
 
   } catch (std::exception& except) {
     catalog.setTableEpochs(catalog.getDatabaseId(), table_epochs);
     clearInMemoryData(td, src_dst_cds);
     recovery_mgr_.rollback(td, recovery_info_);
     cleanupRecoveryInfo(td);
     throw std::runtime_error("Alter column type: " + std::string(except.what()));
   }
 
   // After the last checkpoint, the following operations are non-reversible,
   // when recovering from a crash will be required to finish
   try {
     recovery_mgr_.cleanup(td, src_dst_cds);
   } catch (std::exception& except) {
     // Any exception encountered during the last steps is unexpected and will cause a
     // crash, relying on the recovery process to fix resulting issues
     LOG(FATAL) << "Alter column type: encountered fatal error during finalizing: "
                << except.what();
   }
 
   clearInMemoryData(td, src_dst_cds);
   cleanupRecoveryInfo(td);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AlterTableAlterColumnCommand::alterGeoColumnData	(	const TableDescriptor *	td,
		const std::list< std::pair< const ColumnDescriptor , std::list< const ColumnDescriptor >>> &	geo_src_dst_cds
	)

private

Definition at line 2873 of file DdlCommandExecutor.cpp.

References CHECK, and TableDescriptor::fragmenter.

Referenced by alterColumnTypes().

                                                                                    {
   if (geo_src_dst_cds.empty()) {
     return;
   }
   auto fragmenter = td->fragmenter;
   CHECK(fragmenter);
   auto io_fragmenter =
       dynamic_cast<Fragmenter_Namespace::InsertOrderFragmenter*>(fragmenter.get());
   CHECK(io_fragmenter);
   io_fragmenter->alterColumnGeoType(geo_src_dst_cds);
 }

Here is the caller graph for this function:

void AlterTableAlterColumnCommand::alterNonGeoColumnData	(	const TableDescriptor *	td,
		const std::list< const ColumnDescriptor * > &	cds
	)

private

Definition at line 2859 of file DdlCommandExecutor.cpp.

References CHECK, and TableDescriptor::fragmenter.

Referenced by alterColumnTypes().

                                                  {
   if (cds.empty()) {
     return;
   }
   auto fragmenter = td->fragmenter;
   CHECK(fragmenter);
   auto io_fragmenter =
       dynamic_cast<Fragmenter_Namespace::InsertOrderFragmenter*>(fragmenter.get());
   CHECK(io_fragmenter);
   io_fragmenter->alterNonGeoColumnType(cds);
 }

Here is the caller graph for this function:

void AlterTableAlterColumnCommand::cleanupRecoveryInfo ( const TableDescriptor * td )

private

Definition at line 2950 of file DdlCommandExecutor.cpp.

References AlterTableAlterColumnCommandRecoveryMgr::getRecoveryFilepathInfo(), recovery_mgr_, AlterTableAlterColumnCommandRecoveryMgr::recoveryFilepath(), and TableDescriptor::tableId.

Referenced by alterColumnTypes().

                                                                                 {
   auto recovery_file_info = recovery_mgr_.getRecoveryFilepathInfo(td->tableId);
   auto recovery_filepath = recovery_mgr_.recoveryFilepath(recovery_file_info);
 
   if (std::filesystem::exists(recovery_filepath)) {
     std::filesystem::remove(recovery_filepath);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AlterTableAlterColumnCommand::clearInMemoryData	(	const TableDescriptor *	td,
		const TypePairs &	src_dst_cds
	)

private

Definition at line 2888 of file DdlCommandExecutor.cpp.

References Executor::clearExternalCaches(), Data_Namespace::CPU_LEVEL, Data_Namespace::GPU_LEVEL, DdlCommand::session_ptr_, and TableDescriptor::tableId.

Referenced by alterColumnTypes().

                                                                                    {
   auto& catalog = session_ptr_->getCatalog();
 
   ChunkKey column_key{catalog.getCurrentDB().dbId, td->tableId, 0};
   Executor::clearExternalCaches(true, td, catalog.getDatabaseId());
   column_key.resize(3);
   for (auto& [src_cd, _] : src_dst_cds) {
     column_key[2] = src_cd->columnId;
     catalog.getDataMgr().deleteChunksWithPrefix(column_key, MemoryLevel::GPU_LEVEL);
     catalog.getDataMgr().deleteChunksWithPrefix(column_key, MemoryLevel::CPU_LEVEL);
   }
 
   catalog.removeFragmenterForTable(td->tableId);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AlterTableAlterColumnCommand::collectExpectedCatalogChanges	(	const TableDescriptor *	td,
		const TypePairs &	src_dst_cds
	)

private

Definition at line 2904 of file DdlCommandExecutor.cpp.

References AlterTableAlterColumnCommandRecoveryMgr::RecoveryInfo::added_columns, AlterTableAlterColumnCommandRecoveryMgr::RecoveryInfo::altered_columns, CHECK, ColumnDescriptor::columnId, ddl_utils::alter_column_utils::compare_column_descriptors(), recovery_info_, AlterTableAlterColumnCommandRecoveryMgr::RecoveryInfo::renamed_columns, DdlCommand::session_ptr_, ddl_utils::alter_column_utils::CompareResult::sql_types_match, ColumnDescriptor::tableId, TableDescriptor::tableId, and AlterTableAlterColumnCommandRecoveryMgr::RecoveryInfo::updated_dict_cds.

Referenced by populateAndWriteRecoveryInfo().

                                                               {
   auto& catalog = session_ptr_->getCatalog();
 
   auto column_id_start = catalog.getNextAddedColumnId(*td);
   auto current_column_id = column_id_start;
 
   // Simulate operations required for geo changes
   for (auto& [src_cd, dst_cd] : src_dst_cds) {
     if (dst_cd->columnType.is_geometry()) {
       recovery_info_.renamed_columns.push_back(*src_cd);
 
       std::list<ColumnDescriptor> phy_geo_columns;
       catalog.expandGeoColumn(*dst_cd, phy_geo_columns);
 
       auto col_to_add = *dst_cd;
       col_to_add.tableId = td->tableId;
       col_to_add.columnId = current_column_id++;
       recovery_info_.added_columns.push_back(col_to_add);
 
       for (auto& cd : phy_geo_columns) {
         ColumnDescriptor phys_col_to_add = cd;
         phys_col_to_add.tableId = td->tableId;
         phys_col_to_add.columnId = current_column_id++;
         recovery_info_.added_columns.push_back(phys_col_to_add);
       }
     } else if (dst_cd->columnType.is_dict_encoded_type()) {
       if (!ddl_utils::alter_column_utils::compare_column_descriptors(src_cd, dst_cd)
                .sql_types_match) {
         recovery_info_.updated_dict_cds.push_back(*src_cd);
       }
     }
   }
 
   for (auto& [src_cd, dst_cd] : src_dst_cds) {
     if (dst_cd->columnType.is_geometry()) {
       continue;
     }
     auto compare_result =
         ddl_utils::alter_column_utils::compare_column_descriptors(src_cd, dst_cd);
     CHECK(!compare_result.sql_types_match || !compare_result.defaults_match);
     recovery_info_.altered_columns.emplace_back(*src_cd, *dst_cd);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ExecutionResult AlterTableAlterColumnCommand::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 3074 of file DdlCommandExecutor.cpp.

References alterColumn(), g_cluster, and legacylockmgr::getExecuteReadLock().

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

                                                                          {
   if (g_cluster) {
     throw std::runtime_error(
         "ALTER TABLE ALTER COLUMN is unsupported in distributed mode.");
   }
 
   // NOTE: read_only_mode is validated at a higher level in AlterTableCommand
 
   // TODO: Refactor this lock when refactoring other ALTER TABLE commands
   const auto execute_read_lock = legacylockmgr::getExecuteReadLock();
 
   // There are a few major cases to consider when alter column is invoked.
   // Below non variable length column is abbreviated as NVL and a variable
   // length column is abbreviated as VL.
   //
   // 1. A NVL -> NVL or VL -> VL column conversion.
   //
   // 2. A NVL -> VL or VL -> NVL column conversion.
   //
   // 3. A VL/NVL column converted to a Geo column.
   //
   // Case (1) is the simplest since chunks do not change their chunk keys.
   //
   // Case (2) requires that the chunk keys are added or removed (typically the
   // index chunk), and this requires special treatment.
   //
   // Case (3) requires temporarily renaming the source column, creating new Geo
   // columns, populating the destination Geo columns and dropping the source
   // column.
 
   alterColumn();
   return {};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AlterTableAlterColumnCommand::populateAndWriteRecoveryInfo	(	const TableDescriptor *	td,
		const TypePairs &	src_dst_cds
	)

private

Definition at line 2959 of file DdlCommandExecutor.cpp.

References CHECK_GT, collectExpectedCatalogChanges(), AlterTableAlterColumnCommandRecoveryMgr::getRecoveryFilepathInfo(), TableDescriptor::hasDeletedCol, AlterTableAlterColumnCommandRecoveryMgr::RecoveryInfo::is_vacuumed, recovery_info_, recovery_mgr_, AlterTableAlterColumnCommandRecoveryMgr::recoveryFilepath(), DdlCommand::session_ptr_, AlterTableAlterColumnCommandRecoveryMgr::RecoveryInfo::src_dst_cds, AlterTableAlterColumnCommandRecoveryMgr::RecoveryInfo::table_epoch, TableDescriptor::tableId, and AlterTableAlterColumnCommandRecoveryMgr::writeSerializedRecoveryInformation().

Referenced by alterColumnTypes().

                                   {
   auto& catalog = session_ptr_->getCatalog();
 
   auto table_epochs = catalog.getTableEpochs(catalog.getDatabaseId(), td->tableId);
   CHECK_GT(table_epochs.size(), 0UL);
   recovery_info_.table_epoch = table_epochs[0].table_epoch;
   recovery_info_.is_vacuumed = td->hasDeletedCol;
 
   collectExpectedCatalogChanges(td, src_dst_cds);
 
   for (const auto& [src_cd, dst_cd] : src_dst_cds) {
     recovery_info_.src_dst_cds.emplace_back(*src_cd, *dst_cd);
   }
 
   auto recovery_file_info = recovery_mgr_.getRecoveryFilepathInfo(td->tableId);
   auto recovery_filepath = recovery_mgr_.recoveryFilepath(recovery_file_info);
   recovery_mgr_.writeSerializedRecoveryInformation(recovery_info_, recovery_file_info);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::list< const ColumnDescriptor * > AlterTableAlterColumnCommand::prepareColumns	(	const TableDescriptor *	td,
		const TypePairs &	src_dst_cds
	)

private

Definition at line 2806 of file DdlCommandExecutor.cpp.

References ddl_utils::alter_column_utils::compare_column_descriptors(), and DdlCommand::session_ptr_.

Referenced by alterColumnTypes().

                                   {
   auto& catalog = session_ptr_->getCatalog();
 
   std::list<const ColumnDescriptor*> non_geo_cds;
   for (auto& [src_cd, dst_cd] : src_dst_cds) {
     if (dst_cd->columnType.is_geometry()) {
       continue;
     }
     non_geo_cds.emplace_back(dst_cd);
 
     auto compare_result =
         ddl_utils::alter_column_utils::compare_column_descriptors(src_cd, dst_cd);
     if (compare_result.sql_types_match) {
       continue;
     }
 
     if (dst_cd->columnType.is_dict_encoded_type()) {
       catalog.addDictionaryTransactional(*dst_cd);
     }
   }
 
   return non_geo_cds;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::list< std::list< ColumnDescriptor > > AlterTableAlterColumnCommand::prepareGeoColumns	(	const TableDescriptor *	td,
		const TypePairs &	src_dst_cds
	)

private

Definition at line 2832 of file DdlCommandExecutor.cpp.

References DdlCommand::session_ptr_, and to_string().

Referenced by alterColumnTypes().

                                   {
   auto& catalog = session_ptr_->getCatalog();
   std::list<std::list<ColumnDescriptor>> physical_geo_columns;
 
   for (auto& [src_cd, dst_cd] : src_dst_cds) {
     if (dst_cd->columnType.is_geometry()) {
       std::string col_name = src_cd->columnName;
       auto uuid = boost::uuids::random_generator()();
       catalog.renameColumn(td, src_cd, col_name + "_" + boost::uuids::to_string(uuid));
 
       physical_geo_columns.emplace_back();
       std::list<ColumnDescriptor>& phy_geo_columns = physical_geo_columns.back();
       catalog.expandGeoColumn(*dst_cd, phy_geo_columns);
 
       catalog.addColumnTransactional(*td, *dst_cd);
 
       for (auto& cd : phy_geo_columns) {
         catalog.addColumnTransactional(*td, cd);
       }
     }
   }
 
   return physical_geo_columns;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

AlterTableAlterColumnCommandRecoveryMgr::RecoveryInfo AlterTableAlterColumnCommand::recovery_info_

private

Definition at line 155 of file DdlCommandExecutor.h.

Referenced by alterColumnTypes(), collectExpectedCatalogChanges(), and populateAndWriteRecoveryInfo().

AlterTableAlterColumnCommandRecoveryMgr AlterTableAlterColumnCommand::recovery_mgr_

private

Definition at line 156 of file DdlCommandExecutor.h.

Referenced by alterColumnTypes(), cleanupRecoveryInfo(), and populateAndWriteRecoveryInfo().

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation