Parser Namespace Reference

Namespaces
	anonymous_namespace{ParserNode.cpp}

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	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
struct	DistributedConnector
struct	LocalConnector
class	CreateDataframeStmt
class	InsertIntoTableAsSelectStmt
class	CreateTableAsSelectStmt
class	DropTableStmt
class	TruncateTableStmt
class	OptimizeTableStmt
class	ValidateStmt
class	RenameDatabaseStmt
class	RenameUserStmt
class	RenameTableStmt
class	RenameColumnStmt
class	AddColumnStmt
class	DropColumnStmt
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	ShowCreateTableStmt
class	ExportQueryStmt
class	CreateViewStmt
class	DropViewStmt
class	CreateDBStmt
class	DropDBStmt
class	CreateUserStmt
class	AlterUserStmt
class	DropUserStmt
class	InsertStmt
class	InsertValuesStmt
class	Assignment
class	UpdateStmt
class	DeleteStmt
struct	DefaultValidate
struct	DefaultValidate< IntLiteral >
struct	DefaultValidate< StringLiteral >
struct	CaseSensitiveValidate
struct	ShouldInvalidateSessionsByDB
struct	ShouldInvalidateSessionsByUser
struct	ShouldInvalidateSessionsByDB< DropDBStmt >
struct	ShouldInvalidateSessionsByUser< DropUserStmt >
struct	ShouldInvalidateSessionsByDB< RenameDatabaseStmt >
struct	ShouldInvalidateSessionsByUser< RenameUserStmt >
class	TrackedPtr
class	TrackedListPtr

Functions
template<typename DDLSTMT >
auto	parseDDL (const std::string &stmt_type, const std::string &stmt_str)
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={})
void	check_alter_table_privilege (const Catalog_Namespace::SessionInfo &session, const TableDescriptor *td)
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	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)
void	parser_slistval_to_vector (std::list< std::string * > *l, std::vector< std::string > &v)

Function Documentation

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

Definition at line 3155 of file ParserNode.cpp.

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

Referenced by Parser::AddColumnStmt::check_executable(), Parser::RenameTableStmt::execute(), Parser::RenameColumnStmt::execute(), and Parser::DropColumnStmt::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:

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

static

Definition at line 4639 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 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 4070 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:

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

Definition at line 3941 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::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 = {}
	)

Definition at line 2348 of file ParserNode.cpp.

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

                                                                                   {}) {
  auto const session = query_state_proxy.getQueryState().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 query_ra =
      calcite_mgr
          ->process(query_state_proxy, pg_shim(select_stmt), {}, true, false, false, true)
          .plan_result;
  RelAlgExecutor ra_executor(executor.get(), catalog, query_ra);
  CompilationOptions co = CompilationOptions::defaults(device_type);
  const auto& query_hints = ra_executor.getParsedQueryHints();
  if (query_hints.cpu_mode) {
    co.device_type = ExecutorDeviceType::CPU;
  }
  co.opt_level = ExecutorOptLevel::LoopStrengthReduction;
  // TODO(adb): Need a better method of dropping constants into this ExecutionOptions
  // struct
  ExecutionOptions eo = {false,
                         true,
                         false,
                         true,
                         false,
                         false,
                         validate_only,
                         false,
                         10000,
                         false,
                         false,
                         0.9,
                         false,
                         1000,
                         ExecutorType::Native,
                         outer_fragment_indices};
  ExecutionResult result{std::make_shared<ResultSet>(std::vector<TargetInfo>{},
                                                     ExecutorDeviceType::CPU,
                                                     QueryMemoryDescriptor(),
                                                     nullptr,
                                                     nullptr),
                         {}};
  result = ra_executor.executeRelAlgQuery(co, eo, false, nullptr);
  targets = result.getTargetsMeta();

  return result.getRows();
}

Here is the caller graph for this function:

template<typename DDLSTMT >

auto Parser::parseDDL	(	const std::string &	stmt_type,
		const std::string &	stmt_str
	)

Definition at line 29 of file ParseDDL.h.

References run_benchmark_import::parser.

                                                                     {
  std::list<std::unique_ptr<Parser::Stmt>> parse_trees;
  std::string last_parsed;
  SQLParser parser;
  if (parser.parse(stmt_str, parse_trees, last_parsed) > 0) {
    throw std::runtime_error("Syntax error in " + stmt_type + " \"" + stmt_str +
                             "\" at " + last_parsed);
  }
  if (auto ddl_stmt = dynamic_cast<DDLSTMT*>(parse_trees.front().get())) {
    parse_trees.front().release();
    return std::unique_ptr<DDLSTMT>(ddl_stmt);
  }
  throw std::runtime_error("Expected " + stmt_type + " is not found in \"" + stmt_str +
                           "\"");
}

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

inline

Definition at line 1508 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 call graph for this function:

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 3975 of file ParserNode.cpp.

References AccessPrivileges::ACCESS, AccessPrivileges::ALL_DASHBOARD, AccessPrivileges::ALL_DATABASE, AccessPrivileges::ALL_SERVER, AccessPrivileges::ALL_TABLE, AccessPrivileges::ALL_VIEW, 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, 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}},

          {{"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 4707 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 call graph for this function:

Here is the caller graph for this function:

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

(

const std::string &

hierName

)

Definition at line 3935 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: