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 >

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

Typedef Documentation

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

Definition at line 4115 of file ParserNode.cpp.

Function Documentation

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

Definition at line 3002 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 4475 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 3905 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 3776 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 2261 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(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, true)
           .plan_result;
   CompilationOptions co = CompilationOptions::defaults(device_type);
   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};
   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, 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 1506 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 3810 of file ParserNode.cpp.

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 4543 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 3770 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:

Namespaces

Classes

Typedefs

Functions

Typedef Documentation

Function Documentation