Functions
bool	bool_from_string_literal (const Parser::StringLiteral *str_literal)

void	parse_copy_params (const std::list< std::unique_ptr< NameValueAssign >> &options_, import_export::CopyParams &copy_params, std::vector< std::string > &warnings, std::string &deferred_copy_from_partitions_)

bool	expr_is_null (const Analyzer::Expr *expr)

std::string	unescape (std::string s)

void	parse_options (const rapidjson::Value &payload, std::list< std::unique_ptr< NameValueAssign >> &nameValueList, bool stringToNull=false, bool stringToInteger=false)

Literal *	parse_insert_literal (const rapidjson::Value &literal)

ArrayLiteral *	parse_insert_array_literal (const rapidjson::Value &array)

void	validate_shard_column_type (const ColumnDescriptor &cd)

size_t	shard_column_index (const std::string &name, const std::list< ColumnDescriptor > &columns)

size_t	sort_column_index (const std::string &name, const std::list< ColumnDescriptor > &columns)

void	set_string_field (rapidjson::Value &obj, const std::string &field_name, const std::string &field_value, rapidjson::Document &document)

std::string	serialize_key_metainfo (const ShardKeyDef *shard_key_def, const std::vector< SharedDictionaryDef > &shared_dict_defs)

template<typename LITERAL_TYPE , typename ASSIGNMENT , typename VALIDATE = DefaultValidate<LITERAL_TYPE>>
decltype(auto)	get_property_value (const NameValueAssign *p, ASSIGNMENT op, VALIDATE validate=VALIDATE())

decltype(auto)	get_storage_type (TableDescriptor &td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_frag_size_def (TableDescriptor &td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_frag_size_dataframe_def (DataframeTableDescriptor &df_td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_max_chunk_size_def (TableDescriptor &td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_max_chunk_size_dataframe_def (DataframeTableDescriptor &df_td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_delimiter_def (DataframeTableDescriptor &df_td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_header_def (DataframeTableDescriptor &df_td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_page_size_def (TableDescriptor &td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_max_rows_def (TableDescriptor &td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_skip_rows_def (DataframeTableDescriptor &df_td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_partions_def (TableDescriptor &td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_shard_count_def (TableDescriptor &td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_vacuum_def (TableDescriptor &td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_sort_column_def (TableDescriptor &td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

decltype(auto)	get_max_rollback_epochs_def (TableDescriptor &td, const NameValueAssign *p, const std::list< ColumnDescriptor > &columns)

void	get_table_definitions (TableDescriptor &td, const std::unique_ptr< NameValueAssign > &p, const std::list< ColumnDescriptor > &columns)

void	get_table_definitions_for_ctas (TableDescriptor &td, const std::unique_ptr< NameValueAssign > &p, const std::list< ColumnDescriptor > &columns)

void	get_dataframe_definitions (DataframeTableDescriptor &df_td, const std::unique_ptr< NameValueAssign > &p, const std::list< ColumnDescriptor > &columns)

std::unique_ptr< ColumnDef >	column_from_json (const rapidjson::Value &element)

void	parse_elements (const rapidjson::Value &payload, std::string element_name, std::string &table_name, std::list< std::unique_ptr< TableElement >> &table_element_list)

shared::TableKey	get_table_key (const std::vector< std::string > &table)

lockmgr::LockedTableDescriptors	acquire_query_table_locks (const std::string &insert_table_db_name, const std::string &query_str, const QueryStateProxy &query_state_proxy, const std::optional< std::string > &insert_table_name={})

bool	user_can_access_table (const Catalog_Namespace::SessionInfo &session_info, const TableDescriptor *td, const AccessPrivileges access_priv)

std::string	generateUniqueTableName (std::string name)

void	recordRename (SubstituteMap &sMap, std::string oldName, std::string newName)

std::string	loadTable (Catalog_Namespace::Catalog &catalog, SubstituteMap &sMap, std::string tableName)

bool	hasData (SubstituteMap &sMap, std::string tableName)

void	checkNameSubstition (SubstituteMap &sMap)

void	disable_foreign_tables (const TableDescriptor *td)

std::optional< std::string >	get_string_option (const NameValueAssign *option, const std::string &option_name)

Variables
static const std::map< const std::string, const TableDefFuncPtr >	tableDefFuncMap

static const std::map< const std::string, const DataframeDefFuncPtr >	dataframeDefFuncMap

static constexpr char const *	EMPTY_NAME {""}

Function Documentation

lockmgr::LockedTableDescriptors Parser::anonymous_namespace{ParserNode.cpp}::acquire_query_table_locks	(	const std::string &	insert_table_db_name,
		const std::string &	query_str,
		const QueryStateProxy &	query_state_proxy,
		const std::optional< std::string > &	insert_table_name = `{}`
	)

Definition at line 4146 of file ParserNode.cpp.

Referenced by Parser::InsertIntoTableAsSelectStmt::execute(), Parser::CreateTableAsSelectStmt::execute(), and Parser::ExportQueryStmt::execute().

                                                       {}) {
   auto& sys_catalog = SysCatalog::instance();
   auto& calcite_mgr = sys_catalog.getCalciteMgr();
   const auto calciteQueryParsingOption =
       calcite_mgr.getCalciteQueryParsingOption(true, false, true);
   const auto calciteOptimizationOption = calcite_mgr.getCalciteOptimizationOption(
       false, g_enable_watchdog, {}, sys_catalog.isAggregator());
   const auto result = calcite_mgr.process(query_state_proxy,
                                           pg_shim(query_str),
                                           calciteQueryParsingOption,
                                           calciteOptimizationOption);
   // force sort into tableid order in case of name change to guarantee fixed order of
   // mutex access
   auto comparator = [](const std::vector<std::string>& table_1,
                        const std::vector<std::string>& table_2) {
     return get_table_key(table_1) < get_table_key(table_2);
   };
   std::set<std::vector<std::string>, decltype(comparator)> tables(comparator);
   for (auto& tab : result.resolved_accessed_objects.tables_selected_from) {
     tables.emplace(tab);
   }
   if (insert_table_name.has_value()) {
     tables.emplace(
         std::vector<std::string>{insert_table_name.value(), insert_table_db_name});
   }
   lockmgr::LockedTableDescriptors locks;
   for (const auto& table : tables) {
     const auto catalog = sys_catalog.getCatalog(table[1]);
     CHECK(catalog);
     locks.emplace_back(
         std::make_unique<lockmgr::TableSchemaLockContainer<lockmgr::ReadLock>>(
             lockmgr::TableSchemaLockContainer<lockmgr::ReadLock>::acquireTableDescriptor(
                 *catalog, table[0])));
     if (insert_table_name.has_value() && table[0] == insert_table_name.value() &&
         table[1] == insert_table_db_name) {
       locks.emplace_back(
           std::make_unique<lockmgr::TableInsertLockContainer<lockmgr::WriteLock>>(
               lockmgr::TableInsertLockContainer<lockmgr::WriteLock>::acquire(
                   catalog->getDatabaseId(), (*locks.back())())));
     } else {
       locks.emplace_back(
           std::make_unique<lockmgr::TableDataLockContainer<lockmgr::ReadLock>>(
               lockmgr::TableDataLockContainer<lockmgr::ReadLock>::acquire(
                   catalog->getDatabaseId(), (*locks.back())())));
     }
   }
   return locks;
 }

Here is the caller graph for this function:

bool Parser::anonymous_namespace{ParserNode.cpp}::bool_from_string_literal ( const Parser::StringLiteral * str_literal )

Definition at line 1074 of file ParserNode.cpp.

References Parser::StringLiteral::get_stringval().

Referenced by parse_copy_params(), and Parser::ExportQueryStmt::parseOptions().

                                                                       {
   const std::string* s = str_literal->get_stringval();
   if (*s == "t" || *s == "true" || *s == "T" || *s == "True") {
     return true;
   } else if (*s == "f" || *s == "false" || *s == "F" || *s == "False") {
     return false;
   } else {
     throw std::runtime_error("Invalid string for boolean " + *s);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Parser::anonymous_namespace{ParserNode.cpp}::checkNameSubstition ( SubstituteMap & sMap )

Definition at line 4895 of file ParserNode.cpp.

References EMPTY_NAME.

Referenced by Parser::RenameTableStmt::execute().

                                               {
   // Substition map should be clean at end of rename:
   //    all items in map must (map to self) or (map to EMPTY_STRING) by end
 
   for (auto it : sMap) {
     if ((it.second) != EMPTY_NAME && (it.first) != (it.second)) {
       throw std::runtime_error(
           "Error: Attempted to overwrite and lose data in table: \'" + (it.first) + "\'");
     }
   }
 }

Here is the caller graph for this function:

std::unique_ptr<ColumnDef> Parser::anonymous_namespace{ParserNode.cpp}::column_from_json ( const rapidjson::Value & element )

Definition at line 3057 of file ParserNode.cpp.

References CHECK, json_bool(), json_i64(), json_str(), and to_sql_type().

Referenced by Parser::AlterTableStmt::delegate(), and parse_elements().

                                                                          {
   CHECK(element.HasMember("name"));
   auto col_name = std::make_unique<std::string>(json_str(element["name"]));
   CHECK(element.HasMember("sqltype"));
   const auto sql_types = to_sql_type(json_str(element["sqltype"]));
 
   // decimal / numeric precision / scale
   int precision = -1;
   int scale = -1;
   if (element.HasMember("precision")) {
     precision = json_i64(element["precision"]);
   }
   if (element.HasMember("scale")) {
     scale = json_i64(element["scale"]);
   }
 
   std::optional<int64_t> array_size;
   if (element.HasMember("arraySize")) {
     // We do not yet support geo arrays
     array_size = json_i64(element["arraySize"]);
   }
   std::unique_ptr<SQLType> sql_type;
   if (element.HasMember("subtype")) {
     CHECK(element.HasMember("coordinateSystem"));
     const auto subtype_sql_types = to_sql_type(json_str(element["subtype"]));
     sql_type =
         std::make_unique<SQLType>(subtype_sql_types,
                                   static_cast<int>(sql_types),
                                   static_cast<int>(json_i64(element["coordinateSystem"])),
                                   false);
   } else if (precision > 0 && scale > 0) {
     sql_type = std::make_unique<SQLType>(sql_types,
                                          precision,
                                          scale,
                                          /*is_array=*/array_size.has_value(),
                                          array_size ? *array_size : -1);
   } else if (precision > 0) {
     sql_type = std::make_unique<SQLType>(sql_types,
                                          precision,
                                          0,
                                          /*is_array=*/array_size.has_value(),
                                          array_size ? *array_size : -1);
   } else {
     sql_type = std::make_unique<SQLType>(sql_types,
                                          /*is_array=*/array_size.has_value(),
                                          array_size ? *array_size : -1);
   }
   CHECK(sql_type);
 
   CHECK(element.HasMember("nullable"));
   const auto nullable = json_bool(element["nullable"]);
   std::unique_ptr<ColumnConstraintDef> constraint_def;
   StringLiteral* str_literal = nullptr;
   if (element.HasMember("default") && !element["default"].IsNull()) {
     std::string* defaultval = new std::string(json_str(element["default"]));
     boost::algorithm::trim_if(*defaultval, boost::is_any_of(" \"'`"));
     str_literal = new StringLiteral(defaultval);
   }
 
   constraint_def = std::make_unique<ColumnConstraintDef>(/*notnull=*/!nullable,
                                                          /*unique=*/false,
                                                          /*primarykey=*/false,
                                                          /*defaultval=*/str_literal);
   std::unique_ptr<CompressDef> compress_def;
   if (element.HasMember("encodingType") && !element["encodingType"].IsNull()) {
     std::string encoding_type = json_str(element["encodingType"]);
     CHECK(element.HasMember("encodingSize"));
     auto encoding_name = std::make_unique<std::string>(json_str(element["encodingType"]));
     compress_def = std::make_unique<CompressDef>(encoding_name.release(),
                                                  json_i64(element["encodingSize"]));
   }
   return std::make_unique<ColumnDef>(col_name.release(),
                                      sql_type.release(),
                                      compress_def ? compress_def.release() : nullptr,
                                      constraint_def ? constraint_def.release() : nullptr);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Parser::anonymous_namespace{ParserNode.cpp}::disable_foreign_tables ( const TableDescriptor * td )

Definition at line 4909 of file ParserNode.cpp.

References StorageType::FOREIGN_TABLE, TableDescriptor::storageType, and TableDescriptor::tableName.

Referenced by Parser::RenameTableStmt::execute().

                                                        {
   if (td->storageType == StorageType::FOREIGN_TABLE) {
     throw std::runtime_error(td->tableName + " is a foreign table. " +
                              "Use ALTER FOREIGN TABLE.");
   }
 }

Here is the caller graph for this function:

bool Parser::anonymous_namespace{ParserNode.cpp}::expr_is_null ( const Analyzer::Expr * expr )

Definition at line 1627 of file ParserNode.cpp.

References Analyzer::Constant::get_is_null(), SQLTypeInfo::get_type(), Analyzer::Expr::get_type_info(), and kNULLT.

Referenced by Parser::CaseExpr::normalize().

                                             {
   if (expr->get_type_info().get_type() == kNULLT) {
     return true;
   }
   const auto const_expr = dynamic_cast<const Analyzer::Constant*>(expr);
   return const_expr && const_expr->get_is_null();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string Parser::anonymous_namespace{ParserNode.cpp}::generateUniqueTableName ( std::string name )

Definition at line 4860 of file ParserNode.cpp.

References run_benchmark_import::result, and to_string().

Referenced by Parser::RenameTableStmt::execute().

                                                   {
   // TODO - is there a "better" way to create a tmp name for the table
   std::time_t result = std::time(nullptr);
   return name + "_tmp" + std::to_string(result);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Parser::anonymous_namespace{ParserNode.cpp}::get_dataframe_definitions	(	DataframeTableDescriptor &	df_td,
		const std::unique_ptr< NameValueAssign > &	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 3044 of file ParserNode.cpp.

Referenced by Parser::CreateDataframeStmt::execute().

                                                                          {
   const auto it =
       dataframeDefFuncMap.find(boost::to_lower_copy<std::string>(*p->get_name()));
   if (it == dataframeDefFuncMap.end()) {
     throw std::runtime_error(
         "Invalid CREATE DATAFRAME option " + *p->get_name() +
         ". Should be FRAGMENT_SIZE, MAX_CHUNK_SIZE, SKIP_ROWS, DELIMITER or HEADER.");
   }
   return it->second(df_td, p.get(), columns);
 }

Here is the caller graph for this function:

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_delimiter_def	(	DataframeTableDescriptor &	df_td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2884 of file ParserNode.cpp.

                                                                            {
   return get_property_value<StringLiteral>(p, [&df_td](const auto val) {
     if (val.size() != 1) {
       throw std::runtime_error("Length of DELIMITER must be equal to 1.");
     }
     df_td.delimiter = val;
   });
 }

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_frag_size_dataframe_def	(	DataframeTableDescriptor &	df_td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2862 of file ParserNode.cpp.

                                                                                      {
   return get_property_value<IntLiteral>(
       p, [&df_td](const auto val) { df_td.maxFragRows = val; });
 }

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_frag_size_def	(	TableDescriptor &	td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2855 of file ParserNode.cpp.

                                                                            {
   return get_property_value<IntLiteral>(p,
                                         [&td](const auto val) { td.maxFragRows = val; });
 }

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_header_def	(	DataframeTableDescriptor &	df_td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2895 of file ParserNode.cpp.

                                                                         {
   return get_property_value<StringLiteral>(p, [&df_td](const auto val) {
     if (val == "FALSE") {
       df_td.hasHeader = false;
     } else if (val == "TRUE") {
       df_td.hasHeader = true;
     } else {
       throw std::runtime_error("Option HEADER support only 'true' or 'false' values.");
     }
   });
 }

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_max_chunk_size_dataframe_def	(	DataframeTableDescriptor &	df_td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2876 of file ParserNode.cpp.

                                               {
   return get_property_value<IntLiteral>(
       p, [&df_td](const auto val) { df_td.maxChunkSize = val; });
 }

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_max_chunk_size_def	(	TableDescriptor &	td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2869 of file ParserNode.cpp.

                                                                                 {
   return get_property_value<IntLiteral>(p,
                                         [&td](const auto val) { td.maxChunkSize = val; });
 }

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_max_rollback_epochs_def	(	TableDescriptor &	td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2983 of file ParserNode.cpp.

                                                                                      {
   auto assignment = [&td](const auto val) {
     td.maxRollbackEpochs =
         val < 0 ? -1 : val;  // Anything < 0 means unlimited rollbacks. Note that 0
                              // still means keeping a shadow copy of data/metdata
                              // between epochs so bad writes can be rolled back
   };
   return get_property_value<IntLiteral, decltype(assignment), PositiveOrZeroValidate>(
       p, assignment);
 }

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_max_rows_def	(	TableDescriptor &	td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2915 of file ParserNode.cpp.

                                                                           {
   return get_property_value<IntLiteral>(p, [&td](const auto val) { td.maxRows = val; });
 }

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_page_size_def	(	TableDescriptor &	td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2909 of file ParserNode.cpp.

                                                                            {
   return get_property_value<IntLiteral>(p,
                                         [&td](const auto val) { td.fragPageSize = val; });
 }

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_partions_def	(	TableDescriptor &	td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2928 of file ParserNode.cpp.

                                                                           {
   return get_property_value<StringLiteral>(p, [&td](const auto partitions_uc) {
     if (partitions_uc != "SHARDED" && partitions_uc != "REPLICATED") {
       throw std::runtime_error("PARTITIONS must be SHARDED or REPLICATED");
     }
     if (td.shardedColumnId != 0 && partitions_uc == "REPLICATED") {
       throw std::runtime_error(
           "A table cannot be sharded and replicated at the same time");
     };
     td.partitions = partitions_uc;
   });
 }

template<typename LITERAL_TYPE , typename ASSIGNMENT , typename VALIDATE = DefaultValidate<LITERAL_TYPE>>

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_property_value	(	const NameValueAssign *	p,
		ASSIGNMENT	op,
		VALIDATE	validate = `VALIDATE()`
	)

Definition at line 2840 of file ParserNode.cpp.

                                                                   {
   const auto val = validate(p);
   return op(val);
 }

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_shard_count_def	(	TableDescriptor &	td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2942 of file ParserNode.cpp.

References g_leaf_count.

                                                                              {
   if (!td.shardedColumnId) {
     throw std::runtime_error("SHARD KEY must be defined.");
   }
   return get_property_value<IntLiteral>(p, [&td](const auto shard_count) {
     if (g_leaf_count && shard_count % g_leaf_count) {
       throw std::runtime_error(
           "SHARD_COUNT must be a multiple of the number of leaves in the cluster.");
     }
     td.nShards = g_leaf_count ? shard_count / g_leaf_count : shard_count;
     if (!td.shardedColumnId && !td.nShards) {
       throw std::runtime_error(
           "Must specify the number of shards through the SHARD_COUNT option");
     };
   });
 }

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_skip_rows_def	(	DataframeTableDescriptor &	df_td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2921 of file ParserNode.cpp.

                                                                            {
   return get_property_value<IntLiteral>(
       p, [&df_td](const auto val) { df_td.skipRows = val; });
 }

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_sort_column_def	(	TableDescriptor &	td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2972 of file ParserNode.cpp.

References sort_column_index().

                                                                              {
   return get_property_value<StringLiteral>(p, [&td, &columns](const auto sort_upper) {
     td.sortedColumnId = sort_column_index(sort_upper, columns);
     if (!td.sortedColumnId) {
       throw std::runtime_error("Specified sort column " + sort_upper + " doesn't exist");
     }
   });
 }

Here is the call graph for this function:

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_storage_type	(	TableDescriptor &	td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2847 of file ParserNode.cpp.

                                                                           {
   auto assignment = [&td](const auto val) { td.storageType = val; };
   return get_property_value<StringLiteral, decltype(assignment), CaseSensitiveValidate>(
       p, assignment);
 }

std::optional<std::string> Parser::anonymous_namespace{ParserNode.cpp}::get_string_option	(	const NameValueAssign *	option,
		const std::string &	option_name
	)

Definition at line 6782 of file ParserNode.cpp.

References CHECK, Parser::NameValueAssign::get_name(), and Parser::NameValueAssign::get_value().

Referenced by Parser::DumpRestoreTableStmtBase::DumpRestoreTableStmtBase().

                                                                            {
   CHECK(option);
   if (boost::iequals(*option->get_name(), option_name)) {
     if (const auto str_literal =
             dynamic_cast<const StringLiteral*>(option->get_value())) {
       return *str_literal->get_stringval();
     } else {
       throw std::runtime_error("\"" + option_name + "\" option must be a string.");
     }
   }
   return {};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Parser::anonymous_namespace{ParserNode.cpp}::get_table_definitions	(	TableDescriptor &	td,
		const std::unique_ptr< NameValueAssign > &	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 3008 of file ParserNode.cpp.

Referenced by Parser::CreateTableStmt::executeDryRun().

                                                                      {
   const auto it = tableDefFuncMap.find(boost::to_lower_copy<std::string>(*p->get_name()));
   if (it == tableDefFuncMap.end()) {
     throw std::runtime_error(
         "Invalid CREATE TABLE option " + *p->get_name() +
         ". Should be FRAGMENT_SIZE, MAX_CHUNK_SIZE, PAGE_SIZE, MAX_ROLLBACK_EPOCHS, "
         "MAX_ROWS, "
         "PARTITIONS, SHARD_COUNT, VACUUM, SORT_COLUMN, STORAGE_TYPE.");
   }
   return it->second(td, p.get(), columns);
 }

Here is the caller graph for this function:

void Parser::anonymous_namespace{ParserNode.cpp}::get_table_definitions_for_ctas	(	TableDescriptor &	td,
		const std::unique_ptr< NameValueAssign > &	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 3022 of file ParserNode.cpp.

Referenced by Parser::CreateTableAsSelectStmt::execute().

                                                                               {
   const auto it = tableDefFuncMap.find(boost::to_lower_copy<std::string>(*p->get_name()));
   if (it == tableDefFuncMap.end()) {
     throw std::runtime_error(
         "Invalid CREATE TABLE AS option " + *p->get_name() +
         ". Should be FRAGMENT_SIZE, MAX_CHUNK_SIZE, PAGE_SIZE, MAX_ROLLBACK_EPOCHS, "
         "MAX_ROWS, "
         "PARTITIONS, SHARD_COUNT, VACUUM, SORT_COLUMN, STORAGE_TYPE,  "
         "USE_SHARED_DICTIONARIES or FORCE_GEO_COMPRESSION.");
   }
   return it->second(td, p.get(), columns);
 }

Here is the caller graph for this function:

shared::TableKey Parser::anonymous_namespace{ParserNode.cpp}::get_table_key ( const std::vector< std::string > & table )

Definition at line 4135 of file ParserNode.cpp.

References CHECK.

                                                                 {
   const auto catalog = SysCatalog::instance().getCatalog(table[1]);
   CHECK(catalog);
   const auto table_id = catalog->getTableId(table[0]);
   if (!table_id.has_value()) {
     throw std::runtime_error{"Table \"" + table[0] +
                              "\" does not exist in catalog: " + table[1] + "."};
   }
   return {catalog->getDatabaseId(), table_id.value()};
 }

decltype(auto) Parser::anonymous_namespace{ParserNode.cpp}::get_vacuum_def	(	TableDescriptor &	td,
		const NameValueAssign *	p,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2961 of file ParserNode.cpp.

                                                                         {
   return get_property_value<StringLiteral>(p, [&td](const auto vacuum_uc) {
     if (vacuum_uc != "IMMEDIATE" && vacuum_uc != "DELAYED") {
       throw std::runtime_error("VACUUM must be IMMEDIATE or DELAYED");
     }
     td.hasDeletedCol = boost::iequals(vacuum_uc, "IMMEDIATE") ? false : true;
   });
 }

bool Parser::anonymous_namespace{ParserNode.cpp}::hasData	(	SubstituteMap &	sMap,
		std::string	tableName
	)

Definition at line 4890 of file ParserNode.cpp.

References EMPTY_NAME.

Referenced by Parser::RenameTableStmt::execute().

                                                        {
   // assumes loadTable has been previously called
   return (sMap[tableName] != EMPTY_NAME);
 }

Here is the caller graph for this function:

std::string Parser::anonymous_namespace{ParserNode.cpp}::loadTable	(	Catalog_Namespace::Catalog &	catalog,
		SubstituteMap &	sMap,
		std::string	tableName
	)

Definition at line 4870 of file ParserNode.cpp.

References EMPTY_NAME, and Catalog_Namespace::Catalog::getMetadataForTable().

Referenced by Parser::RenameTableStmt::execute().

                                            {
   if (sMap.find(tableName) != sMap.end()) {
     if (sMap[tableName] == EMPTY_NAME) {
       return tableName;
     }
     return sMap[tableName];
   } else {
     // lookup table in src catalog
     const TableDescriptor* td = catalog.getMetadataForTable(tableName);
     if (td) {
       sMap[tableName] = tableName;
     } else {
       sMap[tableName] = EMPTY_NAME;
     }
   }
   return tableName;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Parser::anonymous_namespace{ParserNode.cpp}::parse_copy_params	(	const std::list< std::unique_ptr< NameValueAssign >> &	options_,
		import_export::CopyParams &	copy_params,
		std::vector< std::string > &	warnings,
		std::string &	deferred_copy_from_partitions_
	)

Definition at line 1085 of file ParserNode.cpp.

Referenced by Parser::CopyTableStmt::execute().

                                                                   {
   if (!options_.empty()) {
     for (auto& p : options_) {
       if (boost::iequals(*p->get_name(), "max_reject")) {
         const IntLiteral* int_literal = dynamic_cast<const IntLiteral*>(p->get_value());
         if (int_literal == nullptr) {
           throw std::runtime_error("max_reject option must be an integer.");
         }
         copy_params.max_reject = int_literal->get_intval();
       } else if (boost::iequals(*p->get_name(), "max_import_batch_row_count")) {
         const IntLiteral* int_literal = dynamic_cast<const IntLiteral*>(p->get_value());
         if (int_literal == nullptr) {
           throw std::runtime_error(
               "max_import_batch_row_count option must be an integer.");
         }
         if (int_literal->get_intval() <= 0) {
           throw std::runtime_error(
               "max_import_batch_row_count option must be a positive integer (greater "
               "than 0).");
         }
         copy_params.max_import_batch_row_count = int_literal->get_intval();
       } else if (boost::iequals(*p->get_name(), "buffer_size")) {
         const IntLiteral* int_literal = dynamic_cast<const IntLiteral*>(p->get_value());
         if (int_literal == nullptr) {
           throw std::runtime_error("buffer_size option must be an integer.");
         }
         copy_params.buffer_size = int_literal->get_intval();
       } else if (boost::iequals(*p->get_name(), "threads")) {
         const IntLiteral* int_literal = dynamic_cast<const IntLiteral*>(p->get_value());
         if (int_literal == nullptr) {
           throw std::runtime_error("Threads option must be an integer.");
         }
         copy_params.threads = int_literal->get_intval();
       } else if (boost::iequals(*p->get_name(), "delimiter")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Delimiter option must be a string.");
         } else if (str_literal->get_stringval()->length() != 1) {
           throw std::runtime_error("Delimiter must be a single character string.");
         }
         copy_params.delimiter = (*str_literal->get_stringval())[0];
       } else if (boost::iequals(*p->get_name(), "nulls")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Nulls option must be a string.");
         }
         copy_params.null_str = *str_literal->get_stringval();
       } else if (boost::iequals(*p->get_name(), "header")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Header option must be a boolean.");
         }
         copy_params.has_header = bool_from_string_literal(str_literal)
                                      ? import_export::ImportHeaderRow::kHasHeader
                                      : import_export::ImportHeaderRow::kNoHeader;
 #ifdef ENABLE_IMPORT_PARQUET
       } else if (boost::iequals(*p->get_name(), "parquet")) {
         warnings.push_back(
             "Deprecation Warning: COPY FROM WITH (parquet='true') is deprecated. Use "
             "WITH (source_type='parquet_file') instead.");
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("'parquet' option must be a boolean.");
         }
         if (bool_from_string_literal(str_literal)) {
           // not sure a parquet "table" type is proper, but to make code
           // look consistent in some places, let's set "table" type too
           copy_params.source_type = import_export::SourceType::kParquetFile;
         }
 #endif  // ENABLE_IMPORT_PARQUET
       } else if (boost::iequals(*p->get_name(), "s3_access_key")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option s3_access_key must be a string.");
         }
         copy_params.s3_access_key = *str_literal->get_stringval();
       } else if (boost::iequals(*p->get_name(), "s3_secret_key")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option s3_secret_key must be a string.");
         }
         copy_params.s3_secret_key = *str_literal->get_stringval();
       } else if (boost::iequals(*p->get_name(), "s3_session_token")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option s3_session_token must be a string.");
         }
         copy_params.s3_session_token = *str_literal->get_stringval();
       } else if (boost::iequals(*p->get_name(), "s3_region")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option s3_region must be a string.");
         }
         copy_params.s3_region = *str_literal->get_stringval();
       } else if (boost::iequals(*p->get_name(), "s3_endpoint")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option s3_endpoint must be a string.");
         }
         copy_params.s3_endpoint = *str_literal->get_stringval();
       } else if (boost::iequals(*p->get_name(), "s3_max_concurrent_downloads")) {
         const IntLiteral* int_literal = dynamic_cast<const IntLiteral*>(p->get_value());
         if (int_literal == nullptr) {
           throw std::runtime_error(
               "'s3_max_concurrent_downloads' option must be an integer");
         }
         const int s3_max_concurrent_downloads = int_literal->get_intval();
         if (s3_max_concurrent_downloads > 0) {
           copy_params.s3_max_concurrent_downloads = s3_max_concurrent_downloads;
         } else {
           throw std::runtime_error(
               "Invalid value for 's3_max_concurrent_downloads' option (must be > 0): " +
               std::to_string(s3_max_concurrent_downloads));
         }
       } else if (boost::iequals(*p->get_name(), "quote")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Quote option must be a string.");
         } else if (str_literal->get_stringval()->length() != 1) {
           throw std::runtime_error("Quote must be a single character string.");
         }
         copy_params.quote = (*str_literal->get_stringval())[0];
       } else if (boost::iequals(*p->get_name(), "escape")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Escape option must be a string.");
         } else if (str_literal->get_stringval()->length() != 1) {
           throw std::runtime_error("Escape must be a single character string.");
         }
         copy_params.escape = (*str_literal->get_stringval())[0];
       } else if (boost::iequals(*p->get_name(), "line_delimiter")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Line_delimiter option must be a string.");
         } else if (str_literal->get_stringval()->length() != 1) {
           throw std::runtime_error("Line_delimiter must be a single character string.");
         }
         copy_params.line_delim = (*str_literal->get_stringval())[0];
       } else if (boost::iequals(*p->get_name(), "quoted")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Quoted option must be a boolean.");
         }
         copy_params.quoted = bool_from_string_literal(str_literal);
       } else if (boost::iequals(*p->get_name(), "plain_text")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("plain_text option must be a boolean.");
         }
         copy_params.plain_text = bool_from_string_literal(str_literal);
       } else if (boost::iequals(*p->get_name(), "trim_spaces")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("trim_spaces option must be a boolean.");
         }
         copy_params.trim_spaces = bool_from_string_literal(str_literal);
       } else if (boost::iequals(*p->get_name(), "array_marker")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Array Marker option must be a string.");
         } else if (str_literal->get_stringval()->length() != 2) {
           throw std::runtime_error(
               "Array Marker option must be exactly two characters.  Default is {}.");
         }
         copy_params.array_begin = (*str_literal->get_stringval())[0];
         copy_params.array_end = (*str_literal->get_stringval())[1];
       } else if (boost::iequals(*p->get_name(), "array_delimiter")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Array Delimiter option must be a string.");
         } else if (str_literal->get_stringval()->length() != 1) {
           throw std::runtime_error("Array Delimiter must be a single character string.");
         }
         copy_params.array_delim = (*str_literal->get_stringval())[0];
       } else if (boost::iequals(*p->get_name(), "lonlat")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Lonlat option must be a boolean.");
         }
         copy_params.lonlat = bool_from_string_literal(str_literal);
       } else if (boost::iequals(*p->get_name(), "geo")) {
         warnings.push_back(
             "Deprecation Warning: COPY FROM WITH (geo='true') is deprecated. Use WITH "
             "(source_type='geo_file') instead.");
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("'geo' option must be a boolean.");
         }
         if (bool_from_string_literal(str_literal)) {
           copy_params.source_type = import_export::SourceType::kGeoFile;
         }
       } else if (boost::iequals(*p->get_name(), "source_type")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("'source_type' option must be a string.");
         }
         const std::string* s = str_literal->get_stringval();
         if (boost::iequals(*s, "delimited_file")) {
           copy_params.source_type = import_export::SourceType::kDelimitedFile;
         } else if (boost::iequals(*s, "geo_file")) {
           copy_params.source_type = import_export::SourceType::kGeoFile;
 #if ENABLE_IMPORT_PARQUET
         } else if (boost::iequals(*s, "parquet_file")) {
           copy_params.source_type = import_export::SourceType::kParquetFile;
 #endif
         } else if (boost::iequals(*s, "raster_file")) {
           copy_params.source_type = import_export::SourceType::kRasterFile;
         } else if (boost::iequals(*s, "regex_parsed_file")) {
           copy_params.source_type = import_export::SourceType::kRegexParsedFile;
         } else {
           throw std::runtime_error(
               "Invalid string for 'source_type' option (must be 'GEO_FILE', 'RASTER_FILE'"
 #if ENABLE_IMPORT_PARQUET
               ", 'PARQUET_FILE'"
 #endif
               ", 'REGEX_PARSED_FILE'"
               " or 'DELIMITED_FILE'): " +
               *s);
         }
       } else if (boost::iequals(*p->get_name(), "geo_coords_type")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("'geo_coords_type' option must be a string");
         }
         const std::string* s = str_literal->get_stringval();
         if (boost::iequals(*s, "geography")) {
           throw std::runtime_error(
               "GEOGRAPHY coords type not yet supported. Please use GEOMETRY.");
           // copy_params.geo_coords_type = kGEOGRAPHY;
         } else if (boost::iequals(*s, "geometry")) {
           copy_params.geo_coords_type = kGEOMETRY;
         } else {
           throw std::runtime_error(
               "Invalid string for 'geo_coords_type' option (must be 'GEOGRAPHY' or "
               "'GEOMETRY'): " +
               *s);
         }
       } else if (boost::iequals(*p->get_name(), "raster_point_type")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("'raster_point_type' option must be a string");
         }
         const std::string* s = str_literal->get_stringval();
         if (boost::iequals(*s, "none")) {
           copy_params.raster_point_type = import_export::RasterPointType::kNone;
         } else if (boost::iequals(*s, "auto")) {
           copy_params.raster_point_type = import_export::RasterPointType::kAuto;
         } else if (boost::iequals(*s, "smallint")) {
           copy_params.raster_point_type = import_export::RasterPointType::kSmallInt;
         } else if (boost::iequals(*s, "int")) {
           copy_params.raster_point_type = import_export::RasterPointType::kInt;
         } else if (boost::iequals(*s, "float")) {
           copy_params.raster_point_type = import_export::RasterPointType::kFloat;
         } else if (boost::iequals(*s, "double")) {
           copy_params.raster_point_type = import_export::RasterPointType::kDouble;
         } else if (boost::iequals(*s, "point")) {
           copy_params.raster_point_type = import_export::RasterPointType::kPoint;
         } else {
           throw std::runtime_error(
               "Invalid string for 'raster_point_type' option (must be 'NONE', 'AUTO', "
               "'SMALLINT', 'INT', 'FLOAT', 'DOUBLE' or 'POINT'): " +
               *s);
         }
       } else if (boost::iequals(*p->get_name(), "raster_point_transform")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("'raster_point_transform' option must be a string");
         }
         const std::string* s = str_literal->get_stringval();
         if (boost::iequals(*s, "none")) {
           copy_params.raster_point_transform = import_export::RasterPointTransform::kNone;
         } else if (boost::iequals(*s, "auto")) {
           copy_params.raster_point_transform = import_export::RasterPointTransform::kAuto;
         } else if (boost::iequals(*s, "file")) {
           copy_params.raster_point_transform = import_export::RasterPointTransform::kFile;
         } else if (boost::iequals(*s, "world")) {
           copy_params.raster_point_transform =
               import_export::RasterPointTransform::kWorld;
         } else {
           throw std::runtime_error(
               "Invalid string for 'raster_point_transform' option (must be 'NONE', "
               "'AUTO', 'FILE' or 'WORLD'): " +
               *s);
         }
       } else if (boost::iequals(*p->get_name(), "raster_import_bands")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("'raster_import_bands' option must be a string");
         }
         const std::string* raster_import_bands = str_literal->get_stringval();
         if (raster_import_bands) {
           copy_params.raster_import_bands = *raster_import_bands;
         } else {
           throw std::runtime_error("Invalid value for 'raster_import_bands' option");
         }
       } else if (boost::iequals(*p->get_name(), "raster_import_dimensions")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("'raster_import_dimensions' option must be a string");
         }
         const std::string* raster_import_dimensions = str_literal->get_stringval();
         if (raster_import_dimensions) {
           copy_params.raster_import_dimensions = *raster_import_dimensions;
         } else {
           throw std::runtime_error("Invalid value for 'raster_import_dimensions' option");
         }
       } else if (boost::iequals(*p->get_name(), "geo_coords_encoding")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("'geo_coords_encoding' option must be a string");
         }
         const std::string* s = str_literal->get_stringval();
         if (boost::iequals(*s, "none")) {
           copy_params.geo_coords_encoding = kENCODING_NONE;
           copy_params.geo_coords_comp_param = 0;
         } else if (boost::iequals(*s, "compressed(32)")) {
           copy_params.geo_coords_encoding = kENCODING_GEOINT;
           copy_params.geo_coords_comp_param = 32;
         } else {
           throw std::runtime_error(
               "Invalid string for 'geo_coords_encoding' option (must be 'NONE' or "
               "'COMPRESSED(32)'): " +
               *s);
         }
       } else if (boost::iequals(*p->get_name(), "raster_scanlines_per_thread")) {
         const IntLiteral* int_literal = dynamic_cast<const IntLiteral*>(p->get_value());
         if (int_literal == nullptr) {
           throw std::runtime_error(
               "'raster_scanlines_per_thread' option must be an integer");
         }
         const int raster_scanlines_per_thread = int_literal->get_intval();
         if (raster_scanlines_per_thread < 0) {
           throw std::runtime_error(
               "'raster_scanlines_per_thread' option must be >= 0, with 0 denoting auto "
               "sizing");
         }
         copy_params.raster_scanlines_per_thread = raster_scanlines_per_thread;
       } else if (boost::iequals(*p->get_name(), "geo_coords_srid")) {
         const IntLiteral* int_literal = dynamic_cast<const IntLiteral*>(p->get_value());
         if (int_literal == nullptr) {
           throw std::runtime_error("'geo_coords_srid' option must be an integer");
         }
         const int srid = int_literal->get_intval();
         if (srid == 4326 || srid == 3857 || srid == 900913) {
           copy_params.geo_coords_srid = srid;
         } else {
           throw std::runtime_error(
               "Invalid value for 'geo_coords_srid' option (must be 4326, 3857, or "
               "900913): " +
               std::to_string(srid));
         }
       } else if (boost::iequals(*p->get_name(), "geo_layer_name")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("'geo_layer_name' option must be a string");
         }
         const std::string* layer_name = str_literal->get_stringval();
         if (layer_name) {
           copy_params.geo_layer_name = *layer_name;
         } else {
           throw std::runtime_error("Invalid value for 'geo_layer_name' option");
         }
       } else if (boost::iequals(*p->get_name(), "partitions")) {
         const auto partitions =
             static_cast<const StringLiteral*>(p->get_value())->get_stringval();
         CHECK(partitions);
         const auto partitions_uc = boost::to_upper_copy<std::string>(*partitions);
         if (partitions_uc != "REPLICATED") {
           throw std::runtime_error(
               "Invalid value for 'partitions' option. Must be 'REPLICATED'.");
         }
         deferred_copy_from_partitions_ = partitions_uc;
       } else if (boost::iequals(*p->get_name(), "geo_assign_render_groups")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("geo_assign_render_groups option must be a boolean.");
         }
         copy_params.geo_assign_render_groups = bool_from_string_literal(str_literal);
       } else if (boost::iequals(*p->get_name(), "geo_explode_collections")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("geo_explode_collections option must be a boolean.");
         }
         copy_params.geo_explode_collections = bool_from_string_literal(str_literal);
       } else if (boost::iequals(*p->get_name(), "source_srid")) {
         const IntLiteral* int_literal = dynamic_cast<const IntLiteral*>(p->get_value());
         if (int_literal == nullptr) {
           throw std::runtime_error("'source_srid' option must be an integer");
         }
         const int srid = int_literal->get_intval();
         if (copy_params.source_type == import_export::SourceType::kDelimitedFile) {
           copy_params.source_srid = srid;
         } else {
           throw std::runtime_error(
               "'source_srid' option can only be used on csv/tsv files");
         }
       } else if (boost::iequals(*p->get_name(), "regex_path_filter")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option regex_path_filter must be a string.");
         }
         const auto string_val = *str_literal->get_stringval();
         copy_params.regex_path_filter =
             string_val.empty() ? std::nullopt : std::optional<std::string>{string_val};
       } else if (boost::iequals(*p->get_name(), "file_sort_order_by")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option file_sort_order_by must be a string.");
         }
         const auto string_val = *str_literal->get_stringval();
         copy_params.file_sort_order_by =
             string_val.empty() ? std::nullopt : std::optional<std::string>{string_val};
       } else if (boost::iequals(*p->get_name(), "file_sort_regex")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option file_sort_regex must be a string.");
         }
         const auto string_val = *str_literal->get_stringval();
         copy_params.file_sort_regex =
             string_val.empty() ? std::nullopt : std::optional<std::string>{string_val};
       } else if (boost::iequals(*p->get_name(), "raster_point_compute_angle")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error(
               "'raster_point_compute_angle' option must be a boolean.");
         }
         if (bool_from_string_literal(str_literal)) {
           copy_params.raster_point_compute_angle = true;
         }
       } else if (boost::iequals(*p->get_name(), "sql_order_by")) {
         if (auto str_literal = dynamic_cast<const StringLiteral*>(p->get_value())) {
           copy_params.sql_order_by = *str_literal->get_stringval();
         } else {
           throw std::runtime_error("Option sql_order_by must be a string.");
         }
       } else if (boost::iequals(*p->get_name(), "username")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option username must be a string.");
         }
         const auto string_val = *str_literal->get_stringval();
         copy_params.username = string_val;
       } else if (boost::iequals(*p->get_name(), "password")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option password must be a string.");
         }
         const auto string_val = *str_literal->get_stringval();
         copy_params.password = string_val;
       } else if (boost::iequals(*p->get_name(), "credential_string")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option credential_string must be a string.");
         }
         const auto string_val = *str_literal->get_stringval();
         copy_params.credential_string = string_val;
       } else if (boost::iequals(*p->get_name(), "data_source_name")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option data_source_name must be a string.");
         }
         const auto string_val = *str_literal->get_stringval();
         copy_params.dsn = string_val;
       } else if (boost::iequals(*p->get_name(), "connection_string")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option connection_string must be a string.");
         }
         const auto string_val = *str_literal->get_stringval();
         copy_params.connection_string = string_val;
       } else if (boost::iequals(*p->get_name(), "line_start_regex")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option line_start_regex must be a string.");
         }
         const auto string_val = *str_literal->get_stringval();
         copy_params.line_start_regex = string_val;
       } else if (boost::iequals(*p->get_name(), "line_regex")) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("Option line_regex must be a string.");
         }
         const auto string_val = *str_literal->get_stringval();
         copy_params.line_regex = string_val;
       } else if (boost::iequals(*p->get_name(), "add_metadata_columns") &&
                  g_enable_add_metadata_columns) {
         const StringLiteral* str_literal =
             dynamic_cast<const StringLiteral*>(p->get_value());
         if (str_literal == nullptr) {
           throw std::runtime_error("'add_metadata_columns' option must be a string.");
         }
         copy_params.add_metadata_columns = *str_literal->get_stringval();
       } else {
         throw std::runtime_error("Invalid option for COPY: " + *p->get_name());
       }
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Parser::anonymous_namespace{ParserNode.cpp}::parse_elements	(	const rapidjson::Value &	payload,
		std::string	element_name,
		std::string &	table_name,
		std::list< std::unique_ptr< TableElement >> &	table_element_list
	)

Definition at line 3134 of file ParserNode.cpp.

References CHECK, column_from_json(), logger::FATAL, json_str(), and LOG.

Referenced by Parser::CreateDataframeStmt::CreateDataframeStmt(), and Parser::CreateTableStmt::CreateTableStmt().

                                                                               {
   const auto elements = payload[element_name].GetArray();
   for (const auto& element : elements) {
     CHECK(element.IsObject());
     CHECK(element.HasMember("type"));
     if (json_str(element["type"]) == "SQL_COLUMN_DECLARATION") {
       auto col_def = column_from_json(element);
       table_element_list.emplace_back(std::move(col_def));
     } else if (json_str(element["type"]) == "SQL_COLUMN_CONSTRAINT") {
       CHECK(element.HasMember("name"));
       if (json_str(element["name"]) == "SHARD_KEY") {
         CHECK(element.HasMember("columns"));
         CHECK(element["columns"].IsArray());
         const auto& columns = element["columns"].GetArray();
         if (columns.Size() != size_t(1)) {
           throw std::runtime_error("Only one shard column is currently supported.");
         }
         auto shard_key_def = std::make_unique<ShardKeyDef>(json_str(columns[0]));
         table_element_list.emplace_back(std::move(shard_key_def));
       } else if (json_str(element["name"]) == "SHARED_DICT") {
         CHECK(element.HasMember("columns"));
         CHECK(element["columns"].IsArray());
         const auto& columns = element["columns"].GetArray();
         if (columns.Size() != size_t(1)) {
           throw std::runtime_error(
               R"(Only one column per shared dictionary entry is currently supported. Use multiple SHARED DICT statements to share dictionaries from multiple columns.)");
         }
         CHECK(element.HasMember("references") && element["references"].IsObject());
         const auto& references = element["references"].GetObject();
         std::string references_table_name;
         if (references.HasMember("table")) {
           references_table_name = json_str(references["table"]);
         } else {
           references_table_name = table_name;
         }
         CHECK(references.HasMember("column"));
 
         auto shared_dict_def = std::make_unique<SharedDictionaryDef>(
             json_str(columns[0]), references_table_name, json_str(references["column"]));
         table_element_list.emplace_back(std::move(shared_dict_def));
 
       } else {
         LOG(FATAL) << "Unsupported type for SQL_COLUMN_CONSTRAINT: "
                    << json_str(element["name"]);
       }
     } else {
       LOG(FATAL) << "Unsupported element type for CREATE TABLE: "
                  << element["type"].GetString();
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ArrayLiteral* Parser::anonymous_namespace{ParserNode.cpp}::parse_insert_array_literal ( const rapidjson::Value & array )

Definition at line 2412 of file ParserNode.cpp.

References CHECK, and parse_insert_literal().

Referenced by Parser::InsertValuesStmt::InsertValuesStmt().

                                                                       {
   CHECK(array.IsArray());
   auto json_elements = array.GetArray();
   auto* elements = new std::list<Expr*>();
   for (const auto& e : json_elements) {
     elements->push_back(parse_insert_literal(e));
   }
   return new ArrayLiteral(elements);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Literal* Parser::anonymous_namespace{ParserNode.cpp}::parse_insert_literal ( const rapidjson::Value & literal )

Definition at line 2378 of file ParserNode.cpp.

References CHECK, json_i64(), json_str(), sql_constants::kMaxNumericPrecision, and run_benchmark_import::type.

Referenced by Parser::InsertValuesStmt::InsertValuesStmt(), and parse_insert_array_literal().

                                                              {
   CHECK(literal.IsObject());
   CHECK(literal.HasMember("literal"));
   CHECK(literal.HasMember("type"));
   auto type = json_str(literal["type"]);
   if (type == "NULL") {
     return new NullLiteral();
   } else if (type == "CHAR" || type == "BOOLEAN") {
     auto* val = new std::string(json_str(literal["literal"]));
     return new StringLiteral(val);
   } else if (type == "DECIMAL") {
     CHECK(literal.HasMember("scale"));
     CHECK(literal.HasMember("precision"));
     auto scale = json_i64(literal["scale"]);
     auto precision = json_i64(literal["precision"]);
     if (scale == 0) {
       auto int_val = std::stol(json_str(literal["literal"]));
       return new IntLiteral(int_val);
     } else if (precision > sql_constants::kMaxNumericPrecision) {
       auto dbl_val = std::stod(json_str(literal["literal"]));
       return new DoubleLiteral(dbl_val);
     } else {
       auto* val = new std::string(json_str(literal["literal"]));
       return new FixedPtLiteral(val);
     }
   } else if (type == "DOUBLE") {
     auto dbl_val = std::stod(json_str(literal["literal"]));
     return new DoubleLiteral(dbl_val);
   } else {
     CHECK(false) << "Unexpected calcite data type: " << type;
   }
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Parser::anonymous_namespace{ParserNode.cpp}::parse_options	(	const rapidjson::Value &	payload,
		std::list< std::unique_ptr< NameValueAssign >> &	nameValueList,
		bool	stringToNull = `false`,
		bool	stringToInteger = `false`
	)

Definition at line 1999 of file ParserNode.cpp.

References CHECK, json_i64(), and unescape().

Referenced by Parser::AlterUserStmt::AlterUserStmt(), Parser::CopyTableStmt::CopyTableStmt(), Parser::CreateDataframeStmt::CreateDataframeStmt(), Parser::CreateDBStmt::CreateDBStmt(), Parser::CreateTableAsSelectStmt::CreateTableAsSelectStmt(), Parser::CreateTableStmt::CreateTableStmt(), Parser::CreateUserStmt::CreateUserStmt(), Parser::DumpRestoreTableStmtBase::DumpRestoreTableStmtBase(), Parser::ExportQueryStmt::ExportQueryStmt(), Parser::OptimizeTableStmt::OptimizeTableStmt(), and Parser::ValidateStmt::ValidateStmt().

                                                  {
   if (payload.HasMember("options") && payload["options"].IsObject()) {
     const auto& options = payload["options"];
     for (auto itr = options.MemberBegin(); itr != options.MemberEnd(); ++itr) {
       auto option_name = std::make_unique<std::string>(itr->name.GetString());
       std::unique_ptr<Literal> literal_value;
       if (itr->value.IsString()) {
         std::string str = itr->value.GetString();
         if (stringToNull && str == "") {
           literal_value = std::make_unique<NullLiteral>();
         } else if (stringToInteger && std::all_of(str.begin(), str.end(), ::isdigit)) {
           int iVal = std::stoi(str);
           literal_value = std::make_unique<IntLiteral>(iVal);
         } else {
           // Rapidjson will deliberately provide escape'd strings when accessed
           //   ... but the literal should have a copy of the raw unescaped string
           auto unique_literal_string = std::make_unique<std::string>(unescape(str));
           literal_value =
               std::make_unique<StringLiteral>(unique_literal_string.release());
         }
       } else if (itr->value.IsInt() || itr->value.IsInt64()) {
         literal_value = std::make_unique<IntLiteral>(json_i64(itr->value));
       } else if (itr->value.IsNull()) {
         literal_value = std::make_unique<NullLiteral>();
       } else {
         throw std::runtime_error("Unable to handle literal for " + *option_name);
       }
       CHECK(literal_value);
 
       nameValueList.emplace_back(std::make_unique<NameValueAssign>(
           option_name.release(), literal_value.release()));
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Parser::anonymous_namespace{ParserNode.cpp}::recordRename	(	SubstituteMap &	sMap,
		std::string	oldName,
		std::string	newName
	)

Definition at line 4866 of file ParserNode.cpp.

Referenced by Parser::RenameTableStmt::execute().

                                                                              {
   sMap[oldName] = newName;
 }

Here is the caller graph for this function:

std::string Parser::anonymous_namespace{ParserNode.cpp}::serialize_key_metainfo	(	const ShardKeyDef *	shard_key_def,
		const std::vector< SharedDictionaryDef > &	shared_dict_defs
	)

Definition at line 2807 of file ParserNode.cpp.

References Parser::ShardKeyDef::get_column(), and set_string_field().

Referenced by Parser::CreateDataframeStmt::execute(), Parser::CreateTableAsSelectStmt::execute(), and Parser::CreateTableStmt::executeDryRun().

                                                             {
   rapidjson::Document document;
   auto& allocator = document.GetAllocator();
   rapidjson::Value arr(rapidjson::kArrayType);
   if (shard_key_def) {
     rapidjson::Value shard_key_obj(rapidjson::kObjectType);
     set_string_field(shard_key_obj, "type", "SHARD KEY", document);
     set_string_field(shard_key_obj, "name", shard_key_def->get_column(), document);
     arr.PushBack(shard_key_obj, allocator);
   }
   for (const auto& shared_dict_def : shared_dict_defs) {
     rapidjson::Value shared_dict_obj(rapidjson::kObjectType);
     set_string_field(shared_dict_obj, "type", "SHARED DICTIONARY", document);
     set_string_field(shared_dict_obj, "name", shared_dict_def.get_column(), document);
     set_string_field(
         shared_dict_obj, "foreign_table", shared_dict_def.get_foreign_table(), document);
     set_string_field(shared_dict_obj,
                      "foreign_column",
                      shared_dict_def.get_foreign_column(),
                      document);
     arr.PushBack(shared_dict_obj, allocator);
   }
   rapidjson::StringBuffer buffer;
   rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
   arr.Accept(writer);
   return buffer.GetString();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Parser::anonymous_namespace{ParserNode.cpp}::set_string_field	(	rapidjson::Value &	obj,
		const std::string &	field_name,
		const std::string &	field_value,
		rapidjson::Document &	document
	)

Definition at line 2794 of file ParserNode.cpp.

Referenced by serialize_key_metainfo().

                                                    {
   rapidjson::Value field_name_json_str;
   field_name_json_str.SetString(
       field_name.c_str(), field_name.size(), document.GetAllocator());
   rapidjson::Value field_value_json_str;
   field_value_json_str.SetString(
       field_value.c_str(), field_value.size(), document.GetAllocator());
   obj.AddMember(field_name_json_str, field_value_json_str, document.GetAllocator());
 }

Here is the caller graph for this function:

size_t Parser::anonymous_namespace{ParserNode.cpp}::shard_column_index	(	const std::string &	name,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2761 of file ParserNode.cpp.

References validate_shard_column_type().

Referenced by Parser::CreateTableStmt::executeDryRun().

                                                                     {
   size_t index = 1;
   for (const auto& cd : columns) {
     if (cd.columnName == name) {
       validate_shard_column_type(cd);
       return index;
     }
     ++index;
     if (cd.columnType.is_geometry()) {
       index += cd.columnType.get_physical_cols();
     }
   }
   // Not found, return 0
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t Parser::anonymous_namespace{ParserNode.cpp}::sort_column_index	(	const std::string &	name,
		const std::list< ColumnDescriptor > &	columns
	)

Definition at line 2778 of file ParserNode.cpp.

Referenced by get_sort_column_def().

                                                                    {
   size_t index = 1;
   for (const auto& cd : columns) {
     if (boost::to_upper_copy<std::string>(cd.columnName) == name) {
       return index;
     }
     ++index;
     if (cd.columnType.is_geometry()) {
       index += cd.columnType.get_physical_cols();
     }
   }
   // Not found, return 0
   return 0;
 }

Here is the caller graph for this function:

std::string Parser::anonymous_namespace{ParserNode.cpp}::unescape ( std::string s )

Definition at line 1967 of file ParserNode.cpp.

Referenced by heavydb._samlutils::get_saml_response(), and parse_options().

                                 {
   boost::replace_all(s, "\\\\t", "\t");
   boost::replace_all(s, "\\t", "\t");
   boost::replace_all(s, "\\\\n", "\n");
   boost::replace_all(s, "\\n", "\n");
 
   // handle numerics
   std::smatch m;
 
   // "\x00"
   std::regex e1("(\\\\x[0-9A-Fa-f][0-9A-Fa-f])");
   while (std::regex_search(s, m, e1)) {
     std::string original(m[0].first, m[0].second);
     std::string replacement;
     long val = strtol(original.substr(2, 2).c_str(), NULL, 16);
     replacement.push_back(val);
     boost::replace_all(s, original, replacement);
   }
 
   // "\u0000"
   std::regex e2("(\\\\u[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f])");
   while (std::regex_search(s, m, e2)) {
     std::string original(m[0].first, m[0].second);
     std::string replacement;
     long val = strtol(original.substr(2, 4).c_str(), NULL, 16);
     replacement.push_back(val);
     boost::replace_all(s, original, replacement);
   }
 
   return s;
 }

Here is the caller graph for this function:

bool Parser::anonymous_namespace{ParserNode.cpp}::user_can_access_table	(	const Catalog_Namespace::SessionInfo &	session_info,
		const TableDescriptor *	td,
		const AccessPrivileges	access_priv
	)

Definition at line 4658 of file ParserNode.cpp.

References cat(), CHECK, Catalog_Namespace::SessionInfo::get_currentUser(), Catalog_Namespace::SessionInfo::getCatalog(), DBObject::loadKey(), DBObject::setPrivileges(), TableDBObjectType, and TableDescriptor::tableName.

Referenced by Parser::OptimizeTableStmt::execute().

                                                                {
   CHECK(td);
   auto& cat = session_info.getCatalog();
   std::vector<DBObject> privObjects;
   DBObject dbObject(td->tableName, TableDBObjectType);
   dbObject.loadKey(cat);
   dbObject.setPrivileges(access_priv);
   privObjects.push_back(dbObject);
   return SysCatalog::instance().checkPrivileges(session_info.get_currentUser(),
                                                 privObjects);
 };

Here is the call graph for this function:

Here is the caller graph for this function:

void Parser::anonymous_namespace{ParserNode.cpp}::validate_shard_column_type ( const ColumnDescriptor & cd )

Definition at line 2752 of file ParserNode.cpp.

References ColumnDescriptor::columnType, and kENCODING_DICT.

Referenced by shard_column_index().

                                                             {
   const auto& col_ti = cd.columnType;
   if (!col_ti.is_integer() && !col_ti.is_time() &&
       !(col_ti.is_string() && col_ti.get_compression() == kENCODING_DICT)) {
     throw std::runtime_error("Cannot shard on type " + col_ti.get_type_name() +
                              ", encoding " + col_ti.get_compression_name());
   }
 }

Here is the caller graph for this function:

Variable Documentation

const std::map<const std::string, const DataframeDefFuncPtr> Parser::anonymous_namespace{ParserNode.cpp}::dataframeDefFuncMap

static

Initial value:

=
    {{"fragment_size"s, get_frag_size_dataframe_def},
     {"max_chunk_size"s, get_max_chunk_size_dataframe_def},
     {"skip_rows"s, get_skip_rows_def},
     {"delimiter"s, get_delimiter_def},
     {"header"s, get_header_def}}

Definition at line 3037 of file ParserNode.cpp.

constexpr char const* Parser::anonymous_namespace{ParserNode.cpp}::EMPTY_NAME {""}

static

Definition at line 4858 of file ParserNode.cpp.

Referenced by checkNameSubstition(), Parser::RenameTableStmt::execute(), hasData(), and loadTable().

const std::map<const std::string, const TableDefFuncPtr> Parser::anonymous_namespace{ParserNode.cpp}::tableDefFuncMap

static

Initial value:

= {
    {"fragment_size"s, get_frag_size_def},
    {"max_chunk_size"s, get_max_chunk_size_def},
    {"page_size"s, get_page_size_def},
    {"max_rows"s, get_max_rows_def},
    {"partitions"s, get_partions_def},
    {"shard_count"s, get_shard_count_def},
    {"vacuum"s, get_vacuum_def},
    {"sort_column"s, get_sort_column_def},
    {"storage_type"s, get_storage_type},
    {"max_rollback_epochs", get_max_rollback_epochs_def}}

Definition at line 2996 of file ParserNode.cpp.

Functions

Variables

Function Documentation

Variable Documentation