ParserWrapper Class Reference

#include <ParserWrapper.h>

Public Types
enum	DMLType : int { DMLType::Insert = 0, DMLType::Delete, DMLType::Update, DMLType::NotDML }
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
QueryType	getQueryType () const
bool	isUpdateDelete () 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_validate = false
bool	is_other_explain = false
bool	is_refresh = false

Private Attributes
DMLType	dml_type_ = DMLType::NotDML
QueryType	query_type_ = QueryType::Unknown

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

Member Enumeration Documentation

enum ParserWrapper::DMLType : int

strong

Enumerator
Insert
Delete
Update
NotDML

Definition at line 94 of file ParserWrapper.h.

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

enum ParserWrapper::QueryType

strong

Enumerator
Unknown
Read
Write
SchemaRead
SchemaWrite

Definition at line 96 of file ParserWrapper.h.

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

Constructor & Destructor Documentation

ParserWrapper::ParserWrapper

(

std::string

query_string

)

Definition at line 104 of file ParserWrapper.cpp.

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

                                                   {
  validate_no_leading_comments(query_string);

  is_other_explain = ExplainInfo(query_string).isOtherExplain();

  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|SESSION).*)",
                                        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;
      } else if (ddl == "REFRESH") {
        is_refresh = 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) {
      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 175 of file ParserWrapper.cpp.

{}

Member Function Documentation

DMLType ParserWrapper::getDMLType ( ) const

inline

Definition at line 116 of file ParserWrapper.h.

References dml_type_.

{ return dml_type_; }

QueryType ParserWrapper::getQueryType ( ) const

inline

Definition at line 118 of file ParserWrapper.h.

References query_type_.

{ return query_type_; }

bool ParserWrapper::isUpdateDelete ( ) const

inline

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

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

staticprivate

Initial value:

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

Definition at line 128 of file ParserWrapper.h.

DMLType ParserWrapper::dml_type_ = DMLType::NotDML

private

Definition at line 125 of file ParserWrapper.h.

Referenced by getDMLType(), and isUpdateDelete().

bool ParserWrapper::is_copy = false

Definition at line 110 of file ParserWrapper.h.

bool ParserWrapper::is_copy_to = false

Definition at line 111 of file ParserWrapper.h.

bool ParserWrapper::is_ctas = false

Definition at line 108 of file ParserWrapper.h.

bool ParserWrapper::is_ddl = false

Definition at line 106 of file ParserWrapper.h.

bool ParserWrapper::is_itas = false

Definition at line 109 of file ParserWrapper.h.

bool ParserWrapper::is_other_explain = false

Definition at line 113 of file ParserWrapper.h.

bool ParserWrapper::is_refresh = false

Definition at line 114 of file ParserWrapper.h.

bool ParserWrapper::is_update_dml = false

Definition at line 107 of file ParserWrapper.h.

bool ParserWrapper::is_validate = false

Definition at line 112 of file ParserWrapper.h.

QueryType ParserWrapper::query_type_ = QueryType::Unknown

private

Definition at line 126 of file ParserWrapper.h.

Referenced by getQueryType().

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

staticprivate

Initial value:

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

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