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

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

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

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

(

std::string

query_string

)

Definition at line 61 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;
        }
      }

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

virtual

Definition at line 198 of file ParserWrapper.cpp.

{}

Member Function Documentation

DMLType ParserWrapper::getDMLType ( ) const

inline

Definition at line 73 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 200 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_.

{ return explain_type_; }

QueryType ParserWrapper::getQueryType ( ) const

inline

Definition at line 79 of file ParserWrapper.h.

References query_type_.

{ return query_type_; }

bool ParserWrapper::isCalciteDdl ( ) const

inline

Definition at line 111 of file ParserWrapper.h.

References is_calcite_ddl_.

{ return is_calcite_ddl_; }

bool ParserWrapper::isCalciteExplain ( ) const

inline

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

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

                                                             {
    return is_calcite_ddl_ || (!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::isCalcitePermissableDml ( bool  read_only_mode )

inline

Definition at line 103 of file ParserWrapper.h.

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

Referenced by isCalcitePathPermissable().

                                                    {
    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 91 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 101 of file ParserWrapper.h.

References explain_type_, and Other.

{ return explain_type_ == ExplainType::Other; }

bool ParserWrapper::isPlanExplain ( ) const

inline

Definition at line 83 of file ParserWrapper.h.

References ExecutionPlan, and explain_type_.

{ return explain_type_ == ExplainType::ExecutionPlan; }

bool ParserWrapper::isSelectExplain ( ) const

inline

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

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 121 of file ParserWrapper.h.

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

staticprivate

Initial value:

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

Definition at line 118 of file ParserWrapper.h.

DMLType ParserWrapper::dml_type_ = DMLType::NotDML

private

Definition at line 114 of file ParserWrapper.h.

Referenced by getDMLType().

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

staticprivate

Definition at line 120 of file ParserWrapper.h.

ExplainType ParserWrapper::explain_type_ = ExplainType::None

private

Definition at line 115 of file ParserWrapper.h.

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

bool ParserWrapper::is_calcite_ddl_ = false

private

Definition at line 128 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.

bool ParserWrapper::is_legacy_ddl_ = false

private

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

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

staticprivate

Definition at line 122 of file ParserWrapper.h.

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

staticprivate

Definition at line 123 of file ParserWrapper.h.

QueryType ParserWrapper::query_type_ = QueryType::Unknown

private

Definition at line 116 of file ParserWrapper.h.

Referenced by getQueryType().

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

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