#include <ParserNode.h>

Inheritance diagram for Parser::AddColumnStmt:

Collaboration diagram for Parser::AddColumnStmt:

Public Member Functions
	AddColumnStmt (std::string tab, ColumnDef coldef)

	AddColumnStmt (std::string tab, std::list< ColumnDef > *coldefs)

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

void	check_executable (const Catalog_Namespace::SessionInfo &session, const TableDescriptor *td)

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::unique_ptr< ColumnDef >	coldef_

std::list< std::unique_ptr < ColumnDef > >	coldefs_

Detailed Description

Definition at line 1371 of file ParserNode.h.

Constructor & Destructor Documentation

Parser::AddColumnStmt::AddColumnStmt	(	std::string *	tab,
		ColumnDef *	coldef
	)

inline

Definition at line 1373 of file ParserNode.h.

1373 : table_(tab), coldef_(coldef) {}

Parser::AddColumnStmt::table_

std::unique_ptr< std::string > table_

Definition: ParserNode.h:1387

Parser::AddColumnStmt::coldef_

std::unique_ptr< ColumnDef > coldef_

Definition: ParserNode.h:1388

Parser::AddColumnStmt::AddColumnStmt	(	std::string *	tab,
		std::list< ColumnDef * > *	coldefs
	)

inline

Definition at line 1374 of file ParserNode.h.

References coldefs_.

                                                               : table_(tab) {
     for (const auto coldef : *coldefs) {
       this->coldefs_.emplace_back(coldef);
     }
     delete coldefs;
   }

Member Function Documentation

void Parser::AddColumnStmt::check_executable	(	const Catalog_Namespace::SessionInfo &	session,
		const TableDescriptor *	td
	)

Definition at line 5032 of file ParserNode.cpp.

References Parser::check_alter_table_privilege(), coldef_, coldefs_, Catalog_Namespace::SessionInfo::getCatalog(), TableDescriptor::isView, ddl_utils::TABLE, table_, table_is_temporary(), TableDescriptor::tableId, and ddl_utils::validate_table_type().

Referenced by execute().

                                                                 {
   auto& catalog = session.getCatalog();
   if (!td) {
     throw std::runtime_error("Table " + *table_ + " does not exist.");
   } else {
     if (td->isView) {
       throw std::runtime_error("Adding columns to a view is not supported.");
     }
     validate_table_type(td, ddl_utils::TableType::TABLE, "ALTER");
     if (table_is_temporary(td)) {
       throw std::runtime_error(
           "Adding columns to temporary tables is not yet supported.");
     }
   }
 
   check_alter_table_privilege(session, td);
 
   if (0 == coldefs_.size()) {
     coldefs_.push_back(std::move(coldef_));
   }
 
   for (const auto& coldef : coldefs_) {
     auto& new_column_name = *coldef->get_column_name();
     if (catalog.getMetadataForColumn(td->tableId, new_column_name) != nullptr) {
       throw std::runtime_error("Column " + new_column_name + " already exists.");
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Implements Parser::DDLStmt.

Definition at line 5062 of file ParserNode.cpp.

References anonymous_namespace{Utm.h}::a, CHECK, check_executable(), coldefs_, ColumnDescriptor::columnId, ColumnDescriptor::columnName, ColumnDescriptor::columnType, legacylockmgr::ExecutorOuterLock, TableDescriptor::fragmenter, Catalog_Namespace::SessionInfo::getCatalog(), Geospatial::GeoTypesFactory::getGeoColumns(), legacylockmgr::LockMgr< MutexType, KeyType >::getMutex(), CacheInvalidator< CACHE_HOLDING_TYPES >::invalidateCachesByTable(), SQLTypeInfo::is_geometry(), is_null(), TableDescriptor::nShards, import_export::Importer::set_geo_physical_import_buffer(), Parser::DDLStmt::setColumnDescriptor(), gpu_enabled::sort(), table_, and TableDescriptor::tableId.

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

                                                  {
   if (read_only_mode) {
     throw std::runtime_error("ADD 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();
 
   check_executable(session, td);
 
   CHECK(td->fragmenter);
   if (std::dynamic_pointer_cast<Fragmenter_Namespace::SortedOrderFragmenter>(
           td->fragmenter)) {
     throw std::runtime_error(
         "Adding columns to a table is not supported when using the \"sort_column\" "
         "option.");
   }
 
   // invalidate cached item
   std::vector<int> table_key{catalog.getCurrentDB().dbId, td->tableId};
   ResultSetCacheInvalidator::invalidateCachesByTable(boost::hash_value(table_key));
 
   // Do not take a data write lock, as the fragmenter may call `deleteFragments`
   // during a cap operation. Note that the schema write lock will prevent concurrent
   // inserts along with all other queries.
 
   catalog.getSqliteConnector().query("BEGIN TRANSACTION");
   try {
     std::map<const std::string, const ColumnDescriptor> cds;
     std::map<const int, const ColumnDef*> cid_coldefs;
     for (const auto& coldef : coldefs_) {
       ColumnDescriptor cd;
       setColumnDescriptor(cd, coldef.get());
       catalog.addColumn(*td, cd);
       cds.emplace(*coldef->get_column_name(), cd);
       cid_coldefs.emplace(cd.columnId, coldef.get());
 
       // expand geo column to phy columns
       if (cd.columnType.is_geometry()) {
         std::list<ColumnDescriptor> phy_geo_columns;
         catalog.expandGeoColumn(cd, phy_geo_columns);
         for (auto& cd : phy_geo_columns) {
           catalog.addColumn(*td, cd);
           cds.emplace(cd.columnName, cd);
           cid_coldefs.emplace(cd.columnId, nullptr);
         }
       }
     }
 
     std::unique_ptr<import_export::Loader> loader(new import_export::Loader(catalog, td));
     std::vector<std::unique_ptr<import_export::TypedImportBuffer>> import_buffers;
     for (const auto& cd : cds) {
       import_buffers.emplace_back(std::make_unique<import_export::TypedImportBuffer>(
           &cd.second, loader->getStringDict(&cd.second)));
     }
     loader->setAddingColumns(true);
 
     // set_geo_physical_import_buffer below needs a sorted import_buffers
     std::sort(import_buffers.begin(),
               import_buffers.end(),
               [](decltype(import_buffers[0])& a, decltype(import_buffers[0])& b) {
                 return a->getColumnDesc()->columnId < b->getColumnDesc()->columnId;
               });
 
     size_t nrows = td->fragmenter->getNumRows();
     // if sharded, get total nrows from all sharded tables
     if (td->nShards > 0) {
       const auto physical_tds = catalog.getPhysicalTablesDescriptors(td);
       nrows = 0;
       std::for_each(physical_tds.begin(), physical_tds.end(), [&nrows](const auto& td) {
         nrows += td->fragmenter->getNumRows();
       });
     }
     if (nrows > 0) {
       int skip_physical_cols = 0;
       for (const auto cit : cid_coldefs) {
         const auto cd = catalog.getMetadataForColumn(td->tableId, cit.first);
         const auto coldef = cit.second;
         const bool is_null = !cd->default_value.has_value();
 
         if (cd->columnType.get_notnull() && is_null) {
           throw std::runtime_error("Default value required for column " + cd->columnName +
                                    " because of NOT NULL constraint");
         }
 
         for (auto it = import_buffers.begin(); it < import_buffers.end(); ++it) {
           auto& import_buffer = *it;
           if (cd->columnId == import_buffer->getColumnDesc()->columnId) {
             if (coldef != nullptr ||
                 skip_physical_cols-- <= 0) {  // skip non-null phy col
               import_buffer->add_value(cd,
                                        cd->default_value.value_or("NULL"),
                                        is_null,
                                        import_export::CopyParams());
               if (cd->columnType.is_geometry()) {
                 std::vector<double> coords, bounds;
                 std::vector<int> ring_sizes, poly_rings;
                 int render_group = 0;
                 SQLTypeInfo tinfo{cd->columnType};
                 if (!Geospatial::GeoTypesFactory::getGeoColumns(
                         cd->default_value.value_or("NULL"),
                         tinfo,
                         coords,
                         bounds,
                         ring_sizes,
                         poly_rings,
                         false)) {
                   throw std::runtime_error("Bad geometry data: '" +
                                            cd->default_value.value_or("NULL") + "'");
                 }
                 size_t col_idx = 1 + std::distance(import_buffers.begin(), it);
                 import_export::Importer::set_geo_physical_import_buffer(catalog,
                                                                         cd,
                                                                         import_buffers,
                                                                         col_idx,
                                                                         coords,
                                                                         bounds,
                                                                         ring_sizes,
                                                                         poly_rings,
                                                                         render_group);
                 // skip following phy cols
                 skip_physical_cols = cd->columnType.get_physical_cols();
               }
             }
             break;
           }
         }
       }
     }
 
     if (!loader->loadNoCheckpoint(import_buffers, nrows, &session)) {
       throw std::runtime_error("loadNoCheckpoint failed!");
     }
     catalog.roll(true);
     catalog.resetTableEpochFloor(td->tableId);
     loader->checkpoint();
     catalog.getSqliteConnector().query("END TRANSACTION");
   } catch (...) {
     catalog.roll(false);
     catalog.getSqliteConnector().query("ROLLBACK TRANSACTION");
     throw;
   }
 }