#include <ParserWrapper.h>

Collaboration diagram for ParserWrapper:

Public Types
enum	DMLType : int { DMLType::Insert = 0, DMLType::Delete, DMLType::Update, DMLType::Upsert, DMLType::NotDML }

enum	ExplainType { ExplainType::None, ExplainType::IR, ExplainType::OptimizedIR, ExplainType::Calcite, ExplainType::ExecutionPlan, ExplainType::Other }

enum	QueryType { QueryType::Unknown, QueryType::Read, QueryType::Write, QueryType::SchemaRead, QueryType::SchemaWrite }

Public Member Functions
	ParserWrapper (std::string query_string)

std::string	process (std::string user, std::string passwd, std::string catalog, std::string sql_string, const bool legacy_syntax)

virtual	~ParserWrapper ()

DMLType	getDMLType () const

ExplainInfo	getExplainInfo () const

ExplainType	getExplainType () const

QueryType	getQueryType () const

bool	isUpdateDelete () const

bool	isCalciteExplain () const

bool	isPlanExplain () const

bool	isSelectExplain () const

bool	isIRExplain () const

bool	isCalcitePathPermissable (bool read_only_mode=false)

bool	isOtherExplain () const

bool	isCalcitePermissableDml (bool read_only_mode=false)

bool	isCalcitePermissableDdl (bool read_only_mode)

bool	isCalciteDdl () const

Public Attributes
bool	is_ddl = false

bool	is_update_dml = false

bool	is_ctas = false

bool	is_itas = false

bool	is_copy = false

bool	is_copy_to = false

bool	is_optimize = false

bool	is_validate = false

std::string	actual_query

Private Attributes
DMLType	dml_type_ = DMLType::NotDML

ExplainType	explain_type_ = ExplainType::None

QueryType	query_type_ = QueryType::Unknown

bool	is_legacy_ddl_ = false

bool	is_calcite_ddl_ = false

Static Private Attributes
static const std::vector < std::string >	ddl_cmd

static const std::vector < std::string >	update_dml_cmd

static const std::string	explain_str = {"explain"}

static const std::string	calcite_explain_str = {"explain calcite"}

static const std::string	optimized_explain_str = {"explain optimized"}

static const std::string	plan_explain_str = {"explain plan"}

static const std::string	optimize_str = {"optimize"}

static const std::string	validate_str = {"validate"}

Detailed Description

Definition at line 44 of file ParserWrapper.h.

Member Enumeration Documentation

enum ParserWrapper::DMLType : int

strong

Enumerator
Insert
Delete
Update
Upsert
NotDML

Definition at line 47 of file ParserWrapper.h.

47 : int { Insert = 0, Delete, Update, Upsert, NotDML };

enum ParserWrapper::ExplainType

strong

Enumerator
None
IR
OptimizedIR
Calcite
ExecutionPlan
Other

Definition at line 49 of file ParserWrapper.h.

49 { None, IR, OptimizedIR, Calcite, ExecutionPlan, Other };

logger::IR

Definition: Logger.h:67

Calcite

Definition: Calcite.h:61

ClientProtocol::Other

enum ParserWrapper::QueryType

strong

Enumerator
Unknown
Read
Write
SchemaRead
SchemaWrite

Definition at line 51 of file ParserWrapper.h.

51 { Unknown, Read, Write, SchemaRead, SchemaWrite };

Constructor & Destructor Documentation

ParserWrapper::ParserWrapper ( std::string query_string )

Definition at line 65 of file ParserWrapper.cpp.

References g_enable_calcite_ddl_parser, g_enable_fsi, i, logger::IR, and update_dml_cmd.

                                                    {
   query_type_ = QueryType::SchemaRead;
   if (boost::istarts_with(query_string, calcite_explain_str)) {
     actual_query = boost::trim_copy(query_string.substr(calcite_explain_str.size()));
     ParserWrapper inner{actual_query};
     if (inner.is_ddl || inner.is_update_dml) {
       explain_type_ = ExplainType::Other;
       return;
     } else {
       explain_type_ = ExplainType::Calcite;
       return;
     }
   }
 
   if (boost::istarts_with(query_string, optimized_explain_str)) {
     actual_query = boost::trim_copy(query_string.substr(optimized_explain_str.size()));
     ParserWrapper inner{actual_query};
     if (inner.is_ddl || inner.is_update_dml) {
       explain_type_ = ExplainType::Other;
       return;
     } else {
       explain_type_ = ExplainType::OptimizedIR;
       return;
     }
   }
 
   if (boost::istarts_with(query_string, plan_explain_str)) {
     actual_query = boost::trim_copy(query_string.substr(plan_explain_str.size()));
     ParserWrapper inner{actual_query};
     if (inner.is_ddl || inner.is_update_dml) {
       explain_type_ = ExplainType::Other;
       return;
     } else {
       explain_type_ = ExplainType::ExecutionPlan;
       return;
     }
   }
 
   if (boost::istarts_with(query_string, explain_str)) {
     actual_query = boost::trim_copy(query_string.substr(explain_str.size()));
     ParserWrapper inner{actual_query};
     if (inner.is_ddl || inner.is_update_dml) {
       explain_type_ = ExplainType::Other;
       return;
     } else {
       explain_type_ = ExplainType::IR;
       return;
     }
   }
 
   if (boost::istarts_with(query_string, optimize_str)) {
     query_type_ = QueryType::SchemaWrite;
     is_optimize = true;
     return;
   }
 
   if (boost::istarts_with(query_string, validate_str)) {
     is_validate = true;
     return;
   }
 
   query_type_ = QueryType::Read;
   for (std::string ddl : ddl_cmd) {
     is_ddl = boost::istarts_with(query_string, ddl);
     if (is_ddl) {
       query_type_ = QueryType::SchemaWrite;
       if (g_enable_fsi) {
         std::string fsi_regex_pattern{
             R"((CREATE|DROP|ALTER)\s+(SERVER|FOREIGN\s+TABLE).*)"};
 
         boost::regex fsi_regex{fsi_regex_pattern,
                                boost::regex::extended | boost::regex::icase};
         boost::regex refresh_regex{R"(REFRESH\s+FOREIGN\s+TABLES.*)",
                                    boost::regex::extended | boost::regex::icase};
 
         if (boost::regex_match(query_string, fsi_regex) ||
             boost::regex_match(query_string, refresh_regex)) {
           is_calcite_ddl_ = true;
           is_legacy_ddl_ = false;
           return;
         }
       }
       if (ddl == "CREATE") {
         boost::regex ctas_regex{R"(CREATE\s+TABLE.*(\"|\s)AS(\(|\s)+(SELECT|WITH).*)",
                                 boost::regex::extended | boost::regex::icase};
         if (boost::regex_match(query_string, ctas_regex)) {
           is_ctas = true;
         } else {
           boost::regex create_table_regex{R"(CREATE\s+TABLE.*)",
                                           boost::regex::extended | boost::regex::icase};
           boost::regex create_view_regex{R"(CREATE\s+VIEW.*)",
                                          boost::regex::extended | boost::regex::icase};
           if (g_enable_calcite_ddl_parser &&
               (boost::regex_match(query_string, create_table_regex) ||
                boost::regex_match(query_string, create_view_regex))) {
             is_calcite_ddl_ = true;
             is_legacy_ddl_ = false;
             return;
           }
         }
       } else if (ddl == "COPY") {
         is_copy = true;
         // now check if it is COPY TO
         boost::regex copy_to{R"(COPY\s*\(([^#])(.+)\)\s+TO\s+.*)",
                              boost::regex::extended | boost::regex::icase};
         if (boost::regex_match(query_string, copy_to)) {
           query_type_ = QueryType::Read;
           is_copy_to = true;
         } else {
           query_type_ = QueryType::Write;
         }
       } else if (ddl == "SHOW") {
         query_type_ = QueryType::SchemaRead;
         boost::regex show_create_table_regex{
             R"(SHOW\s+CREATE\s+TABLE\s+.*)",
             boost::regex::extended | boost::regex::icase};
         if (!boost::regex_match(query_string, show_create_table_regex)) {
           is_calcite_ddl_ = true;
           is_legacy_ddl_ = false;
           return;
         }
       } else if (ddl == "DROP") {
         boost::regex drop_table_regex{R"(DROP\s+TABLE.*)",
                                       boost::regex::extended | boost::regex::icase};
         boost::regex drop_view_regex{R"(DROP\s+VIEW.*)",
                                      boost::regex::extended | boost::regex::icase};
         if (g_enable_calcite_ddl_parser &&
             (boost::regex_match(query_string, drop_table_regex) ||
              boost::regex_match(query_string, drop_view_regex))) {
           is_calcite_ddl_ = true;
           is_legacy_ddl_ = false;
           return;
         }
       } else if (ddl == "KILL") {
         query_type_ = QueryType::Unknown;
         is_calcite_ddl_ = true;
         is_legacy_ddl_ = false;
         return;
       } else if (ddl == "RENAME") {
         query_type_ = QueryType::SchemaWrite;
         is_calcite_ddl_ = true;
         is_legacy_ddl_ = false;
         return;
       } else if (ddl == "ALTER") {
         query_type_ = QueryType::SchemaWrite;
         boost::regex alter_table_regex{R"(ALTER\s+TABLE.*)",
                                        boost::regex::extended | boost::regex::icase};
         if (g_enable_calcite_ddl_parser &&
             boost::regex_match(query_string, alter_table_regex)) {
           is_calcite_ddl_ = true;
           is_legacy_ddl_ = false;
           return;
         }
       }
       is_legacy_ddl_ = !is_calcite_ddl_;
       return;
     }
   }
 
   for (int i = 0; i < update_dml_cmd.size(); i++) {
     is_update_dml = boost::istarts_with(query_string, ParserWrapper::update_dml_cmd[i]);
     if (is_update_dml) {
       query_type_ = QueryType::Write;
       dml_type_ = (DMLType)(i);
       break;
     }
   }
 
   if (dml_type_ == DMLType::Insert) {
     boost::regex itas_regex{R"(INSERT\s+INTO\s+.*(\s+|\(|\")SELECT(\s|\(|\").*)",
                             boost::regex::extended | boost::regex::icase};
     if (boost::regex_match(query_string, itas_regex)) {
       is_itas = true;
       return;
     }
   }
 }

ParserWrapper::~ParserWrapper ( )

virtual

Definition at line 243 of file ParserWrapper.cpp.

243 {}

Member Function Documentation

DMLType ParserWrapper::getDMLType ( ) const

inline

Definition at line 73 of file ParserWrapper.h.

References dml_type_.

Referenced by isCalcitePermissableDml().

73 { return dml_type_; }

ParserWrapper::dml_type_

DMLType dml_type_

Definition: ParserWrapper.h:132

Here is the caller graph for this function:

ExplainInfo ParserWrapper::getExplainInfo ( ) const

Definition at line 245 of file ParserWrapper.cpp.

References logger::IR.

                                                 {
   return {explain_type_ == ExplainType::IR,
           explain_type_ == ExplainType::OptimizedIR,
           explain_type_ == ExplainType::ExecutionPlan,
           explain_type_ == ExplainType::Calcite};
 }

ExplainType ParserWrapper::getExplainType ( ) const

inline

Definition at line 77 of file ParserWrapper.h.

References explain_type_.

77 { return explain_type_; }

ParserWrapper::explain_type_

ExplainType explain_type_

Definition: ParserWrapper.h:133

QueryType ParserWrapper::getQueryType ( ) const

inline

Definition at line 79 of file ParserWrapper.h.

References query_type_.

79 { return query_type_; }

ParserWrapper::query_type_

QueryType query_type_

Definition: ParserWrapper.h:134

bool ParserWrapper::isCalciteDdl ( ) const

inline

Definition at line 129 of file ParserWrapper.h.

References is_calcite_ddl_.

129 { return is_calcite_ddl_; }

ParserWrapper::is_calcite_ddl_

bool is_calcite_ddl_

Definition: ParserWrapper.h:146

bool ParserWrapper::isCalciteExplain ( ) const

inline

Definition at line 85 of file ParserWrapper.h.

References Calcite, and explain_type_.

85 { return explain_type_ == ExplainType::Calcite; }

ParserWrapper::ExplainType::Calcite

ParserWrapper::explain_type_

ExplainType explain_type_

Definition: ParserWrapper.h:133

bool ParserWrapper::isCalcitePathPermissable ( bool read_only_mode = false )

inline

Definition at line 99 of file ParserWrapper.h.

References explain_type_, is_calcite_ddl_, is_legacy_ddl_, is_optimize, is_validate, isCalcitePermissableDdl(), isCalcitePermissableDml(), and Other.

                                                              {
     if (is_calcite_ddl_) {
       return isCalcitePermissableDdl(read_only_mode);
     }
     return (!is_legacy_ddl_ && !is_optimize && !is_validate &&
             isCalcitePermissableDml(read_only_mode) &&
             !(explain_type_ == ExplainType::Other));
   }

Here is the call graph for this function:

bool ParserWrapper::isCalcitePermissableDdl ( bool read_only_mode )

inline

Definition at line 121 of file ParserWrapper.h.

References query_type_, SchemaWrite, and Write.

Referenced by isCalcitePathPermissable().

                                                     {
     if (read_only_mode) {
       // If we're read-only, no Write/SchemaWrite DDL is permissable
       return query_type_ != QueryType::Write && query_type_ != QueryType::SchemaWrite;
     }
     return true;
   }

Here is the caller graph for this function:

bool ParserWrapper::isCalcitePermissableDml ( bool read_only_mode = false )

inline

Definition at line 110 of file ParserWrapper.h.

References Delete, getDMLType(), is_itas, is_update_dml, and Update.

Referenced by isCalcitePathPermissable().

                                                             {
     if (is_itas) {
       return !read_only_mode;
     }
     if (read_only_mode) {
       return !is_update_dml;  // If we're read-only, no update/delete DML is permissable
     }
     return !is_update_dml || (getDMLType() == ParserWrapper::DMLType::Delete) ||
            (getDMLType() == ParserWrapper::DMLType::Update);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

bool ParserWrapper::isIRExplain ( ) const

inline

Definition at line 95 of file ParserWrapper.h.

References explain_type_, IR, and OptimizedIR.

                            {
     return explain_type_ == ExplainType::IR || explain_type_ == ExplainType::OptimizedIR;
   }

bool ParserWrapper::isOtherExplain ( ) const

inline

Definition at line 108 of file ParserWrapper.h.

References explain_type_, and Other.

108 { return explain_type_ == ExplainType::Other; }

ParserWrapper::ExplainType::Other

ParserWrapper::explain_type_

ExplainType explain_type_

Definition: ParserWrapper.h:133

bool ParserWrapper::isPlanExplain ( ) const

inline

Definition at line 87 of file ParserWrapper.h.

References ExecutionPlan, and explain_type_.

87 { return explain_type_ == ExplainType::ExecutionPlan; }

ParserWrapper::ExplainType::ExecutionPlan

ParserWrapper::explain_type_

ExplainType explain_type_

Definition: ParserWrapper.h:133

bool ParserWrapper::isSelectExplain ( ) const

inline

Definition at line 89 of file ParserWrapper.h.

References Calcite, ExecutionPlan, explain_type_, IR, and OptimizedIR.

Referenced by DBHandler::parse_to_ra().

                                {
     return explain_type_ == ExplainType::Calcite || explain_type_ == ExplainType::IR ||
            explain_type_ == ExplainType::OptimizedIR ||
            explain_type_ == ExplainType::ExecutionPlan;
   }

Here is the caller graph for this function:

bool ParserWrapper::isUpdateDelete ( ) const

inline

Definition at line 81 of file ParserWrapper.h.

References Delete, dml_type_, and Update.

                               {
     return dml_type_ == DMLType::Update || dml_type_ == DMLType::Delete;
   }

std::string ParserWrapper::process	(	std::string	user,
		std::string	passwd,
		std::string	catalog,
		std::string	sql_string,
		const bool	legacy_syntax
	)

Member Data Documentation

std::string ParserWrapper::actual_query

Definition at line 71 of file ParserWrapper.h.

const std::string ParserWrapper::calcite_explain_str = {"explain calcite"}

staticprivate

Definition at line 139 of file ParserWrapper.h.

const std::vector< std::string > ParserWrapper::ddl_cmd

staticprivate

Initial value:

= {"ARCHIVE",
                                                         "ALTER",
                                                         "COPY",
                                                         "GRANT",
                                                         "CREATE",
                                                         "DROP",
                                                         "DUMP",
                                                         "OPTIMIZE",
                                                         "REFRESH",
                                                         "RENAME",
                                                         "RESTORE",
                                                         "REVOKE",
                                                         "SHOW",
                                                         "TRUNCATE",
                                                         "KILL"}

Definition at line 136 of file ParserWrapper.h.

DMLType ParserWrapper::dml_type_ = DMLType::NotDML

private

Definition at line 132 of file ParserWrapper.h.

Referenced by getDMLType(), and isUpdateDelete().

const std::string ParserWrapper::explain_str = {"explain"}

staticprivate

Definition at line 138 of file ParserWrapper.h.

ExplainType ParserWrapper::explain_type_ = ExplainType::None

private

Definition at line 133 of file ParserWrapper.h.

Referenced by getExplainType(), isCalciteExplain(), isCalcitePathPermissable(), isIRExplain(), isOtherExplain(), isPlanExplain(), and isSelectExplain().

bool ParserWrapper::is_calcite_ddl_ = false

private

Definition at line 146 of file ParserWrapper.h.

Referenced by isCalciteDdl(), and isCalcitePathPermissable().

bool ParserWrapper::is_copy = false

Definition at line 67 of file ParserWrapper.h.

bool ParserWrapper::is_copy_to = false

Definition at line 68 of file ParserWrapper.h.

bool ParserWrapper::is_ctas = false

Definition at line 65 of file ParserWrapper.h.

bool ParserWrapper::is_ddl = false

Definition at line 61 of file ParserWrapper.h.

bool ParserWrapper::is_itas = false

Definition at line 66 of file ParserWrapper.h.

Referenced by isCalcitePermissableDml().

bool ParserWrapper::is_legacy_ddl_ = false

private

Definition at line 145 of file ParserWrapper.h.

Referenced by isCalcitePathPermissable().

bool ParserWrapper::is_optimize = false

Definition at line 69 of file ParserWrapper.h.

Referenced by isCalcitePathPermissable().

bool ParserWrapper::is_update_dml = false

Definition at line 64 of file ParserWrapper.h.

Referenced by isCalcitePermissableDml().

bool ParserWrapper::is_validate = false

Definition at line 70 of file ParserWrapper.h.

Referenced by isCalcitePathPermissable().

const std::string ParserWrapper::optimize_str = {"optimize"}

staticprivate

Definition at line 142 of file ParserWrapper.h.

const std::string ParserWrapper::optimized_explain_str = {"explain optimized"}

staticprivate

Definition at line 140 of file ParserWrapper.h.

const std::string ParserWrapper::plan_explain_str = {"explain plan"}

staticprivate

Definition at line 141 of file ParserWrapper.h.

QueryType ParserWrapper::query_type_ = QueryType::Unknown

private

Definition at line 134 of file ParserWrapper.h.

Referenced by getQueryType(), and isCalcitePermissableDdl().

const std::vector< std::string > ParserWrapper::update_dml_cmd

staticprivate

Initial value:

= {
    "INSERT",
    "DELETE",
    "UPDATE",
    "UPSERT",
}

Definition at line 137 of file ParserWrapper.h.

Referenced by ParserWrapper().

const std::string ParserWrapper::validate_str = {"validate"}

staticprivate

Definition at line 143 of file ParserWrapper.h.

The documentation for this class was generated from the following files:

/home/jenkins-slave/workspace/core-os-doxygen/Parser/ParserWrapper.h
/home/jenkins-slave/workspace/core-os-doxygen/Parser/ParserWrapper.cpp

Public Types

Public Member Functions

Public Attributes

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation