Parser Namespace Reference

Namespaces
	anonymous_namespace{ParserNode.cpp}
	anonymous_namespace{ParserNode.h}
	Compress

Classes
class	Node
class	SQLType
class	Expr
class	Literal
class	NullLiteral
class	StringLiteral
class	IntLiteral
class	FixedPtLiteral
class	FloatLiteral
class	DoubleLiteral
class	TimestampLiteral
class	UserLiteral
class	ArrayLiteral
class	OperExpr
class	SubqueryExpr
class	IsNullExpr
class	InExpr
class	InSubquery
class	InValues
class	BetweenExpr
class	CharLengthExpr
class	CardinalityExpr
class	LikeExpr
class	RegexpExpr
class	WidthBucketExpr
class	LikelihoodExpr
class	ExistsExpr
class	ColumnRef
class	FunctionRef
class	CastExpr
class	ExprPair
class	CaseExpr
class	TableRef
class	Stmt
class	DMLStmt
class	DDLStmt
class	TableElement
class	ColumnConstraintDef
class	CompressDef
class	ColumnDef
class	TableConstraintDef
class	UniqueDef
class	ForeignKeyDef
class	CheckDef
class	SharedDictionaryDef
class	ShardKeyDef
class	NameValueAssign
class	CreateTableBaseStmt
class	CreateTableStmt
class	QueryConnector
class	LocalQueryConnector
class	CreateDataframeStmt
class	InsertIntoTableAsSelectStmt
class	CreateTableAsSelectStmt
class	DropTableStmt
class	TruncateTableStmt
class	OptimizeTableStmt
class	ValidateStmt
class	RenameDBStmt
class	RenameUserStmt
class	RenameTableStmt
class	RenameColumnStmt
class	AddColumnStmt
class	DropColumnStmt
class	AlterTableParamStmt
class	DumpRestoreTableStmtBase
class	DumpTableStmt
class	RestoreTableStmt
class	CopyTableStmt
class	CreateRoleStmt
class	DropRoleStmt
class	GrantPrivilegesStmt
class	RevokePrivilegesStmt
class	ShowPrivilegesStmt
class	GrantRoleStmt
class	RevokeRoleStmt
class	QueryExpr
class	UnionQuery
class	SelectEntry
class	QuerySpec
class	OrderSpec
class	SelectStmt
class	ExportQueryStmt
class	CreateViewStmt
class	DropViewStmt
class	CreateDBStmt
class	DropDBStmt
class	CreateModelStmt
class	DropModelStmt
class	CreateUserStmt
class	AlterUserStmt
class	DropUserStmt
class	InsertStmt
class	ValuesList
class	InsertValuesStmt
class	Assignment
class	UpdateStmt
class	DeleteStmt
struct	DefaultValidate
struct	DefaultValidate< IntLiteral >
struct	PositiveOrZeroValidate
struct	DefaultValidate< StringLiteral >
struct	CaseSensitiveValidate

Typedefs
using	SubstituteMap = std::map< std::string, std::string >

Functions
bool	check_session_interrupted (const QuerySessionId &query_session, Executor *executor)
std::vector< int >	getTableChunkKey (const TableDescriptor *td, Catalog_Namespace::Catalog &catalog)
bool	should_translate_strings (const std::shared_ptr< Analyzer::Expr > &lhs_expr, const std::shared_ptr< Analyzer::Expr > &rhs_expr)
SQLTypeInfo const &	get_str_dict_cast_type (const SQLTypeInfo &lhs_type_info, const SQLTypeInfo &rhs_type_info, const Executor *executor)
SQLTypeInfo	common_string_type (const SQLTypeInfo &lhs_type_info, const SQLTypeInfo &rhs_type_info, const Executor *executor)
std::unique_ptr< ColumnDef >	column_from_json (const rapidjson::Value &element)
std::list< ColumnDef >	get_columns_from_json_payload (const std::string &payload_key, const rapidjson::Value &payload)
std::string	write_model_params_to_json (const std::string &predicted, const std::vector< std::string > &features, const std::string &training_query, const double data_split_train_fraction, const double data_split_eval_fraction, const std::vector< int64_t > &feature_permutations)
std::shared_ptr< ResultSet >	getResultSet (QueryStateProxy query_state_proxy, const std::string select_stmt, std::vector< TargetMetaInfo > &targets, bool validate_only=false, std::vector< size_t > outer_fragment_indices={}, bool allow_interrupt=false)
bool	repair_type (std::list< std::unique_ptr< NameValueAssign >> &options)
void	check_alter_table_privilege (const Catalog_Namespace::SessionInfo &session, const TableDescriptor *td)
void	set_column_descriptor (ColumnDescriptor &cd, const ColumnDef *coldef)
std::vector< std::string >	splitObjectHierName (const std::string &hierName)
std::string	extractObjectNameFromHierName (const std::string &objectHierName, const std::string &objectType, const Catalog_Namespace::Catalog &cat)
static std::pair < AccessPrivileges, DBObjectType >	parseStringPrivs (const std::string &privs, const DBObjectType &objectType, const std::string &object_name)
static DBObject	createObject (const std::string &objectName, DBObjectType objectType)
static void	verifyObject (Catalog_Namespace::Catalog &sessionCatalog, const std::string &objectName, DBObjectType objectType, const std::string &command)
static void	checkStringLiteral (const std::string &option_name, const std::unique_ptr< NameValueAssign > &p)
static bool	readBooleanLiteral (const std::string &option_name, const std::unique_ptr< NameValueAssign > &p)
std::unique_ptr< Parser::Stmt >	create_stmt_for_query (const std::string &queryStr, const Catalog_Namespace::SessionInfo &session_info)
std::unique_ptr< Parser::Stmt >	create_stmt_for_json (const std::string &query_json)
void	execute_stmt_for_json (const std::string &query_json, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr, bool read_only_mode)
int32_t	validate_and_get_fragment_size (const std::string &fragment_size_str)
void	parser_slistval_to_vector (std::list< std::string * > *l, std::vector< std::string > &v)

Typedef Documentation

using Parser::SubstituteMap = typedef std::map<std::string, std::string>

Definition at line 5191 of file ParserNode.cpp.

Function Documentation

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

Definition at line 5097 of file ParserNode.cpp.

References AccessPrivileges::ALTER_TABLE, Catalog_Namespace::SessionInfo::get_currentUser(), Catalog_Namespace::SessionInfo::getCatalog(), lockmgr::instance(), Catalog_Namespace::UserMetadata::isSuper, DBObject::loadKey(), DBObject::setPrivileges(), TableDBObjectType, TableDescriptor::tableName, TableDescriptor::userId, and Catalog_Namespace::UserMetadata::userId.

Referenced by AlterTableAlterColumnCommand::alterColumn(), Parser::AddColumnStmt::check_executable(), Parser::RenameTableStmt::execute(), Parser::RenameColumnStmt::execute(), Parser::DropColumnStmt::execute(), and Parser::AlterTableParamStmt::execute().

                                                            {
  if (session.get_currentUser().isSuper ||
      session.get_currentUser().userId == td->userId) {
    return;
  }
  std::vector<DBObject> privObjects;
  DBObject dbObject(td->tableName, TableDBObjectType);
  dbObject.loadKey(session.getCatalog());
  dbObject.setPrivileges(AccessPrivileges::ALTER_TABLE);
  privObjects.push_back(dbObject);
  if (!SysCatalog::instance().checkPrivileges(session.get_currentUser(), privObjects)) {
    throw std::runtime_error("Current user does not have the privilege to alter table: " +
                             td->tableName);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Parser::check_session_interrupted	(	const QuerySessionId &	query_session,
		Executor *	executor
	)

Definition at line 107 of file ParserNode.cpp.

References g_enable_non_kernel_time_query_interrupt.

Referenced by Parser::InsertIntoTableAsSelectStmt::populateData().

                                                                                        {
  // we call this function with unitary executor but is okay since
  // we know the exact session info from a global session map object
  // in the executor
  if (g_enable_non_kernel_time_query_interrupt) {
    heavyai::shared_lock<heavyai::shared_mutex> session_read_lock(
        executor->getSessionLock());
    return executor->checkIsQuerySessionInterrupted(query_session, session_read_lock);
  }
  return false;
}

Here is the caller graph for this function:

static void Parser::checkStringLiteral ( const std::string &  option_name, const std::unique_ptr< NameValueAssign > &  p  )

static

Definition at line 6851 of file ParserNode.cpp.

References CHECK.

Referenced by Parser::CreateDBStmt::execute(), Parser::CreateUserStmt::execute(), and Parser::AlterUserStmt::execute().

                                                                        {
  CHECK(p);
  if (!dynamic_cast<const StringLiteral*>(p->get_value())) {
    throw std::runtime_error(option_name + " option must be a string literal.");
  }
}

Here is the caller graph for this function:

std::unique_ptr< ColumnDef > Parser::column_from_json

(

const rapidjson::Value &

element

)

Definition at line 3153 of file ParserNode.cpp.

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

Referenced by AlterTableCommand::execute(), get_columns_from_json_payload(), and Parser::anonymous_namespace{ParserNode.cpp}::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:

SQLTypeInfo Parser::common_string_type	(	const SQLTypeInfo &	lhs_type_info,
		const SQLTypeInfo &	rhs_type_info,
		const Executor *	executor
	)

Definition at line 355 of file ParserNode.cpp.

References CHECK, shared::StringDictKey::dict_id, SQLTypeInfo::get_dimension(), get_str_dict_cast_type(), SQLTypeInfo::getStringDictKey(), SQLTypeInfo::is_dict_encoded_string(), SQLTypeInfo::is_none_encoded_string(), SQLTypeInfo::is_string(), SQLTypeInfo::set_dimension(), and TRANSIENT_DICT.

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

                                                         {
  CHECK(lhs_type_info.is_string());
  CHECK(rhs_type_info.is_string());
  if (lhs_type_info.is_dict_encoded_string() && rhs_type_info.is_dict_encoded_string()) {
    const auto& lhs_dict_key = lhs_type_info.getStringDictKey();
    const auto& rhs_dict_key = rhs_type_info.getStringDictKey();
    if (lhs_dict_key == rhs_dict_key ||
        (lhs_dict_key.db_id == rhs_dict_key.db_id &&
         lhs_dict_key.dict_id == TRANSIENT_DICT(rhs_dict_key.dict_id))) {
      return lhs_dict_key.dict_id <= rhs_dict_key.dict_id ? lhs_type_info : rhs_type_info;
    }
    return get_str_dict_cast_type(lhs_type_info, rhs_type_info, executor);
  }
  CHECK(lhs_type_info.is_none_encoded_string() || rhs_type_info.is_none_encoded_string());
  SQLTypeInfo ret_ti =
      rhs_type_info.is_none_encoded_string() ? lhs_type_info : rhs_type_info;
  if (ret_ti.is_none_encoded_string()) {
    ret_ti.set_dimension(
        std::max(lhs_type_info.get_dimension(), rhs_type_info.get_dimension()));
  }
  return ret_ti;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr< Parser::Stmt > Parser::create_stmt_for_json

(

const std::string &

query_json

)

Definition at line 7294 of file ParserNode.cpp.

References CHECK, UNREACHABLE, and VLOG.

Referenced by create_stmt_for_query(), QueryRunner::QueryRunner::createStatement(), and execute_stmt_for_json().

                                                                            {
  CHECK(!query_json.empty());
  VLOG(2) << "Parsing JSON DDL from Calcite: " << query_json;
  rapidjson::Document ddl_query;
  ddl_query.Parse(query_json);
  CHECK(ddl_query.IsObject());
  CHECK(ddl_query.HasMember("payload"));
  CHECK(ddl_query["payload"].IsObject());
  const auto& payload = ddl_query["payload"].GetObject();
  CHECK(payload.HasMember("command"));
  CHECK(payload["command"].IsString());

  const auto& ddl_command = std::string_view(payload["command"].GetString());

  Parser::Stmt* stmt = nullptr;
  if (ddl_command == "CREATE_TABLE") {
    stmt = new Parser::CreateTableStmt(payload);
  } else if (ddl_command == "DROP_TABLE") {
    stmt = new Parser::DropTableStmt(payload);
  } else if (ddl_command == "RENAME_TABLE") {
    stmt = new Parser::RenameTableStmt(payload);
  } else if (ddl_command == "ALTER_TABLE") {
    // no-op: fall-back to DdlCommandExecutor by returning a nullptr
  } else if (ddl_command == "TRUNCATE_TABLE") {
    stmt = new Parser::TruncateTableStmt(payload);
  } else if (ddl_command == "DUMP_TABLE") {
    stmt = new Parser::DumpTableStmt(payload);
  } else if (ddl_command == "RESTORE_TABLE") {
    stmt = new Parser::RestoreTableStmt(payload);
  } else if (ddl_command == "OPTIMIZE_TABLE") {
    stmt = new Parser::OptimizeTableStmt(payload);
  } else if (ddl_command == "COPY_TABLE") {
    stmt = new Parser::CopyTableStmt(payload);
  } else if (ddl_command == "EXPORT_QUERY") {
    stmt = new Parser::ExportQueryStmt(payload);
  } else if (ddl_command == "CREATE_VIEW") {
    stmt = new Parser::CreateViewStmt(payload);
  } else if (ddl_command == "DROP_VIEW") {
    stmt = new Parser::DropViewStmt(payload);
  } else if (ddl_command == "CREATE_DB") {
    stmt = new Parser::CreateDBStmt(payload);
  } else if (ddl_command == "DROP_DB") {
    stmt = new Parser::DropDBStmt(payload);
  } else if (ddl_command == "RENAME_DB") {
    stmt = new Parser::RenameDBStmt(payload);
  } else if (ddl_command == "CREATE_USER") {
    stmt = new Parser::CreateUserStmt(payload);
  } else if (ddl_command == "DROP_USER") {
    stmt = new Parser::DropUserStmt(payload);
  } else if (ddl_command == "ALTER_USER") {
    stmt = new Parser::AlterUserStmt(payload);
  } else if (ddl_command == "RENAME_USER") {
    stmt = new Parser::RenameUserStmt(payload);
  } else if (ddl_command == "CREATE_ROLE") {
    stmt = new Parser::CreateRoleStmt(payload);
  } else if (ddl_command == "DROP_ROLE") {
    stmt = new Parser::DropRoleStmt(payload);
  } else if (ddl_command == "GRANT_ROLE") {
    stmt = new Parser::GrantRoleStmt(payload);
  } else if (ddl_command == "REVOKE_ROLE") {
    stmt = new Parser::RevokeRoleStmt(payload);
  } else if (ddl_command == "GRANT_PRIVILEGE") {
    stmt = new Parser::GrantPrivilegesStmt(payload);
  } else if (ddl_command == "REVOKE_PRIVILEGE") {
    stmt = new Parser::RevokePrivilegesStmt(payload);
  } else if (ddl_command == "CREATE_DATAFRAME") {
    stmt = new Parser::CreateDataframeStmt(payload);
  } else if (ddl_command == "CREATE_MODEL") {
    stmt = new Parser::CreateModelStmt(payload);
  } else if (ddl_command == "DROP_MODEL") {
    stmt = new Parser::DropModelStmt(payload);
  } else if (ddl_command == "VALIDATE_SYSTEM") {
    // VALIDATE should have been excuted in outer context before it reaches here
    UNREACHABLE();  // not-implemented alterType
  } else {
    throw std::runtime_error("Unsupported DDL command");
  }
  return std::unique_ptr<Parser::Stmt>(stmt);
}

Here is the caller graph for this function:

std::unique_ptr< Parser::Stmt > Parser::create_stmt_for_query	(	const std::string &	queryStr,
		const Catalog_Namespace::SessionInfo &	session_info
	)

Helper functions for parsing the DDL returned from calcite as part of the plan result to a parser node in this class. Currently only used in QueryRunner/DistributedQueryRunner, where we do not want to link in the thrift dependencies wich DdlCommandExecutor currently brings along.

Definition at line 7269 of file ParserNode.cpp.

References cat(), query_state::QueryState::create(), create_stmt_for_json(), g_enable_watchdog, Catalog_Namespace::SessionInfo::getCatalog(), Catalog_Namespace::SysCatalog::instance(), Catalog_Namespace::SysCatalog::isAggregator(), and pg_shim().

Referenced by TableArchiver::restoreTable(), and DBHandler::sql_execute_impl().

                                                      {
  auto session_copy = session_info;
  auto session_ptr = std::shared_ptr<Catalog_Namespace::SessionInfo>(
      &session_copy, boost::null_deleter());
  auto query_state = query_state::QueryState::create(session_ptr, queryStr);
  const auto& cat = session_info.getCatalog();
  auto calcite_mgr = cat.getCalciteMgr();
  const auto calciteQueryParsingOption =
      calcite_mgr->getCalciteQueryParsingOption(true, false, true, false);
  const auto calciteOptimizationOption = calcite_mgr->getCalciteOptimizationOption(
      false,
      g_enable_watchdog,
      {},
      Catalog_Namespace::SysCatalog::instance().isAggregator());
  const auto query_json = calcite_mgr
                              ->process(query_state->createQueryStateProxy(),
                                        pg_shim(queryStr),
                                        calciteQueryParsingOption,
                                        calciteOptimizationOption)
                              .plan_result;
  return create_stmt_for_json(query_json);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static DBObject Parser::createObject ( const std::string &  objectName, DBObjectType  objectType  )

static

Definition at line 6113 of file ParserNode.cpp.

References DashboardDBObjectType.

Referenced by Parser::GrantPrivilegesStmt::execute(), Parser::RevokePrivilegesStmt::execute(), and Parser::ShowPrivilegesStmt::execute().

                                                                                   {
  if (objectType == DashboardDBObjectType) {
    int32_t dashboard_id = -1;
    if (!objectName.empty()) {
      try {
        dashboard_id = stoi(objectName);
      } catch (const std::exception&) {
        throw std::runtime_error(
            "Privileges on dashboards should be changed via integer dashboard ID");
      }
    }
    return DBObject(dashboard_id, objectType);
  } else {
    return DBObject(objectName, objectType);
  }
}

Here is the caller graph for this function:

void Parser::execute_stmt_for_json	(	const std::string &	query_json,
		std::shared_ptr< Catalog_Namespace::SessionInfo const >	session_ptr,
		bool	read_only_mode
	)

Definition at line 7374 of file ParserNode.cpp.

References create_stmt_for_json(), and Parser::DDLStmt::execute().

                         {
  std::unique_ptr<Parser::Stmt> stmt = create_stmt_for_json(query_json);
  auto ddl = dynamic_cast<Parser::DDLStmt*>(stmt.get());
  if (ddl != nullptr) {
    (*ddl).execute(*session_ptr, read_only_mode);
  }
}

Here is the call graph for this function:

std::string Parser::extractObjectNameFromHierName	(	const std::string &	objectHierName,
		const std::string &	objectType,
		const Catalog_Namespace::Catalog &	cat
	)

Definition at line 5976 of file ParserNode.cpp.

References splitObjectHierName().

Referenced by Parser::GrantPrivilegesStmt::execute(), Parser::RevokePrivilegesStmt::execute(), and Parser::ShowPrivilegesStmt::execute().

                                                                               {
  std::string objectName;
  std::vector<std::string> componentNames = splitObjectHierName(objectHierName);
  if (objectType.compare("DATABASE") == 0) {
    if (componentNames.size() == 1) {
      objectName = componentNames[0];
    } else {
      throw std::runtime_error("DB object name is not correct " + objectHierName);
    }
  } else {
    if (objectType.compare("TABLE") == 0 || objectType.compare("DASHBOARD") == 0 ||
        objectType.compare("VIEW") == 0 || objectType.compare("SERVER") == 0) {
      switch (componentNames.size()) {
        case (1): {
          objectName = componentNames[0];
          break;
        }
        case (2): {
          objectName = componentNames[1];
          break;
        }
        default: {
          throw std::runtime_error("DB object name is not correct " + objectHierName);
        }
      }
    } else {
      throw std::runtime_error("DB object type " + objectType + " is not supported.");
    }
  }
  return objectName;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::list< ColumnDef > Parser::get_columns_from_json_payload	(	const std::string &	payload_key,
		const rapidjson::Value &	payload
	)

Definition at line 3230 of file ParserNode.cpp.

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

Referenced by AlterTableAlterColumnCommand::alterColumn().

                                                                                  {
  std::list<ColumnDef> table_element_list;
  CHECK(payload[payload_key].IsArray());

  const auto elements = payload[payload_key].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 {
      LOG(FATAL) << "Unsupported element type for ALTER TABLE: "
                 << element["type"].GetString();
    }
  }
  return table_element_list;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SQLTypeInfo const& Parser::get_str_dict_cast_type	(	const SQLTypeInfo &	lhs_type_info,
		const SQLTypeInfo &	rhs_type_info,
		const Executor *	executor
	)

Definition at line 332 of file ParserNode.cpp.

References CHECK, CHECK_NE, SQLTypeInfo::get_compression(), SQLTypeInfo::getStringDictKey(), SQLTypeInfo::is_string(), and kENCODING_DICT.

Referenced by common_string_type(), and Parser::OperExpr::normalize().

                                                                    {
  CHECK(lhs_type_info.is_string());
  CHECK(lhs_type_info.get_compression() == kENCODING_DICT);
  CHECK(rhs_type_info.is_string());
  CHECK(rhs_type_info.get_compression() == kENCODING_DICT);
  const auto& lhs_dict_key = lhs_type_info.getStringDictKey();
  const auto& rhs_dict_key = rhs_type_info.getStringDictKey();
  CHECK_NE(lhs_dict_key, rhs_dict_key);
  if (lhs_dict_key.isTransientDict()) {
    return rhs_type_info;
  }
  if (rhs_dict_key.isTransientDict()) {
    return lhs_type_info;
  }
  // If here then neither lhs or rhs type was transient, we should see which
  // type has the largest dictionary and make that the destination type
  const auto lhs_sdp = executor->getStringDictionaryProxy(lhs_dict_key, true);
  const auto rhs_sdp = executor->getStringDictionaryProxy(rhs_dict_key, true);
  return lhs_sdp->entryCount() >= rhs_sdp->entryCount() ? lhs_type_info : rhs_type_info;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<ResultSet> Parser::getResultSet	(	QueryStateProxy	query_state_proxy,
		const std::string	select_stmt,
		std::vector< TargetMetaInfo > &	targets,
		bool	validate_only = false,
		std::vector< size_t >	outer_fragment_indices = {},
		bool	allow_interrupt = false
	)

Definition at line 3873 of file ParserNode.cpp.

Referenced by Parser::LocalQueryConnector::query().

                                                                                   {},
                                        bool allow_interrupt = false) {
  auto const session = query_state_proxy->getConstSessionInfo();
  auto& catalog = session->getCatalog();

  auto executor = Executor::getExecutor(Executor::UNITARY_EXECUTOR_ID);
#ifdef HAVE_CUDA
  const auto device_type = session->get_executor_device_type();
#else
  const auto device_type = ExecutorDeviceType::CPU;
#endif  // HAVE_CUDA
  auto calcite_mgr = catalog.getCalciteMgr();

  // TODO MAT this should actually get the global or the session parameter for
  // view optimization
  const auto calciteQueryParsingOption =
      calcite_mgr->getCalciteQueryParsingOption(true, false, true, false);
  const auto calciteOptimizationOption = calcite_mgr->getCalciteOptimizationOption(
      false,
      g_enable_watchdog,
      {},
      Catalog_Namespace::SysCatalog::instance().isAggregator());
  const auto query_ra = calcite_mgr
                            ->process(query_state_proxy,
                                      pg_shim(select_stmt),
                                      calciteQueryParsingOption,
                                      calciteOptimizationOption)
                            .plan_result;
  RelAlgExecutor ra_executor(
      executor.get(), query_ra, query_state_proxy->shared_from_this());
  CompilationOptions co = CompilationOptions::defaults(device_type);
  // TODO(adb): Need a better method of dropping constants into this ExecutionOptions
  // struct
  ExecutionOptions eo = {false,
                         false,
                         true,
                         false,
                         true,
                         false,
                         false,
                         validate_only,
                         false,
                         10000,
                         false,
                         false,
                         1000,
                         allow_interrupt,
                         g_running_query_interrupt_freq,
                         g_pending_query_interrupt_freq,
                         g_optimize_cuda_block_and_grid_sizes,
                         g_from_table_reordering,
                         false,
                         std::numeric_limits<size_t>::max(),
                         ExecutorType::Native,
                         outer_fragment_indices};

  ExecutionResult result{std::make_shared<ResultSet>(std::vector<TargetInfo>{},
                                                     ExecutorDeviceType::CPU,
                                                     QueryMemoryDescriptor(),
                                                     nullptr,
                                                     0,
                                                     0),
                         {}};
  result = ra_executor.executeRelAlgQuery(co, eo, false, false, nullptr);
  targets = result.getTargetsMeta();

  return result.getRows();
}

Here is the caller graph for this function:

std::vector<int> Parser::getTableChunkKey	(	const TableDescriptor *	td,
		Catalog_Namespace::Catalog &	catalog
	)

Definition at line 119 of file ParserNode.cpp.

References Catalog_Namespace::DBMetadata::dbId, TableDescriptor::fragmenter, Catalog_Namespace::Catalog::getCurrentDB(), and TableDescriptor::tableId.

                                                                     {
  std::vector<int> table_chunk_key_prefix;
  if (td) {
    if (td->fragmenter) {
      table_chunk_key_prefix = td->fragmenter->getFragmentsForQuery().chunkKeyPrefix;
    } else {
      table_chunk_key_prefix.push_back(catalog.getCurrentDB().dbId);
      table_chunk_key_prefix.push_back(td->tableId);
    }
  }
  return table_chunk_key_prefix;
}

Here is the call graph for this function:

void Parser::parser_slistval_to_vector ( std::list< std::string * > *  l, std::vector< std::string > &  v  )

inline

Definition at line 1541 of file ParserNode.h.

References CHECK.

Referenced by Parser::GrantPrivilegesStmt::GrantPrivilegesStmt(), Parser::GrantRoleStmt::GrantRoleStmt(), Parser::RevokePrivilegesStmt::RevokePrivilegesStmt(), and Parser::RevokeRoleStmt::RevokeRoleStmt().

                                                               {
  CHECK(l);
  for (auto str : *l) {
    v.push_back(*str);
    delete str;
  }
  delete l;
}

Here is the caller graph for this function:

static std::pair<AccessPrivileges, DBObjectType> Parser::parseStringPrivs ( const std::string &  privs, const DBObjectType &  objectType, const std::string &  object_name  )

static

Definition at line 6010 of file ParserNode.cpp.

References AccessPrivileges::ACCESS, AccessPrivileges::ALL_DASHBOARD, AccessPrivileges::ALL_DATABASE, AccessPrivileges::ALL_SERVER, AccessPrivileges::ALL_TABLE, AccessPrivileges::ALL_VIEW, AccessPrivileges::ALTER_SERVER, AccessPrivileges::ALTER_TABLE, AccessPrivileges::CREATE_DASHBOARD, AccessPrivileges::CREATE_SERVER, AccessPrivileges::CREATE_TABLE, AccessPrivileges::CREATE_VIEW, DashboardDBObjectType, DatabaseDBObjectType, AccessPrivileges::DELETE_DASHBOARD, AccessPrivileges::DELETE_FROM_TABLE, AccessPrivileges::DROP_SERVER, AccessPrivileges::DROP_TABLE, AccessPrivileges::DROP_VIEW, AccessPrivileges::EDIT_DASHBOARD, AccessPrivileges::INSERT_INTO_TABLE, run_benchmark_import::result, AccessPrivileges::SELECT_FROM_TABLE, AccessPrivileges::SELECT_FROM_VIEW, AccessPrivileges::SERVER_USAGE, ServerDBObjectType, TableDBObjectType, AccessPrivileges::TRUNCATE_TABLE, AccessPrivileges::UPDATE_IN_TABLE, AccessPrivileges::VIEW_DASHBOARD, AccessPrivileges::VIEW_SQL_EDITOR, and ViewDBObjectType.

Referenced by Parser::GrantPrivilegesStmt::execute(), and Parser::RevokePrivilegesStmt::execute().

                                  {
  static const std::map<std::pair<const std::string, const DBObjectType>,
                        std::pair<const AccessPrivileges, const DBObjectType>>
      privileges_lookup{
          {{"ALL"s, DatabaseDBObjectType},
           {AccessPrivileges::ALL_DATABASE, DatabaseDBObjectType}},
          {{"ALL"s, TableDBObjectType}, {AccessPrivileges::ALL_TABLE, TableDBObjectType}},
          {{"ALL"s, DashboardDBObjectType},
           {AccessPrivileges::ALL_DASHBOARD, DashboardDBObjectType}},
          {{"ALL"s, ViewDBObjectType}, {AccessPrivileges::ALL_VIEW, ViewDBObjectType}},
          {{"ALL"s, ServerDBObjectType},
           {AccessPrivileges::ALL_SERVER, ServerDBObjectType}},

          {{"CREATE TABLE"s, DatabaseDBObjectType},
           {AccessPrivileges::CREATE_TABLE, TableDBObjectType}},
          {{"CREATE"s, DatabaseDBObjectType},
           {AccessPrivileges::CREATE_TABLE, TableDBObjectType}},
          {{"SELECT"s, DatabaseDBObjectType},
           {AccessPrivileges::SELECT_FROM_TABLE, TableDBObjectType}},
          {{"INSERT"s, DatabaseDBObjectType},
           {AccessPrivileges::INSERT_INTO_TABLE, TableDBObjectType}},
          {{"TRUNCATE"s, DatabaseDBObjectType},
           {AccessPrivileges::TRUNCATE_TABLE, TableDBObjectType}},
          {{"UPDATE"s, DatabaseDBObjectType},
           {AccessPrivileges::UPDATE_IN_TABLE, TableDBObjectType}},
          {{"DELETE"s, DatabaseDBObjectType},
           {AccessPrivileges::DELETE_FROM_TABLE, TableDBObjectType}},
          {{"DROP"s, DatabaseDBObjectType},
           {AccessPrivileges::DROP_TABLE, TableDBObjectType}},
          {{"ALTER"s, DatabaseDBObjectType},
           {AccessPrivileges::ALTER_TABLE, TableDBObjectType}},

          {{"SELECT"s, TableDBObjectType},
           {AccessPrivileges::SELECT_FROM_TABLE, TableDBObjectType}},
          {{"INSERT"s, TableDBObjectType},
           {AccessPrivileges::INSERT_INTO_TABLE, TableDBObjectType}},
          {{"TRUNCATE"s, TableDBObjectType},
           {AccessPrivileges::TRUNCATE_TABLE, TableDBObjectType}},
          {{"UPDATE"s, TableDBObjectType},
           {AccessPrivileges::UPDATE_IN_TABLE, TableDBObjectType}},
          {{"DELETE"s, TableDBObjectType},
           {AccessPrivileges::DELETE_FROM_TABLE, TableDBObjectType}},
          {{"DROP"s, TableDBObjectType},
           {AccessPrivileges::DROP_TABLE, TableDBObjectType}},
          {{"ALTER"s, TableDBObjectType},
           {AccessPrivileges::ALTER_TABLE, TableDBObjectType}},

          {{"CREATE VIEW"s, DatabaseDBObjectType},
           {AccessPrivileges::CREATE_VIEW, ViewDBObjectType}},
          {{"SELECT VIEW"s, DatabaseDBObjectType},
           {AccessPrivileges::SELECT_FROM_VIEW, ViewDBObjectType}},
          {{"DROP VIEW"s, DatabaseDBObjectType},
           {AccessPrivileges::DROP_VIEW, ViewDBObjectType}},
          {{"SELECT"s, ViewDBObjectType},
           {AccessPrivileges::SELECT_FROM_VIEW, ViewDBObjectType}},
          {{"DROP"s, ViewDBObjectType}, {AccessPrivileges::DROP_VIEW, ViewDBObjectType}},

          {{"CREATE DASHBOARD"s, DatabaseDBObjectType},
           {AccessPrivileges::CREATE_DASHBOARD, DashboardDBObjectType}},
          {{"EDIT DASHBOARD"s, DatabaseDBObjectType},
           {AccessPrivileges::EDIT_DASHBOARD, DashboardDBObjectType}},
          {{"VIEW DASHBOARD"s, DatabaseDBObjectType},
           {AccessPrivileges::VIEW_DASHBOARD, DashboardDBObjectType}},
          {{"DELETE DASHBOARD"s, DatabaseDBObjectType},
           {AccessPrivileges::DELETE_DASHBOARD, DashboardDBObjectType}},
          {{"VIEW"s, DashboardDBObjectType},
           {AccessPrivileges::VIEW_DASHBOARD, DashboardDBObjectType}},
          {{"EDIT"s, DashboardDBObjectType},
           {AccessPrivileges::EDIT_DASHBOARD, DashboardDBObjectType}},
          {{"DELETE"s, DashboardDBObjectType},
           {AccessPrivileges::DELETE_DASHBOARD, DashboardDBObjectType}},

          {{"CREATE SERVER"s, DatabaseDBObjectType},
           {AccessPrivileges::CREATE_SERVER, ServerDBObjectType}},
          {{"DROP SERVER"s, DatabaseDBObjectType},
           {AccessPrivileges::DROP_SERVER, ServerDBObjectType}},
          {{"DROP"s, ServerDBObjectType},
           {AccessPrivileges::DROP_SERVER, ServerDBObjectType}},
          {{"ALTER SERVER"s, DatabaseDBObjectType},
           {AccessPrivileges::ALTER_SERVER, ServerDBObjectType}},
          {{"ALTER"s, ServerDBObjectType},
           {AccessPrivileges::ALTER_SERVER, ServerDBObjectType}},
          {{"USAGE"s, ServerDBObjectType},
           {AccessPrivileges::SERVER_USAGE, ServerDBObjectType}},
          {{"SERVER USAGE"s, DatabaseDBObjectType},
           {AccessPrivileges::SERVER_USAGE, ServerDBObjectType}},

          {{"VIEW SQL EDITOR"s, DatabaseDBObjectType},
           {AccessPrivileges::VIEW_SQL_EDITOR, DatabaseDBObjectType}},
          {{"ACCESS"s, DatabaseDBObjectType},
           {AccessPrivileges::ACCESS, DatabaseDBObjectType}}};

  auto result = privileges_lookup.find(std::make_pair(privs, objectType));
  if (result == privileges_lookup.end()) {
    throw std::runtime_error("Privileges " + privs + " on DB object " + object_name +
                             " are not correct.");
  }
  return result->second;
}

Here is the caller graph for this function:

static bool Parser::readBooleanLiteral ( const std::string &  option_name, const std::unique_ptr< NameValueAssign > &  p  )

static

Definition at line 6943 of file ParserNode.cpp.

References CHECK.

Referenced by Parser::CreateUserStmt::execute(), and Parser::AlterUserStmt::execute().

                                                                        {
  CHECK(p);
  const std::string* str =
      static_cast<const StringLiteral*>(p->get_value())->get_stringval();
  if (boost::iequals(*str, "true")) {
    return true;
  } else if (boost::iequals(*str, "false")) {
    return false;
  } else {
    throw std::runtime_error("Value to " + option_name + " must be TRUE or FALSE.");
  }
}

Here is the caller graph for this function:

bool Parser::repair_type

(

std::list< std::unique_ptr< NameValueAssign >> &

options

)

Definition at line 5053 of file ParserNode.cpp.

References CHECK.

Referenced by Parser::ValidateStmt::ValidateStmt().

                                                                   {
  for (const auto& opt : options) {
    if (boost::iequals(*opt->get_name(), "REPAIR_TYPE")) {
      const auto repair_type =
          static_cast<const StringLiteral*>(opt->get_value())->get_stringval();
      CHECK(repair_type);
      if (boost::iequals(*repair_type, "REMOVE")) {
        return true;
      } else {
        throw std::runtime_error("REPAIR_TYPE must be REMOVE.");
      }
    } else {
      throw std::runtime_error("The only VALIDATE WITH options is REPAIR_TYPE.");
    }
  }
  return false;
}

Here is the caller graph for this function:

void Parser::set_column_descriptor	(	ColumnDescriptor &	cd,
		const ColumnDef *	coldef
	)

Definition at line 5335 of file ParserNode.cpp.

References Parser::ColumnDef::get_column_constraint(), Parser::ColumnDef::get_column_name(), Parser::ColumnDef::get_column_type(), Parser::ColumnDef::get_compression(), Parser::ColumnConstraintDef::get_defaultval(), ddl_utils::SqlType::get_is_array(), Parser::ColumnConstraintDef::get_notnull(), Parser::StringLiteral::get_stringval(), and ddl_utils::set_column_descriptor().

Referenced by anonymous_namespace{DdlCommandExecutor.cpp}::get_alter_column_src_dst_cds(), and Parser::DDLStmt::setColumnDescriptor().

                                                                          {
  bool not_null;
  const ColumnConstraintDef* cc = coldef->get_column_constraint();
  if (cc == nullptr) {
    not_null = false;
  } else {
    not_null = cc->get_notnull();
  }
  std::string default_value;
  const std::string* default_value_ptr = nullptr;
  if (cc) {
    if (auto def_val_literal = cc->get_defaultval()) {
      auto defaultsp = dynamic_cast<const StringLiteral*>(def_val_literal);
      default_value =
          defaultsp ? *defaultsp->get_stringval() : def_val_literal->to_string();
      // The preprocessing below is needed because:
      // a) TypedImportBuffer expects arrays in the {...} format
      // b) TypedImportBuffer expects string literals inside arrays w/o any quotes
      if (coldef->get_column_type()->get_is_array()) {
        std::regex array_re(R"(^ARRAY\s*\[(.*)\]$)", std::regex_constants::icase);
        default_value = std::regex_replace(default_value, array_re, "{$1}");
        boost::erase_all(default_value, "\'");
      }
      default_value_ptr = &default_value;
    }
  }
  ddl_utils::set_column_descriptor(*coldef->get_column_name(),
                                   cd,
                                   coldef->get_column_type(),
                                   not_null,
                                   coldef->get_compression(),
                                   default_value_ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Parser::should_translate_strings	(	const std::shared_ptr< Analyzer::Expr > &	lhs_expr,
		const std::shared_ptr< Analyzer::Expr > &	rhs_expr
	)

Definition at line 317 of file ParserNode.cpp.

References CHECK.

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

                                                                           {
  if (dynamic_cast<Analyzer::Constant*>(rhs_expr.get())) {
    // we must translate rhs string literal against lhs str dictionary
    return true;
  }
  std::set<int> lhs_rte_idx;
  lhs_expr->collect_rte_idx(lhs_rte_idx);
  CHECK(!lhs_rte_idx.empty());
  std::set<int> rhs_rte_idx;
  rhs_expr->collect_rte_idx(rhs_rte_idx);
  CHECK(!rhs_rte_idx.empty());
  return lhs_rte_idx.size() == 1UL && lhs_rte_idx == rhs_rte_idx;
}

Here is the caller graph for this function:

std::vector<std::string> Parser::splitObjectHierName

(

const std::string &

hierName

)

Definition at line 5970 of file ParserNode.cpp.

References split().

Referenced by extractObjectNameFromHierName().

                                                                    {
  std::vector<std::string> componentNames;
  boost::split(componentNames, hierName, boost::is_any_of("."));
  return componentNames;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int32_t Parser::validate_and_get_fragment_size

(

const std::string &

fragment_size_str

)

Definition at line 7385 of file ParserNode.cpp.

References to_string().

Referenced by Parser::anonymous_namespace{ParserNode.cpp}::get_frag_size_def(), and CreateForeignTableCommand::setTableDetails().

                                                                           {
  int64_t fragment_size_value{-1};
  bool validation_failed{false};
  try {
    fragment_size_value = std::stoll(fragment_size_str);
  } catch (std::out_of_range& e) {
    validation_failed = true;
  }
  constexpr int64_t max_fragment_size = std::numeric_limits<int32_t>::max();
  if (!validation_failed &&
      (fragment_size_value <= 0 || fragment_size_value > max_fragment_size)) {
    validation_failed = true;
  }
  if (validation_failed) {
    throw std::runtime_error(
        "Invalid value \"" + fragment_size_str +
        "\" provided for FRAGMENT_SIZE option, expected a positive integer between "
        "1 and " +
        std::to_string(max_fragment_size) + ".");
  }
  return fragment_size_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void Parser::verifyObject ( Catalog_Namespace::Catalog &  sessionCatalog, const std::string &  objectName, DBObjectType  objectType, const std::string &  command  )

static

Definition at line 6132 of file ParserNode.cpp.

References DBObjectTypeToString(), Catalog_Namespace::Catalog::getMetadataForTable(), TableDescriptor::isView, TableDBObjectType, and ViewDBObjectType.

Referenced by Parser::GrantPrivilegesStmt::execute(), Parser::RevokePrivilegesStmt::execute(), and Parser::ShowPrivilegesStmt::execute().

                                                   {
  if (objectType == TableDBObjectType) {
    auto td = sessionCatalog.getMetadataForTable(objectName, false);
    if (!td || td->isView) {
      // expected TABLE, found VIEW
      throw std::runtime_error(command + " failed. Object '" + objectName + "' of type " +
                               DBObjectTypeToString(objectType) + " not found.");
    }

  } else if (objectType == ViewDBObjectType) {
    auto td = sessionCatalog.getMetadataForTable(objectName, false);
    if (!td || !td->isView) {
      // expected VIEW, found TABLE
      throw std::runtime_error(command + " failed. Object '" + objectName + "' of type " +
                               DBObjectTypeToString(objectType) + " not found.");
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string Parser::write_model_params_to_json	(	const std::string &	predicted,
		const std::vector< std::string > &	features,
		const std::string &	training_query,
		const double	data_split_train_fraction,
		const double	data_split_eval_fraction,
		const std::vector< int64_t > &	feature_permutations
	)

Definition at line 3485 of file ParserNode.cpp.

Referenced by Parser::CreateModelStmt::train_model().

                                                                                       {
  // Create a RapidJSON document
  rapidjson::Document doc;
  doc.SetObject();

  // Add the fields to the document
  rapidjson::Value predicted_value;
  predicted_value.SetString(predicted.c_str(), predicted.length(), doc.GetAllocator());
  doc.AddMember("predicted", predicted_value, doc.GetAllocator());

  rapidjson::Value features_array(rapidjson::kArrayType);
  for (const auto& feature : features) {
    rapidjson::Value feature_value;
    feature_value.SetString(feature.c_str(), feature.length(), doc.GetAllocator());
    features_array.PushBack(feature_value, doc.GetAllocator());
  }
  doc.AddMember("features", features_array, doc.GetAllocator());

  rapidjson::Value training_query_value;
  training_query_value.SetString(
      training_query.c_str(), training_query.length(), doc.GetAllocator());
  doc.AddMember("training_query", training_query_value, doc.GetAllocator());

  rapidjson::Value data_split_train_fraction_key("data_split_train_fraction",
                                                 doc.GetAllocator());

  rapidjson::Value data_split_train_fraction_value(data_split_train_fraction);

  doc.AddMember(
      data_split_train_fraction_key, data_split_train_fraction_value, doc.GetAllocator());

  rapidjson::Value data_split_eval_fraction_key("data_split_eval_fraction",
                                                doc.GetAllocator());

  rapidjson::Value data_split_eval_fraction_value(data_split_eval_fraction);

  doc.AddMember(
      data_split_eval_fraction_key, data_split_eval_fraction_value, doc.GetAllocator());

  rapidjson::Value feature_permutations_array(rapidjson::kArrayType);
  for (const auto& feature_permutation : feature_permutations) {
    rapidjson::Value feature_permutation_value;
    feature_permutation_value.SetInt64(feature_permutation);
    feature_permutations_array.PushBack(feature_permutation_value, doc.GetAllocator());
  }
  doc.AddMember("feature_permutations", feature_permutations_array, doc.GetAllocator());

  // Convert the document to a JSON string
  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
  doc.Accept(writer);

  return buffer.GetString();
}

Here is the caller graph for this function: