ParserWrapper Class Reference

#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	isDdl () const
std::string	ActualQuery ()

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_validate = false

Private Member Functions
void	initExplainType (std::string query_string)

Private Attributes
std::string	actual_query_
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

Detailed Description

Definition at line 45 of file ParserWrapper.h.

Member Enumeration Documentation

enum ParserWrapper::DMLType : int

strong

Enumerator
Insert
Delete
Update
Upsert
NotDML

Definition at line 48 of file ParserWrapper.h.

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

enum ParserWrapper::ExplainType

strong

Enumerator
None
IR
OptimizedIR
Calcite
ExecutionPlan
Other

Definition at line 50 of file ParserWrapper.h.

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

enum ParserWrapper::QueryType

strong

Enumerator
Unknown
Read
Write
SchemaRead
SchemaWrite

Definition at line 52 of file ParserWrapper.h.

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

Constructor & Destructor Documentation

ParserWrapper::ParserWrapper

(

std::string

query_string

)

Definition at line 76 of file ParserWrapper.cpp.

References update_dml_cmd, and anonymous_namespace{ParserWrapper.cpp}::validate_no_leading_comments().

                                                   {
  validate_no_leading_comments(query_string);

  // init explain_type_ and actual_info_
  initExplainType(query_string);

  query_type_ = QueryType::Read;
  for (std::string ddl : ddl_cmd) {
    if (boost::istarts_with(query_string, ddl)) {
      query_type_ = QueryType::SchemaWrite;
      is_ddl_ = true;

      if (ddl == "CREATE") {
        boost::regex ctas_regex{
            R"(CREATE\s+(TEMPORARY\s+|\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 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;

      } else if (ddl == "KILL") {
        query_type_ = QueryType::Unknown;
      } else if (ddl == "VALIDATE") {
        query_type_ = QueryType::Unknown;
        // needs to execute in a different context from other DDL
        is_validate = true;
      } else if (ddl == "ALTER") {
        boost::regex alter_system_regex{R"(ALTER\s+(SYSTEM).*)",
                                        boost::regex::extended | boost::regex::icase};
        if (boost::regex_match(query_string, alter_system_regex)) {
          query_type_ = QueryType::Unknown;
        }
      } else if (ddl == "ARCHIVE" || ddl == "DUMP") {
        query_type_ = QueryType::SchemaRead;
      }
      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;
    }
  }
}

Here is the call graph for this function:

ParserWrapper::~ParserWrapper ( )

virtual

Definition at line 147 of file ParserWrapper.cpp.

{}

Member Function Documentation

std::string ParserWrapper::ActualQuery ( )

inline

Definition at line 130 of file ParserWrapper.h.

References actual_query_.

{ return actual_query_; }

DMLType ParserWrapper::getDMLType ( ) const

inline

Definition at line 72 of file ParserWrapper.h.

References dml_type_.

Referenced by isCalcitePermissableDml().

{ return dml_type_; }

Here is the caller graph for this function:

ExplainInfo ParserWrapper::getExplainInfo

(

)

const

Definition at line 191 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 76 of file ParserWrapper.h.

References explain_type_.

{ return explain_type_; }

QueryType ParserWrapper::getQueryType ( ) const

inline

Definition at line 78 of file ParserWrapper.h.

References query_type_.

{ return query_type_; }

void ParserWrapper::initExplainType ( std::string  query_string )

private

Definition at line 149 of file ParserWrapper.cpp.

References anonymous_namespace{ParserWrapper.cpp}::calcite_explain_str, anonymous_namespace{ParserWrapper.cpp}::explain_str, logger::IR, None, anonymous_namespace{ParserWrapper.cpp}::optimized_explain_str, and anonymous_namespace{ParserWrapper.cpp}::plan_explain_str.

                                                          {
  // sets explain_type_ and caches a trimmed actual_query_
  explain_type_ = ParserWrapper::ExplainType::None;

  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.isDdl() || inner.is_update_dml) {
      explain_type_ = ExplainType::Other;
    } else {
      explain_type_ = ExplainType::Calcite;
    }

  } else 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.isDdl() || inner.is_update_dml) {
      explain_type_ = ExplainType::Other;
    } else {
      explain_type_ = ExplainType::OptimizedIR;
    }

  } else 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.isDdl() || inner.is_update_dml) {
      explain_type_ = ExplainType::Other;
    } else {
      explain_type_ = ExplainType::ExecutionPlan;
    }

  } else 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.isDdl() || inner.is_update_dml) {
      explain_type_ = ExplainType::Other;
    } else {
      explain_type_ = ExplainType::IR;
    }
  }
}

bool ParserWrapper::isCalciteExplain ( ) const

inline

Definition at line 84 of file ParserWrapper.h.

References Calcite, and explain_type_.

{ return explain_type_ == ExplainType::Calcite; }

bool ParserWrapper::isCalcitePathPermissable ( bool  read_only_mode = false )

inline

Definition at line 98 of file ParserWrapper.h.

References explain_type_, is_ddl_, is_validate, isCalcitePermissableDdl(), isCalcitePermissableDml(), and Other.

                                                             {
    if (is_ddl_) {
      return isCalcitePermissableDdl(read_only_mode);
    }
    return (!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 120 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 108 of file ParserWrapper.h.

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

Referenced by isCalcitePathPermissable().

                                                            {
    if (is_itas || is_ctas) {
      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 ||
            (getDMLType() == ParserWrapper::DMLType::Insert));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool ParserWrapper::isDdl ( ) const

inline

Definition at line 128 of file ParserWrapper.h.

References is_ddl_.

{ return is_ddl_; }

bool ParserWrapper::isIRExplain ( ) const

inline

Definition at line 94 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 106 of file ParserWrapper.h.

References explain_type_, and Other.

{ return explain_type_ == ExplainType::Other; }

bool ParserWrapper::isPlanExplain ( ) const

inline

Definition at line 86 of file ParserWrapper.h.

References ExecutionPlan, and explain_type_.

{ return explain_type_ == ExplainType::ExecutionPlan; }

bool ParserWrapper::isSelectExplain ( ) const

inline

Definition at line 88 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 80 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_

private

Definition at line 134 of file ParserWrapper.h.

Referenced by ActualQuery().

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

staticprivate

Initial value:

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

Definition at line 140 of file ParserWrapper.h.

DMLType ParserWrapper::dml_type_ = DMLType::NotDML

private

Definition at line 136 of file ParserWrapper.h.

Referenced by getDMLType(), and isUpdateDelete().

ExplainType ParserWrapper::explain_type_ = ExplainType::None

private

Definition at line 137 of file ParserWrapper.h.

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

bool ParserWrapper::is_calcite_ddl_ = false

private

Definition at line 144 of file ParserWrapper.h.

bool ParserWrapper::is_copy = false

Definition at line 68 of file ParserWrapper.h.

bool ParserWrapper::is_copy_to = false

Definition at line 69 of file ParserWrapper.h.

bool ParserWrapper::is_ctas = false

Definition at line 66 of file ParserWrapper.h.

Referenced by isCalcitePermissableDml().

bool ParserWrapper::is_ddl_ = false

Definition at line 62 of file ParserWrapper.h.

Referenced by isCalcitePathPermissable(), and isDdl().

bool ParserWrapper::is_itas = false

Definition at line 67 of file ParserWrapper.h.

Referenced by isCalcitePermissableDml().

bool ParserWrapper::is_legacy_ddl_ = false

private

Definition at line 143 of file ParserWrapper.h.

bool ParserWrapper::is_update_dml = false

Definition at line 65 of file ParserWrapper.h.

Referenced by isCalcitePermissableDml().

bool ParserWrapper::is_validate = false

Definition at line 70 of file ParserWrapper.h.

Referenced by isCalcitePathPermissable().

QueryType ParserWrapper::query_type_ = QueryType::Unknown

private

Definition at line 138 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 141 of file ParserWrapper.h.

Referenced by ParserWrapper().

---

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