Parser Namespace Reference

Namespaces
	anonymous_namespace{ParserNode.cpp}

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

Typedefs
using	dbl = std::numeric_limits< double >

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)
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)

Typedef Documentation

dbl

using Parser::dbl = typedef std::numeric_limits<double>

Definition at line 4137 of file ParserNode.cpp.

Function Documentation

check_alter_table_privilege()

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

Definition at line 2914 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(), and Parser::RenameColumnStmt::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:

checkStringLiteral()

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

static

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

createObject()

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

static

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

extractObjectNameFromHierName()

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

Definition at line 3821 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) {
      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:

getResultSet()

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

Definition at line 2248 of file ParserNode.cpp.

References CPU, query_state::QueryState::getConstSessionInfo(), Executor::getExecutor(), query_state::QueryStateProxy::getQueryState(), LoopStrengthReduction, pg_shim(), and run_benchmark_import::result.

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

                                                                    {
  auto const session = query_state_proxy.getQueryState().getConstSessionInfo();
  auto& catalog = session->getCatalog();

  auto executor = Executor::getExecutor(catalog.getCurrentDB().dbId);

#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)
          .plan_result;
  CompilationOptions co = {
      device_type, true, ExecutorOptLevel::LoopStrengthReduction, false};
  // 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};
  RelAlgExecutor ra_executor(executor.get(), catalog, query_ra);
  ExecutionResult result{std::make_shared<ResultSet>(std::vector<TargetInfo>{},
                                                     ExecutorDeviceType::CPU,
                                                     QueryMemoryDescriptor(),
                                                     nullptr,
                                                     nullptr),
                         {}};
  result = ra_executor.executeRelAlgQuery(co, eo, nullptr);
  targets = result.getTargetsMeta();

  return result.getRows();
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseDDL()

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 +
                           "\"");
}

parser_slistval_to_vector()

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

inline

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

parseStringPrivs()

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

static

Definition at line 3855 of file ParserNode.cpp.

References AccessPrivileges::ACCESS, AccessPrivileges::ALL_DASHBOARD, AccessPrivileges::ALL_DATABASE, AccessPrivileges::ALL_TABLE, AccessPrivileges::ALL_VIEW, AccessPrivileges::ALTER_TABLE, AccessPrivileges::CREATE_DASHBOARD, AccessPrivileges::CREATE_TABLE, AccessPrivileges::CREATE_VIEW, DashboardDBObjectType, DatabaseDBObjectType, AccessPrivileges::DELETE_DASHBOARD, AccessPrivileges::DELETE_FROM_TABLE, 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, 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}},

          {{"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}},

          {{"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:

readBooleanLiteral()

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

static

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

splitObjectHierName()

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

(

const std::string &

hierName

)

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