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

Member Enumeration Documentation

enum ParserWrapper::DMLType : int

strong

Enumerator
Insert
Delete
Update
NotDML

Definition at line 72 of file ParserWrapper.h.

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

enum ParserWrapper::QueryType

strong

Enumerator
Unknown
Read
Write
SchemaRead
SchemaWrite

Definition at line 74 of file ParserWrapper.h.

74 { 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.

175 {}

Member Function Documentation

DMLType ParserWrapper::getDMLType ( ) const

inline

Definition at line 94 of file ParserWrapper.h.

References dml_type_.

94 { return dml_type_; }

ParserWrapper::dml_type_

DMLType dml_type_

Definition: ParserWrapper.h:103

QueryType ParserWrapper::getQueryType ( ) const

inline

Definition at line 96 of file ParserWrapper.h.

References query_type_.

96 { return query_type_; }

ParserWrapper::query_type_

QueryType query_type_

Definition: ParserWrapper.h:104

bool ParserWrapper::isUpdateDelete ( ) const

inline

Definition at line 98 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",
                                                         "GRANT",
                                                         "KILL",
                                                         "OPTIMIZE",
                                                         "REFRESH",
                                                         "RENAME",
                                                         "RESTORE",
                                                         "REVOKE",
                                                         "SHOW",
                                                         "TRUNCATE",
                                                         "REASSIGN",
                                                         "VALIDATE",
                                                         "CLEAR"}

Definition at line 106 of file ParserWrapper.h.

DMLType ParserWrapper::dml_type_ = DMLType::NotDML

private

Definition at line 103 of file ParserWrapper.h.

Referenced by getDMLType(), and isUpdateDelete().

bool ParserWrapper::is_copy = false

Definition at line 88 of file ParserWrapper.h.

bool ParserWrapper::is_copy_to = false

Definition at line 89 of file ParserWrapper.h.

bool ParserWrapper::is_ctas = false

Definition at line 86 of file ParserWrapper.h.

bool ParserWrapper::is_ddl = false

Definition at line 84 of file ParserWrapper.h.

bool ParserWrapper::is_itas = false

Definition at line 87 of file ParserWrapper.h.

bool ParserWrapper::is_other_explain = false

Definition at line 91 of file ParserWrapper.h.

bool ParserWrapper::is_refresh = false

Definition at line 92 of file ParserWrapper.h.

bool ParserWrapper::is_update_dml = false

Definition at line 85 of file ParserWrapper.h.

bool ParserWrapper::is_validate = false

Definition at line 90 of file ParserWrapper.h.

QueryType ParserWrapper::query_type_ = QueryType::Unknown

private

Definition at line 104 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 107 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

Public Types

Public Member Functions

Public Attributes

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation