Parser::anonymous_namespace{ParserNode.cpp} Namespace Reference

Functions
bool	expr_is_null (const Analyzer::Expr *expr)
bool	bool_from_string_literal (const Parser::StringLiteral *str_literal)
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::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)

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

bool Parser::anonymous_namespace{ParserNode.cpp}::bool_from_string_literal

(

const Parser::StringLiteral *

str_literal

)

Definition at line 920 of file ParserNode.cpp.

References Parser::StringLiteral::get_stringval().

Referenced by Parser::CopyTableStmt::execute(), 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 3772 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:

bool Parser::anonymous_namespace{ParserNode.cpp}::expr_is_null

(

const Analyzer::Expr *

expr

)

Definition at line 912 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 3738 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 2233 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 2073 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 2051 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 2044 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 2084 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 2065 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 2058 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 2172 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 2104 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 2098 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 2117 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 2029 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 2131 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 2110 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 2161 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 2036 of file ParserNode.cpp.

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

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 2197 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 2211 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 or "
        "USE_SHARED_DICTIONARIES.");
  }
  return it->second(td, p.get(), columns);
}

Here is the caller graph for this function:

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

Definition at line 2150 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 3767 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 3748 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}::recordRename	(	SubstituteMap &	sMap,
		std::string	oldName,
		std::string	newName
	)

Definition at line 3744 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 1996 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 1983 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 1950 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 1967 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:

void Parser::anonymous_namespace{ParserNode.cpp}::validate_shard_column_type

(

const ColumnDescriptor &

cd

)

Definition at line 1939 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_string() && col_ti.get_compression() == kENCODING_DICT) ||
      col_ti.is_time()) {
    return;
  }
  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 2226 of file ParserNode.cpp.

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

static

Definition at line 3736 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 2185 of file ParserNode.cpp.