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

DMLType

enum ParserWrapper::DMLType : int

strong

Enumerator
Insert
Delete
Update
Upsert
NotDML

Definition at line 47 of file ParserWrapper.h.

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

ExplainType

enum ParserWrapper::ExplainType

strong

Enumerator
None
IR
OptimizedIR
Calcite
ExecutionPlan
Other

Definition at line 49 of file ParserWrapper.h.

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

QueryType

enum ParserWrapper::QueryType

strong

Enumerator
Unknown
Read
Write
SchemaRead
SchemaWrite

Definition at line 51 of file ParserWrapper.h.

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

Constructor & Destructor Documentation

ParserWrapper()

ParserWrapper::ParserWrapper

(

std::string

query_string

)

Definition at line 62 of file ParserWrapper.cpp.

References g_enable_fsi, 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.*AS.*SELECT.*)",
                                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;
        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 == "KILL") {
        query_type_ = QueryType::Unknown;
        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 insert_regex{R"(INSERT\s+INTO.*VALUES\s*\(.*)",
                              boost::regex::extended | boost::regex::icase};
    if (!boost::regex_match(query_string, insert_regex)) {
      boost::regex itas_regex{R"(INSERT\s+INTO.*SELECT.*)",
                              boost::regex::extended | boost::regex::icase};
      if (boost::regex_match(query_string, itas_regex)) {
        is_itas = true;
      }
    }
  }
}

~ParserWrapper()

ParserWrapper::~ParserWrapper ( )

virtual

Definition at line 203 of file ParserWrapper.cpp.

{}

Member Function Documentation

getDMLType()

DMLType ParserWrapper::getDMLType ( ) const

inline

Definition at line 73 of file ParserWrapper.h.

{ return dml_type_; }

getExplainInfo()

ExplainInfo ParserWrapper::getExplainInfo

(

)

const

Definition at line 205 of file ParserWrapper.cpp.

References logger::IR.

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

getExplainType()

ExplainType ParserWrapper::getExplainType ( ) const

inline

Definition at line 77 of file ParserWrapper.h.

{ return explain_type_; }

getQueryType()

QueryType ParserWrapper::getQueryType ( ) const

inline

Definition at line 79 of file ParserWrapper.h.

{ return query_type_; }

isCalciteDdl()

bool ParserWrapper::isCalciteDdl ( ) const

inline

Definition at line 111 of file ParserWrapper.h.

{ return is_calcite_ddl_; }

isCalciteExplain()

bool ParserWrapper::isCalciteExplain ( ) const

inline

Definition at line 81 of file ParserWrapper.h.

{ return explain_type_ == ExplainType::Calcite; }

isCalcitePathPermissable()

bool ParserWrapper::isCalcitePathPermissable ( bool  read_only_mode = false )

inline

Definition at line 95 of file ParserWrapper.h.

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

isCalcitePermissableDml()

bool ParserWrapper::isCalcitePermissableDml ( bool  read_only_mode )

inline

Definition at line 103 of file ParserWrapper.h.

References Delete, and Update.

                                                    {
    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);
  }

isIRExplain()

bool ParserWrapper::isIRExplain ( ) const

inline

Definition at line 91 of file ParserWrapper.h.

References logger::IR.

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

isOtherExplain()

bool ParserWrapper::isOtherExplain ( ) const

inline

Definition at line 101 of file ParserWrapper.h.

{ return explain_type_ == ExplainType::Other; }

isPlanExplain()

bool ParserWrapper::isPlanExplain ( ) const

inline

Definition at line 83 of file ParserWrapper.h.

{ return explain_type_ == ExplainType::ExecutionPlan; }

isSelectExplain()

bool ParserWrapper::isSelectExplain ( ) const

inline

Definition at line 85 of file ParserWrapper.h.

References logger::IR.

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:

process()

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

Member Data Documentation

actual_query

std::string ParserWrapper::actual_query

Definition at line 71 of file ParserWrapper.h.

calcite_explain_str

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

staticprivate

Definition at line 121 of file ParserWrapper.h.

ddl_cmd

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

staticprivate

Initial value:

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

Definition at line 118 of file ParserWrapper.h.

dml_type_

DMLType ParserWrapper::dml_type_ = DMLType::NotDML

private

Definition at line 114 of file ParserWrapper.h.

explain_str

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

staticprivate

Definition at line 120 of file ParserWrapper.h.

explain_type_

ExplainType ParserWrapper::explain_type_ = ExplainType::None

private

Definition at line 115 of file ParserWrapper.h.

is_calcite_ddl_

bool ParserWrapper::is_calcite_ddl_ = false

private

Definition at line 128 of file ParserWrapper.h.

is_copy

bool ParserWrapper::is_copy = false

Definition at line 67 of file ParserWrapper.h.

is_copy_to

bool ParserWrapper::is_copy_to = false

Definition at line 68 of file ParserWrapper.h.

is_ctas

bool ParserWrapper::is_ctas = false

Definition at line 65 of file ParserWrapper.h.

is_ddl

bool ParserWrapper::is_ddl = false

Definition at line 61 of file ParserWrapper.h.

is_itas

bool ParserWrapper::is_itas = false

Definition at line 66 of file ParserWrapper.h.

is_legacy_ddl_

bool ParserWrapper::is_legacy_ddl_ = false

private

Definition at line 127 of file ParserWrapper.h.

is_optimize

bool ParserWrapper::is_optimize = false

Definition at line 69 of file ParserWrapper.h.

is_update_dml

bool ParserWrapper::is_update_dml = false

Definition at line 64 of file ParserWrapper.h.

is_validate

bool ParserWrapper::is_validate = false

Definition at line 70 of file ParserWrapper.h.

optimize_str

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

staticprivate

Definition at line 124 of file ParserWrapper.h.

optimized_explain_str

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

staticprivate

Definition at line 122 of file ParserWrapper.h.

plan_explain_str

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

staticprivate

Definition at line 123 of file ParserWrapper.h.

query_type_

QueryType ParserWrapper::query_type_ = QueryType::Unknown

private

Definition at line 116 of file ParserWrapper.h.

update_dml_cmd

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

staticprivate

Initial value:

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

Definition at line 119 of file ParserWrapper.h.

Referenced by ParserWrapper().

validate_str

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

staticprivate

Definition at line 125 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