anonymous_namespace{DdlCommandExecutor.cpp} Namespace Reference

Classes
struct	AggregratedStorageStats
class	JsonColumnSqlType
	declare this class scoped local to avoid exposing rapidjson in the header file More...
class	JsonColumnEncoding
class	DdlCommandDataImpl

Functions
void	vacuum_table_if_required (const Catalog_Namespace::Catalog &catalog, const TableDescriptor *td)
void	validate_alter_type_allowed (const std::string &colname, const SQLTypeInfo &src, const SQLTypeInfo &dst)
void	validate_alter_type_metadata (const Catalog_Namespace::Catalog &catalog, const TableDescriptor *td, const ColumnDescriptor &cd)
std::list< std::pair< const ColumnDescriptor *, std::list < const ColumnDescriptor * > > >	get_alter_column_geo_pairs_from_src_dst_pairs_phys_cds (const AlterTableAlterColumnCommand::TypePairs &src_dst_cds, const std::list< std::list< ColumnDescriptor >> &phys_cds)
AlterTableAlterColumnCommand::TypePairs	get_alter_column_pairs_from_src_dst_cds (std::list< ColumnDescriptor > &src_cds, std::list< ColumnDescriptor > &dst_cds)
std::pair< std::list < ColumnDescriptor > , std::list< ColumnDescriptor > >	get_alter_column_src_dst_cds (const std::list< Parser::ColumnDef > &columns, Catalog_Namespace::Catalog &catalog, const TableDescriptor *td)
template<class LockType >
std::tuple< const TableDescriptor *, std::unique_ptr < lockmgr::TableSchemaLockContainer < LockType > > >	get_table_descriptor_with_lock (Catalog_Namespace::Catalog &cat, const std::string &table_name, const bool populate_fragmenter)
template<class Func >
void	exec_for_tables_which_exist (const std::vector< std::string > &table_names, Catalog_Namespace::Catalog *cat_ptr, Func func)
AggregratedStorageStats	get_agg_storage_stats (const TableDescriptor *td, const Catalog_Namespace::Catalog *catalog)
std::unique_ptr< RexLiteral >	genLiteralStr (std::string val)
std::unique_ptr< RexLiteral >	genLiteralTimestamp (time_t val)
std::unique_ptr< RexLiteral >	genLiteralBigInt (int64_t val)
std::unique_ptr< RexLiteral >	genLiteralDouble (double val)
std::unique_ptr< RexLiteral >	genLiteralBoolean (bool val)
void	set_headers_with_type (std::vector< TargetMetaInfo > &label_infos, const std::vector< std::tuple< std::string, SQLTypes, bool >> &headers)
void	add_table_details (std::vector< RelLogicalValues::RowValues > &logical_values, const TableDescriptor *logical_table, const AggregratedStorageStats &agg_storage_stats)
const rapidjson::Value &	extractPayload (const DdlCommandData &ddl_data)
const rapidjson::Value *	extractFilters (const rapidjson::Value &payload)
bool	is_default_server (const std::string &server_name)
void	throw_reserved_server_prefix_exception ()

Variables
const std::array< std::string, 3 >	kReservedServerPrefixes {"default", "system", "internal"}

Function Documentation

void anonymous_namespace{DdlCommandExecutor.cpp}::add_table_details	(	std::vector< RelLogicalValues::RowValues > &	logical_values,
		const TableDescriptor *	logical_table,
		const AggregratedStorageStats &	agg_storage_stats
	)

Definition at line 356 of file DdlCommandExecutor.cpp.

References File_Namespace::StorageStats::data_file_count, genLiteralBigInt(), genLiteralBoolean(), genLiteralStr(), anonymous_namespace{DdlCommandExecutor.cpp}::AggregratedStorageStats::max_epoch, anonymous_namespace{DdlCommandExecutor.cpp}::AggregratedStorageStats::max_epoch_floor, TableDescriptor::maxFragRows, TableDescriptor::maxRollbackEpochs, TableDescriptor::maxRows, File_Namespace::StorageStats::metadata_file_count, anonymous_namespace{DdlCommandExecutor.cpp}::AggregratedStorageStats::min_epoch, anonymous_namespace{DdlCommandExecutor.cpp}::AggregratedStorageStats::min_epoch_floor, TableDescriptor::nColumns, TableDescriptor::nShards, NULL_BIGINT, TableDescriptor::tableId, TableDescriptor::tableName, File_Namespace::StorageStats::total_data_file_size, File_Namespace::StorageStats::total_data_page_count, File_Namespace::StorageStats::total_free_data_page_count, File_Namespace::StorageStats::total_free_metadata_page_count, File_Namespace::StorageStats::total_metadata_file_size, and File_Namespace::StorageStats::total_metadata_page_count.

Referenced by ShowTableDetailsCommand::execute().

                                                                         {
  bool is_sharded_table = (logical_table->nShards > 0);
  logical_values.emplace_back(RelLogicalValues::RowValues{});
  logical_values.back().emplace_back(genLiteralBigInt(logical_table->tableId));
  logical_values.back().emplace_back(genLiteralStr(logical_table->tableName));
  logical_values.back().emplace_back(genLiteralBigInt(logical_table->nColumns));
  logical_values.back().emplace_back(genLiteralBoolean(is_sharded_table));
  logical_values.back().emplace_back(genLiteralBigInt(logical_table->nShards));
  logical_values.back().emplace_back(genLiteralBigInt(logical_table->maxRows));
  logical_values.back().emplace_back(genLiteralBigInt(logical_table->maxFragRows));
  logical_values.back().emplace_back(genLiteralBigInt(logical_table->maxRollbackEpochs));
  logical_values.back().emplace_back(genLiteralBigInt(agg_storage_stats.min_epoch));
  logical_values.back().emplace_back(genLiteralBigInt(agg_storage_stats.max_epoch));
  logical_values.back().emplace_back(genLiteralBigInt(agg_storage_stats.min_epoch_floor));
  logical_values.back().emplace_back(genLiteralBigInt(agg_storage_stats.max_epoch_floor));
  logical_values.back().emplace_back(
      genLiteralBigInt(agg_storage_stats.metadata_file_count));
  logical_values.back().emplace_back(
      genLiteralBigInt(agg_storage_stats.total_metadata_file_size));
  logical_values.back().emplace_back(
      genLiteralBigInt(agg_storage_stats.total_metadata_page_count));

  if (agg_storage_stats.total_free_metadata_page_count) {
    logical_values.back().emplace_back(
        genLiteralBigInt(agg_storage_stats.total_free_metadata_page_count.value()));
  } else {
    logical_values.back().emplace_back(genLiteralBigInt(NULL_BIGINT));
  }

  logical_values.back().emplace_back(genLiteralBigInt(agg_storage_stats.data_file_count));
  logical_values.back().emplace_back(
      genLiteralBigInt(agg_storage_stats.total_data_file_size));
  logical_values.back().emplace_back(
      genLiteralBigInt(agg_storage_stats.total_data_page_count));

  if (agg_storage_stats.total_free_data_page_count) {
    logical_values.back().emplace_back(
        genLiteralBigInt(agg_storage_stats.total_free_data_page_count.value()));
  } else {
    logical_values.back().emplace_back(genLiteralBigInt(NULL_BIGINT));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class Func >

void anonymous_namespace{DdlCommandExecutor.cpp}::exec_for_tables_which_exist	(	const std::vector< std::string > &	table_names,
		Catalog_Namespace::Catalog *	cat_ptr,
		Func	func
	)

Definition at line 235 of file DdlCommandExecutor.cpp.

Referenced by ShowTableDetailsCommand::execute(), ShowDiskCacheUsageCommand::execute(), and ShowTableDetailsCommand::getFilteredTableNames().

                                            {
  for (const auto& table_name : table_names) {
    try {
      auto [td, td_with_lock] =
          get_table_descriptor_with_lock<lockmgr::ReadLock>(*cat_ptr, table_name, false);
      func(td, table_name);
    } catch (const Catalog_Namespace::TableNotFoundException& e) {
      continue;
    }
  }
}

Here is the caller graph for this function:

const rapidjson::Value* anonymous_namespace{DdlCommandExecutor.cpp}::extractFilters

(

const rapidjson::Value &

payload

)

Definition at line 493 of file DdlCommandExecutor.cpp.

Referenced by ShowForeignServersCommand::execute().

                                                                    {
  const rapidjson::Value* filters = nullptr;
  if (payload.HasMember("filters") && payload["filters"].IsArray()) {
    filters = &payload["filters"];
  }
  return filters;
}

Here is the caller graph for this function:

const rapidjson::Value& anonymous_namespace{DdlCommandExecutor.cpp}::extractPayload

(

const DdlCommandData &

ddl_data

)

Definition at line 488 of file DdlCommandExecutor.cpp.

References anonymous_namespace{DdlCommandExecutor.cpp}::DdlCommandDataImpl::payload().

Referenced by AlterTableAlterColumnCommand::alterColumn(), AlterDatabaseCommand::AlterDatabaseCommand(), AlterForeignServerCommand::AlterForeignServerCommand(), AlterForeignTableCommand::AlterForeignTableCommand(), AlterForeignTableCommand::alterOptions(), AlterTableAlterColumnCommand::AlterTableAlterColumnCommand(), AlterTableCommand::AlterTableCommand(), AlterForeignServerCommand::changeForeignServerOwner(), AlterDatabaseCommand::changeOwner(), CreateForeignServerCommand::CreateForeignServerCommand(), CreateForeignTableCommand::CreateForeignTableCommand(), DropForeignServerCommand::DropForeignServerCommand(), DropForeignTableCommand::DropForeignTableCommand(), CreateForeignServerCommand::execute(), AlterForeignServerCommand::execute(), DropForeignServerCommand::execute(), CreateForeignTableCommand::execute(), DropForeignTableCommand::execute(), AlterTableCommand::execute(), AlterForeignTableCommand::execute(), ShowForeignServersCommand::execute(), ShowCreateTableCommand::execute(), ShowFunctionsCommand::execute(), ShowTableFunctionsCommand::execute(), ShowModelFeatureDetailsCommand::execute(), EvaluateModelCommand::execute(), ShowUserDetailsCommand::execute(), ShowRolesCommand::execute(), RefreshForeignTablesCommand::execute(), AlterDatabaseCommand::execute(), DdlCommandExecutor::execute(), DdlCommandExecutor::getDistributedExecutionDetails(), ShowModelDetailsCommand::getFilteredModelNames(), ShowTableDetailsCommand::getFilteredTableNames(), ShowDiskCacheUsageCommand::getFilteredTableNames(), DdlCommandExecutor::getSessionParameter(), DdlCommandExecutor::getTargetQuerySessionToKill(), AlterForeignServerCommand::hasAlterServerPrivileges(), ReassignOwnedCommand::ReassignOwnedCommand(), RefreshForeignTablesCommand::RefreshForeignTablesCommand(), AlterDatabaseCommand::rename(), AlterForeignTableCommand::renameColumn(), AlterForeignServerCommand::renameForeignServer(), AlterForeignTableCommand::renameTable(), DdlCommandExecutor::returnCacheType(), DdlCommandExecutor::returnQueueAction(), CreateForeignTableCommand::setColumnDetails(), AlterForeignServerCommand::setForeignServerDataWrapper(), AlterForeignServerCommand::setForeignServerOptions(), CreateForeignTableCommand::setTableDetails(), ShowCreateServerCommand::ShowCreateServerCommand(), ShowDiskCacheUsageCommand::ShowDiskCacheUsageCommand(), ShowForeignServersCommand::ShowForeignServersCommand(), ShowRolesCommand::ShowRolesCommand(), ShowTableDetailsCommand::ShowTableDetailsCommand(), and ShowUserDetailsCommand::ShowUserDetailsCommand().

                                                                     {
  const DdlCommandDataImpl* data = static_cast<const DdlCommandDataImpl*>(&ddl_data);
  return data->payload();
}

Here is the call graph for this function:

std::unique_ptr<RexLiteral> anonymous_namespace{DdlCommandExecutor.cpp}::genLiteralBigInt

(

int64_t

val

)

Definition at line 327 of file DdlCommandExecutor.cpp.

References kBIGINT.

Referenced by add_table_details(), ShowModelDetailsCommand::execute(), ShowDiskCacheUsageCommand::execute(), ShowUserDetailsCommand::execute(), and ShowModelFeatureDetailsCommand::prepareLogicalValues().

                                                        {
  return std::unique_ptr<RexLiteral>(
      new RexLiteral(val, SQLTypes::kBIGINT, SQLTypes::kBIGINT, 0, 8, 0, 8));
}

Here is the caller graph for this function:

std::unique_ptr<RexLiteral> anonymous_namespace{DdlCommandExecutor.cpp}::genLiteralBoolean

(

bool

val

)

Definition at line 337 of file DdlCommandExecutor.cpp.

References kBIGINT.

Referenced by add_table_details(), ShowFunctionsCommand::execute(), ShowTableFunctionsCommand::execute(), and ShowUserDetailsCommand::execute().

                                                      {
  return std::unique_ptr<RexLiteral>(new RexLiteral(
      (int64_t)(val ? 1 : 0), SQLTypes::kBIGINT, SQLTypes::kBIGINT, 0, 8, 0, 8));
}

Here is the caller graph for this function:

std::unique_ptr<RexLiteral> anonymous_namespace{DdlCommandExecutor.cpp}::genLiteralDouble

(

double

val

)

Definition at line 332 of file DdlCommandExecutor.cpp.

References kDOUBLE.

Referenced by ShowModelDetailsCommand::execute(), EvaluateModelCommand::execute(), and ShowModelFeatureDetailsCommand::prepareLogicalValues().

                                                       {
  return std::unique_ptr<RexLiteral>(
      new RexLiteral(val, SQLTypes::kDOUBLE, SQLTypes::kDOUBLE, 0, 8, 0, 8));
}

Here is the caller graph for this function:

std::unique_ptr<RexLiteral> anonymous_namespace{DdlCommandExecutor.cpp}::genLiteralStr

(

std::string

val

)

Definition at line 317 of file DdlCommandExecutor.cpp.

References kTEXT.

                                                       {
  return std::unique_ptr<RexLiteral>(
      new RexLiteral(val, SQLTypes::kTEXT, SQLTypes::kTEXT, 0, 0, 0, 0));
}

std::unique_ptr<RexLiteral> anonymous_namespace{DdlCommandExecutor.cpp}::genLiteralTimestamp

(

time_t

val

)

Definition at line 322 of file DdlCommandExecutor.cpp.

References kTIMESTAMP.

Referenced by ShowForeignServersCommand::execute().

                                                          {
  return std::unique_ptr<RexLiteral>(new RexLiteral(
      (int64_t)val, SQLTypes::kTIMESTAMP, SQLTypes::kTIMESTAMP, 0, 8, 0, 8));
}

Here is the caller graph for this function:

AggregratedStorageStats anonymous_namespace{DdlCommandExecutor.cpp}::get_agg_storage_stats	(	const TableDescriptor *	td,
		const Catalog_Namespace::Catalog *	catalog
	)

Definition at line 292 of file DdlCommandExecutor.cpp.

References CHECK, CHECK_EQ, Catalog_Namespace::Catalog::getDatabaseId(), Catalog_Namespace::Catalog::getDataMgr(), Data_Namespace::DataMgr::getGlobalFileMgr(), Catalog_Namespace::Catalog::getPhysicalTablesDescriptors(), TableDescriptor::nShards, and TableDescriptor::tableId.

Referenced by ShowTableDetailsCommand::execute().

                                                                                       {
  const auto global_file_mgr = catalog->getDataMgr().getGlobalFileMgr();
  std::optional<AggregratedStorageStats> agg_storage_stats;
  if (td->nShards > 0) {
    const auto physical_tables = catalog->getPhysicalTablesDescriptors(td, false);
    CHECK_EQ(static_cast<size_t>(td->nShards), physical_tables.size());

    for (const auto physical_table : physical_tables) {
      auto storage_stats = global_file_mgr->getStorageStats(catalog->getDatabaseId(),
                                                            physical_table->tableId);
      if (agg_storage_stats) {
        agg_storage_stats.value().aggregate(storage_stats);
      } else {
        agg_storage_stats = storage_stats;
      }
    }
  } else {
    agg_storage_stats =
        global_file_mgr->getStorageStats(catalog->getDatabaseId(), td->tableId);
  }
  CHECK(agg_storage_stats.has_value());
  return agg_storage_stats.value();
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::list<std::pair<const ColumnDescriptor*, std::list<const ColumnDescriptor*> > > anonymous_namespace{DdlCommandExecutor.cpp}::get_alter_column_geo_pairs_from_src_dst_pairs_phys_cds	(	const AlterTableAlterColumnCommand::TypePairs &	src_dst_cds,
		const std::list< std::list< ColumnDescriptor >> &	phys_cds
	)

Definition at line 101 of file DdlCommandExecutor.cpp.

References CHECK.

Referenced by AlterTableAlterColumnCommand::alterColumnTypes().

                                                        {
  std::list<std::pair<const ColumnDescriptor*, std::list<const ColumnDescriptor*>>>
      geo_src_dst_column_pairs;

  auto phys_cds_it = phys_cds.begin();
  for (auto& [src_cd, dst_cd] : src_dst_cds) {
    if (dst_cd->columnType.is_geometry()) {
      geo_src_dst_column_pairs.emplace_back();
      auto& pair = geo_src_dst_column_pairs.back();
      pair.first = src_cd;

      std::list<const ColumnDescriptor*> geo_dst_cds;
      CHECK(phys_cds_it != phys_cds.end());
      auto& phy_geo_columns = *phys_cds_it;
      geo_dst_cds.push_back(dst_cd);
      for (const auto& cd : phy_geo_columns) {
        geo_dst_cds.push_back(&cd);
      }
      pair.second = geo_dst_cds;

      phys_cds_it++;
    }
  }

  return geo_src_dst_column_pairs;
}

Here is the caller graph for this function:

AlterTableAlterColumnCommand::TypePairs anonymous_namespace{DdlCommandExecutor.cpp}::get_alter_column_pairs_from_src_dst_cds	(	std::list< ColumnDescriptor > &	src_cds,
		std::list< ColumnDescriptor > &	dst_cds
	)

Definition at line 130 of file DdlCommandExecutor.cpp.

References CHECK_EQ.

Referenced by AlterTableAlterColumnCommand::alterColumn().

                                        {
  CHECK_EQ(src_cds.size(), dst_cds.size());
  AlterTableAlterColumnCommand::TypePairs src_dst_column_pairs;
  auto src_cd_it = src_cds.begin();
  auto dst_cd_it = dst_cds.begin();
  for (; src_cd_it != src_cds.end(); ++src_cd_it, ++dst_cd_it) {
    src_dst_column_pairs.emplace_back(&(*src_cd_it), &(*dst_cd_it));
  }
  return src_dst_column_pairs;
}

Here is the caller graph for this function:

std::pair<std::list<ColumnDescriptor>, std::list<ColumnDescriptor> > anonymous_namespace{DdlCommandExecutor.cpp}::get_alter_column_src_dst_cds	(	const std::list< Parser::ColumnDef > &	columns,
		Catalog_Namespace::Catalog &	catalog,
		const TableDescriptor *	td
	)

Definition at line 144 of file DdlCommandExecutor.cpp.

References CHECK, ColumnDescriptor::chunks, ColumnDescriptor::columnId, ColumnDescriptor::columnName, ColumnDescriptor::columnType, ddl_utils::alter_column_utils::compare_column_descriptors(), ColumnDescriptor::db_id, ddl_utils::alter_column_utils::CompareResult::exact_match, SQLTypeInfo::get_comp_param(), Catalog_Namespace::Catalog::getMetadataForColumn(), SQLTypeInfo::is_dict_encoded_string(), SQLTypeInfo::is_dict_encoded_type(), Parser::set_column_descriptor(), SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_size(), SQLTypeInfo::setStringDictKey(), ColumnDescriptor::sourceName, ddl_utils::alter_column_utils::CompareResult::sql_types_match, ColumnDescriptor::tableId, TableDescriptor::tableId, UNREACHABLE, validate_alter_type_allowed(), and validate_alter_type_metadata().

Referenced by AlterTableAlterColumnCommand::alterColumn().

                                                        {
  std::list<ColumnDescriptor> src_cds;
  std::list<ColumnDescriptor> dst_cds;
  for (const auto& coldef : columns) {
    dst_cds.emplace_back();
    ColumnDescriptor& dst_cd = dst_cds.back();
    set_column_descriptor(dst_cd, &coldef);

    // update kENCODING_DICT column descriptors to reflect correct sizing based on comp
    // param
    if (dst_cd.columnType.is_dict_encoded_string()) {
      switch (dst_cd.columnType.get_comp_param()) {
        case 8:
          dst_cd.columnType.set_size(1);
          break;
        case 16:
          dst_cd.columnType.set_size(2);
          break;
        case 32:
          dst_cd.columnType.set_size(4);
          break;
        default:
          UNREACHABLE();
      }
    }

    auto catalog_cd = catalog.getMetadataForColumn(td->tableId, dst_cd.columnName);
    CHECK(catalog_cd);

    validate_alter_type_allowed(
        dst_cd.columnName, catalog_cd->columnType, dst_cd.columnType);

    // Set remaining values in column descriptor that must be obtained from catalog
    dst_cd.columnId = catalog_cd->columnId;
    dst_cd.tableId = catalog_cd->tableId;
    dst_cd.sourceName = catalog_cd->sourceName;
    dst_cd.chunks = catalog_cd->chunks;
    dst_cd.db_id = catalog_cd->db_id;

    // This branch handles the special case where a string dictionary column
    // type is not changed, but altering is required (for example default
    // changes)
    if (catalog_cd->columnType.is_dict_encoded_type() &&
        dst_cd.columnType.is_dict_encoded_type() &&
        ddl_utils::alter_column_utils::compare_column_descriptors(catalog_cd, &dst_cd)
            .sql_types_match) {
      dst_cd.columnType.set_comp_param(catalog_cd->columnType.get_comp_param());
      dst_cd.columnType.setStringDictKey(catalog_cd->columnType.getStringDictKey());
    }

    if (ddl_utils::alter_column_utils::compare_column_descriptors(catalog_cd, &dst_cd)
            .exact_match) {
      throw std::runtime_error("Altering column " + dst_cd.columnName +
                               " results in no change to column, please review command.");
    }

    validate_alter_type_metadata(catalog, td, dst_cd);

    // A copy of the catalog column descriptor is stored for the source because
    // the catalog may delete its version of the source descriptor in progress
    // of the alter column command
    src_cds.emplace_back();
    src_cds.back() = *catalog_cd;
  }
  return {src_cds, dst_cds};
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class LockType >

std::tuple<const TableDescriptor*, std::unique_ptr<lockmgr::TableSchemaLockContainer<LockType> > > anonymous_namespace{DdlCommandExecutor.cpp}::get_table_descriptor_with_lock	(	Catalog_Namespace::Catalog &	cat,
		const std::string &	table_name,
		const bool	populate_fragmenter
	)

Definition at line 216 of file DdlCommandExecutor.cpp.

References CHECK.

                                                               {
  const TableDescriptor* td{nullptr};
  std::unique_ptr<lockmgr::TableSchemaLockContainer<LockType>> td_with_lock =
      std::make_unique<lockmgr::TableSchemaLockContainer<LockType>>(
          lockmgr::TableSchemaLockContainer<LockType>::acquireTableDescriptor(
              cat, table_name, populate_fragmenter));
  CHECK(td_with_lock);
  td = (*td_with_lock)();
  CHECK(td);
  return std::make_tuple(td, std::move(td_with_lock));
}

bool anonymous_namespace{DdlCommandExecutor.cpp}::is_default_server

(

const std::string &

server_name

)

Definition at line 845 of file DdlCommandExecutor.cpp.

References anonymous_namespace{QueryMemoryDescriptor.cpp}::any_of(), and kReservedServerPrefixes.

Referenced by CreateForeignServerCommand::execute(), AlterForeignServerCommand::execute(), DropForeignServerCommand::execute(), AlterForeignServerCommand::renameForeignServer(), and CreateForeignTableCommand::setTableDetails().

                                                     {
  return std::any_of(kReservedServerPrefixes.begin(),
                     kReservedServerPrefixes.end(),
                     [&server_name](const std::string& reserved_prefix) {
                       return boost::istarts_with(server_name, reserved_prefix);
                     });
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{DdlCommandExecutor.cpp}::set_headers_with_type	(	std::vector< TargetMetaInfo > &	label_infos,
		const std::vector< std::tuple< std::string, SQLTypes, bool >> &	headers
	)

Definition at line 342 of file DdlCommandExecutor.cpp.

References report::header, kBIGINT, kBOOLEAN, kTEXT, kTIMESTAMP, to_string(), and UNREACHABLE.

Referenced by ShowTableDetailsCommand::execute().

                                                                   {
  for (const auto& header : headers) {
    auto [_val, _type, _notnull] = header;
    if (_type == kBIGINT || _type == kTEXT || _type == kTIMESTAMP || _type == kBOOLEAN) {
      label_infos.emplace_back(_val, SQLTypeInfo(_type, _notnull));
    } else {
      UNREACHABLE() << "Unsupported type provided for header. SQL type: "
                    << to_string(_type);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{DdlCommandExecutor.cpp}::throw_reserved_server_prefix_exception

(

)

Definition at line 853 of file DdlCommandExecutor.cpp.

References kReservedServerPrefixes.

Referenced by CreateForeignServerCommand::execute(), and AlterForeignServerCommand::renameForeignServer().

                                              {
  std::string error_message{"Foreign server names cannot start with "};
  for (size_t i = 0; i < kReservedServerPrefixes.size(); i++) {
    if (i > 0) {
      error_message += ", ";
    }
    if (i == kReservedServerPrefixes.size() - 1) {
      error_message += "or ";
    }
    error_message += "\"" + kReservedServerPrefixes[i] + "\"";
  }
  error_message += ".";
  throw std::runtime_error{error_message};
}

Here is the caller graph for this function:

void anonymous_namespace{DdlCommandExecutor.cpp}::vacuum_table_if_required	(	const Catalog_Namespace::Catalog &	catalog,
		const TableDescriptor *	td
	)

Definition at line 51 of file DdlCommandExecutor.cpp.

References DEBUG_TIMER, measure< TimeT >::execution(), Executor::getExecutor(), Catalog_Namespace::Catalog::getMetadataForTable(), TableDescriptor::hasDeletedCol, logger::INFO, LOG, TableDescriptor::tableName, Executor::UNITARY_EXECUTOR_ID, and TableOptimizer::vacuumDeletedRows().

Referenced by AlterTableAlterColumnCommand::alterColumnTypes().

                                                         {
  if (!td->hasDeletedCol) {
    return;
  }

  DEBUG_TIMER(__func__);

  auto executor = Executor::getExecutor(Executor::UNITARY_EXECUTOR_ID).get();
  const TableOptimizer optimizer(td, executor, catalog);
  auto total_time_ms = measure<>::execution([&]() { optimizer.vacuumDeletedRows(); });
  LOG(INFO) << "Vacuum time (alter column data type): " << total_time_ms << "ms";

  // Reload fragmenter
  catalog.getMetadataForTable(td->tableName, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{DdlCommandExecutor.cpp}::validate_alter_type_allowed	(	const std::string &	colname,
		const SQLTypeInfo &	src,
		const SQLTypeInfo &	dst
	)

Definition at line 68 of file DdlCommandExecutor.cpp.

References SQLTypeInfo::is_string().

Referenced by get_alter_column_src_dst_cds().

                                                         {
  if (!src.is_string()) {
    throw std::runtime_error("Altering column " + colname +
                             " type not allowed. Column type must be TEXT.");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{DdlCommandExecutor.cpp}::validate_alter_type_metadata	(	const Catalog_Namespace::Catalog &	catalog,
		const TableDescriptor *	td,
		const ColumnDescriptor &	cd
	)

Definition at line 77 of file DdlCommandExecutor.cpp.

References ColumnDescriptor::columnId, ColumnDescriptor::columnName, ColumnDescriptor::columnType, SQLTypeInfo::get_notnull(), Data_Namespace::DataMgr::getChunkMetadataVecForKeyPrefix(), Catalog_Namespace::Catalog::getDatabaseId(), Catalog_Namespace::Catalog::getDataMgr(), TableDescriptor::nShards, and TableDescriptor::tableId.

Referenced by get_alter_column_src_dst_cds().

                                                              {
  ChunkMetadataVector column_metadata;
  catalog.getDataMgr().getChunkMetadataVecForKeyPrefix(
      column_metadata, {catalog.getDatabaseId(), td->tableId, cd.columnId});

  const bool is_not_null = cd.columnType.get_notnull();
  // check for non nulls
  for (const auto& [key, metadata] : column_metadata) {
    if (is_not_null && metadata->chunkStats.has_nulls) {
      throw std::runtime_error("Alter column type: Column " + cd.columnName +
                               ": NULL value not allowed in NOT NULL column");
    }
  }

  if (td->nShards > 0) {
    throw std::runtime_error("Alter column type: Column " + cd.columnName +
                             ": altering a sharded table is unsupported");
  }
  // further checks on metadata can be done to prevent late exceptions
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

const std::array<std::string, 3> anonymous_namespace{DdlCommandExecutor.cpp}::kReservedServerPrefixes {"default", "system", "internal"}

Definition at line 843 of file DdlCommandExecutor.cpp.

Referenced by is_default_server(), and throw_reserved_server_prefix_exception().