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::Other }

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
ExplainType	getExplainType () const
bool	isCalciteExplain () const
bool	isSelectExplain () const
bool	isIRExplain () const
bool	isCalcitePathPermissable (bool read_only_mode=false)
bool	isOtherExplain () const
bool	isCalcitePermissableDml (bool read_only_mode)

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

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	optimize_str = {"optimize"}
static const std::string	validate_str = {"validate"}

Detailed Description

Definition at line 51 of file ParserWrapper.h.

Member Enumeration Documentation

enum ParserWrapper::DMLType : int

strong

Enumerator
Insert
Delete
Update
Upsert
NotDML

Definition at line 54 of file ParserWrapper.h.

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

enum ParserWrapper::ExplainType

strong

Enumerator
None
IR
OptimizedIR
Calcite
Other

Definition at line 56 of file ParserWrapper.h.

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

Constructor & Destructor Documentation

ParserWrapper::ParserWrapper

(

std::string

query_string

)

Definition at line 57 of file ParserWrapper.cpp.

References logger::IR, and update_dml_cmd.

                                                   {
  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, 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)) {
    is_optimize = true;
    return;
  }

  if (boost::istarts_with(query_string, validate_str)) {
    is_validate = true;
    return;
  }

  for (std::string ddl : ddl_cmd) {
    is_ddl = boost::istarts_with(query_string, ddl);
    if (is_ddl) {
      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)) {
          is_copy_to = true;
        }
      }
      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) {
      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 147 of file ParserWrapper.cpp.

{}

Member Function Documentation

DMLType ParserWrapper::getDMLType ( ) const

inline

Definition at line 76 of file ParserWrapper.h.

References dml_type_.

Referenced by isCalcitePermissableDml().

{ return dml_type_; }

Here is the caller graph for this function:

ExplainType ParserWrapper::getExplainType ( ) const

inline

Definition at line 78 of file ParserWrapper.h.

References explain_type_.

{ return explain_type_; }

bool ParserWrapper::isCalciteExplain ( ) const

inline

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

References explain_type_, is_ddl, is_optimize, is_validate, isCalcitePermissableDml(), and Other.

                                                             {
    return (!is_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 99 of file ParserWrapper.h.

References Delete, getDMLType(), is_update_dml, OnlyDeletes, OnlyUpdates, Unsupported, Update, UpdatesAndDeletes, and yield_dml_path_selector().

Referenced by isCalcitePathPermissable().

                                                    {
    if (read_only_mode) {
      return !is_update_dml;  // If we're read-only, no DML is permissable
    }

    // TODO: A good place for if-constexpr
    switch (yield_dml_path_selector()) {
      case CalciteDMLPathSelection::OnlyUpdates:
        return !is_update_dml || (getDMLType() == ParserWrapper::DMLType::Update);
      case CalciteDMLPathSelection::OnlyDeletes:
        return !is_update_dml || (getDMLType() == ParserWrapper::DMLType::Delete);
      case CalciteDMLPathSelection::UpdatesAndDeletes:
        return !is_update_dml || (getDMLType() == ParserWrapper::DMLType::Delete) ||
               (getDMLType() == ParserWrapper::DMLType::Update);
      case CalciteDMLPathSelection::Unsupported:
      default:
        return false;
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool ParserWrapper::isIRExplain ( ) const

inline

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

References explain_type_, and Other.

{ return explain_type_ == ExplainType::Other; }

bool ParserWrapper::isSelectExplain ( ) const

inline

Definition at line 82 of file ParserWrapper.h.

References Calcite, explain_type_, IR, and OptimizedIR.

Referenced by MapDHandler::parse_to_ra().

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

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

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

staticprivate

Definition at line 126 of file ParserWrapper.h.

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

staticprivate

Initial value:

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

Definition at line 123 of file ParserWrapper.h.

DMLType ParserWrapper::dml_type_ = DMLType::NotDML

private

Definition at line 120 of file ParserWrapper.h.

Referenced by getDMLType().

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

staticprivate

Definition at line 125 of file ParserWrapper.h.

ExplainType ParserWrapper::explain_type_ = ExplainType::None

private

Definition at line 121 of file ParserWrapper.h.

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

bool ParserWrapper::is_copy = false

Definition at line 70 of file ParserWrapper.h.

bool ParserWrapper::is_copy_to = false

Definition at line 71 of file ParserWrapper.h.

bool ParserWrapper::is_ctas = false

Definition at line 68 of file ParserWrapper.h.

bool ParserWrapper::is_ddl = false

Definition at line 66 of file ParserWrapper.h.

Referenced by isCalcitePathPermissable().

bool ParserWrapper::is_itas = false

Definition at line 69 of file ParserWrapper.h.

bool ParserWrapper::is_optimize = false

Definition at line 72 of file ParserWrapper.h.

Referenced by isCalcitePathPermissable().

bool ParserWrapper::is_update_dml = false

Definition at line 67 of file ParserWrapper.h.

Referenced by isCalcitePermissableDml().

bool ParserWrapper::is_validate = false

Definition at line 73 of file ParserWrapper.h.

Referenced by isCalcitePathPermissable().

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

staticprivate

Definition at line 128 of file ParserWrapper.h.

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

staticprivate

Definition at line 127 of file ParserWrapper.h.

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

staticprivate

Initial value:

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

Definition at line 124 of file ParserWrapper.h.

Referenced by ParserWrapper().

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

staticprivate

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