#include <SerializeToSql.h>

Inheritance diagram for ScalarExprToSql:

Collaboration diagram for ScalarExprToSql:

Public Member Functions
	ScalarExprToSql (const RelAlgExecutionUnit *ra_exe_unit)

std::string	visitVar (const Analyzer::Var *) const override

std::string	visitColumnVar (const Analyzer::ColumnVar *col_var) const override

std::string	visitConstant (const Analyzer::Constant *constant) const override

std::string	visitUOper (const Analyzer::UOper *uoper) const override

std::string	visitBinOper (const Analyzer::BinOper *bin_oper) const override

std::string	visitInValues (const Analyzer::InValues *in_values) const override

std::string	visitLikeExpr (const Analyzer::LikeExpr *like) const override

std::string	visitCaseExpr (const Analyzer::CaseExpr *case_) const override

std::string	visitFunctionOper (const Analyzer::FunctionOper *func_oper) const override

std::string	visitWindowFunction (const Analyzer::WindowFunction *window_func) const override

std::string	visitAggExpr (const Analyzer::AggExpr *agg) const override

template<typename List >
std::vector< std::string >	visitList (const List &expressions) const

Public Member Functions inherited from ScalarExprVisitor< std::string >
std::string	visit (const Analyzer::Expr *expr) const

Protected Member Functions
std::string	aggregateResult (const std::string &aggregate, const std::string &next_result) const override

std::string	defaultResult () const override

Protected Member Functions inherited from ScalarExprVisitor< std::string >
virtual std::string	visitColumnVarTuple (const Analyzer::ExpressionTuple *) const

virtual std::string	visitGeoExpr (const Analyzer::GeoExpr *geo_expr) const

virtual std::string	visitInIntegerSet (const Analyzer::InIntegerSet *in_integer_set) const

virtual std::string	visitCharLength (const Analyzer::CharLengthExpr *char_length) const

virtual std::string	visitKeyForString (const Analyzer::KeyForStringExpr *key_for_string) const

virtual std::string	visitSampleRatio (const Analyzer::SampleRatioExpr *sample_ratio) const

virtual std::string	visitStringOper (const Analyzer::StringOper *string_oper) const

virtual std::string	visitCardinality (const Analyzer::CardinalityExpr *cardinality) const

virtual std::string	visitRegexpExpr (const Analyzer::RegexpExpr *regexp) const

virtual std::string	visitWidthBucket (const Analyzer::WidthBucketExpr *width_bucket_expr) const

virtual std::string	visitMLPredict (const Analyzer::MLPredictExpr *ml_predict_expr) const

virtual std::string	visitPCAProject (const Analyzer::PCAProjectExpr *pca_project_expr) const

virtual std::string	visitDatetruncExpr (const Analyzer::DatetruncExpr *datetrunc) const

virtual std::string	visitExtractExpr (const Analyzer::ExtractExpr *extract) const

virtual std::string	visitFunctionOperWithCustomTypeHandling (const Analyzer::FunctionOperWithCustomTypeHandling *func_oper) const

virtual std::string	visitArrayOper (Analyzer::ArrayExpr const *array_expr) const

virtual std::string	visitGeoUOper (const Analyzer::GeoUOper *geo_expr) const

virtual std::string	visitGeoBinOper (const Analyzer::GeoBinOper *geo_expr) const

virtual std::string	visitDatediffExpr (const Analyzer::DatediffExpr *datediff) const

virtual std::string	visitDateaddExpr (const Analyzer::DateaddExpr *dateadd) const

virtual std::string	visitLikelihood (const Analyzer::LikelihoodExpr *likelihood) const

virtual std::string	visitOffsetInFragment (const Analyzer::OffsetInFragment *) const

virtual std::string	visitRangeJoinOper (const Analyzer::RangeOper *range_oper) const

virtual void	visitBegin () const

Static Private Member Functions
static std::string	binOpTypeToString (const SQLOps op_type)

Private Attributes
const RelAlgExecutionUnit *	ra_exe_unit_

Detailed Description

Definition at line 23 of file SerializeToSql.h.

Constructor & Destructor Documentation

ScalarExprToSql::ScalarExprToSql ( const RelAlgExecutionUnit * ra_exe_unit )

Definition at line 20 of file SerializeToSql.cpp.

21 : ra_exe_unit_(ra_exe_unit) {}

ScalarExprToSql::ra_exe_unit_

const RelAlgExecutionUnit * ra_exe_unit_

Definition: SerializeToSql.h:66

Member Function Documentation

std::string ScalarExprToSql::aggregateResult	(	const std::string &	aggregate,
		const std::string &	next_result
	)		const

inlineoverrideprotectedvirtual

Reimplemented from ScalarExprVisitor< std::string >.

Definition at line 54 of file SerializeToSql.h.

                                                                            {
     throw std::runtime_error("Expression not supported yet");
   }

std::string ScalarExprToSql::binOpTypeToString ( const SQLOps op_type )

staticprivate

Definition at line 186 of file SerializeToSql.cpp.

References logger::FATAL, kAND, kARRAY_AT, kBBOX_INTERSECT, kDIVIDE, kEQ, kGE, kGT, kLE, kLT, kMINUS, kMODULO, kMULTIPLY, kNE, kOR, kPLUS, and LOG.

Referenced by visitBinOper().

                                                                  {
   switch (op_type) {
     case kEQ:
       return "=";
     case kNE:
       return "<>";
     case kLT:
       return "<";
     case kLE:
       return "<=";
     case kGT:
       return ">";
     case kGE:
       return ">=";
     case kAND:
       return "AND";
     case kOR:
       return "OR";
     case kMINUS:
       return "-";
     case kPLUS:
       return "+";
     case kMULTIPLY:
       return "*";
     case kDIVIDE:
       return "/";
     case kMODULO:
       return "%";
     case kARRAY_AT:
       return "[]";
     case kBBOX_INTERSECT:
       return "BBOX_INTERSECT";
     default:
       LOG(FATAL) << "Invalid operator type: " << op_type;
       return "";
   }
 }

Here is the caller graph for this function:

std::string ScalarExprToSql::defaultResult ( ) const

inlineoverrideprotectedvirtual

Reimplemented from ScalarExprVisitor< std::string >.

Definition at line 59 of file SerializeToSql.h.

                                            {
     throw std::runtime_error("Expression not supported yet");
   }

std::string ScalarExprToSql::visitAggExpr ( const Analyzer::AggExpr * agg ) const

overridevirtual

Reimplemented from ScalarExprVisitor< std::string >.

Definition at line 182 of file SerializeToSql.cpp.

References anonymous_namespace{SerializeToSql.cpp}::agg_to_string(), and ra_exe_unit_.

                                                                         {
   return agg_to_string(agg, ra_exe_unit_);
 }

Here is the call graph for this function:

std::string ScalarExprToSql::visitBinOper ( const Analyzer::BinOper * bin_oper ) const

overridevirtual

Reimplemented from ScalarExprVisitor< std::string >.

Definition at line 84 of file SerializeToSql.cpp.

References binOpTypeToString(), Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_optype(), Analyzer::BinOper::get_right_operand(), and ScalarExprVisitor< std::string >::visit().

                                                                              {
   return visit(bin_oper->get_left_operand()) + " " +
          binOpTypeToString(bin_oper->get_optype()) + " " +
          visit(bin_oper->get_right_operand());
 }

Here is the call graph for this function:

std::string ScalarExprToSql::visitCaseExpr ( const Analyzer::CaseExpr * case_ ) const

overridevirtual

Reimplemented from ScalarExprVisitor< std::string >.

Definition at line 107 of file SerializeToSql.cpp.

References Analyzer::CaseExpr::get_else_expr(), Analyzer::CaseExpr::get_expr_pair_list(), and ScalarExprVisitor< std::string >::visit().

                                                                             {
   std::string case_str = "CASE ";
   const auto& expr_pair_list = case_->get_expr_pair_list();
   for (const auto& expr_pair : expr_pair_list) {
     const auto when = "WHEN " + visit(expr_pair.first.get());
     const auto then = " THEN " + visit(expr_pair.second.get());
     case_str += when + then;
   }
   return case_str + " ELSE " + visit(case_->get_else_expr()) + " END";
 }

Here is the call graph for this function:

std::string ScalarExprToSql::visitColumnVar ( const Analyzer::ColumnVar * col_var ) const

overridevirtual

Reimplemented from ScalarExprVisitor< std::string >.

Definition at line 29 of file SerializeToSql.cpp.

References Catalog_Namespace::SysCatalog::getCatalog(), Analyzer::ColumnVar::getColumnKey(), Catalog_Namespace::SysCatalog::instance(), serialize_column_ref(), and serialize_table_ref().

                                                                                 {
   const auto& column_key = col_var->getColumnKey();
   const auto catalog =
       Catalog_Namespace::SysCatalog::instance().getCatalog(column_key.db_id);
   return serialize_table_ref(column_key.table_id, catalog.get()) + "." +
          serialize_column_ref(column_key.table_id, column_key.column_id, catalog.get());
 }

Here is the call graph for this function:

std::string ScalarExprToSql::visitConstant ( const Analyzer::Constant * constant ) const

overridevirtual

Reimplemented from ScalarExprVisitor< std::string >.

Definition at line 37 of file SerializeToSql.cpp.

References DatumToString(), Analyzer::Constant::get_constval(), Analyzer::Constant::get_is_null(), Analyzer::Expr::get_type_info(), and run_benchmark_import::result.

                                                                                {
   if (constant->get_is_null()) {
     return "NULL";
   }
   const auto& constant_ti = constant->get_type_info();
   const auto result = DatumToString(constant->get_constval(), constant_ti);
   if (constant_ti.is_string()) {
     return "'" + result + "'";
   } else {
     return result;
   }
 }

Here is the call graph for this function:

std::string ScalarExprToSql::visitFunctionOper ( const Analyzer::FunctionOper * func_oper ) const

overridevirtual

Reimplemented from ScalarExprVisitor< std::string >.

Definition at line 132 of file SerializeToSql.cpp.

References CHECK_EQ, Analyzer::FunctionOper::getArg(), Analyzer::FunctionOper::getArity(), Analyzer::FunctionOper::getName(), join(), run_benchmark_import::result, and ScalarExprVisitor< std::string >::visit().

                                                  {
   std::string result = func_oper->getName();
   if (result == "||") {
     CHECK_EQ(func_oper->getArity(), size_t(2));
     return visit(func_oper->getArg(0)) + "||" + visit(func_oper->getArg(1));
   }
   if (result == "SUBSTRING") {
     result = "SUBSTR";
   }
   std::vector<std::string> arg_strs;
   for (size_t i = 0; i < func_oper->getArity(); ++i) {
     arg_strs.push_back(visit(func_oper->getArg(i)));
   }
   return result + "(" + boost::algorithm::join(arg_strs, ",") + ")";
 }

Here is the call graph for this function:

std::string ScalarExprToSql::visitInValues ( const Analyzer::InValues * in_values ) const

overridevirtual

Reimplemented from ScalarExprVisitor< std::string >.

Definition at line 90 of file SerializeToSql.cpp.

References Analyzer::InValues::get_arg(), Analyzer::InValues::get_value_list(), join(), ScalarExprVisitor< std::string >::visit(), and visitList().

                                                                                 {
   const auto needle = visit(in_values->get_arg());
   const auto haystack = visitList(in_values->get_value_list());
   return needle + " IN (" + boost::algorithm::join(haystack, ", ") + ")";
 }

Here is the call graph for this function:

std::string ScalarExprToSql::visitLikeExpr ( const Analyzer::LikeExpr * like ) const

overridevirtual

Reimplemented from ScalarExprVisitor< std::string >.

Definition at line 96 of file SerializeToSql.cpp.

References Analyzer::LikeExpr::get_arg(), Analyzer::LikeExpr::get_escape_expr(), Analyzer::LikeExpr::get_like_expr(), run_benchmark_import::result, and ScalarExprVisitor< std::string >::visit().

                                                                            {
   const auto str = visit(like->get_arg());
   const auto pattern = visit(like->get_like_expr());
   const auto result = str + " LIKE " + pattern;
   if (like->get_escape_expr()) {
     const auto escape = visit(like->get_escape_expr());
     return result + " ESCAPE " + escape;
   }
   return result;
 }

Here is the call graph for this function:

template<typename List >

std::vector< std::string > ScalarExprToSql::visitList ( const List & expressions ) const

Definition at line 225 of file SerializeToSql.cpp.

References run_benchmark_import::result, and ScalarExprVisitor< std::string >::visit().

Referenced by anonymous_namespace{SerializeToSql.cpp}::group_by_to_string(), anonymous_namespace{SerializeToSql.cpp}::join_condition_to_string(), visitInValues(), visitWindowFunction(), and anonymous_namespace{SerializeToSql.cpp}::where_to_string().

                                                                              {
   std::vector<std::string> result;
   for (const auto& expression : expressions) {
     result.push_back(visit(expression.get()));
   }
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string ScalarExprToSql::visitUOper ( const Analyzer::UOper * uoper ) const

overridevirtual

Reimplemented from ScalarExprVisitor< std::string >.

Definition at line 50 of file SerializeToSql.cpp.

References Analyzer::UOper::get_operand(), Analyzer::UOper::get_optype(), Analyzer::Expr::get_type_info(), SQLTypeInfo::get_type_name(), is_supported_type_for_extern_execution(), kCAST, kISNULL, kNOT, kUMINUS, to_string(), and ScalarExprVisitor< std::string >::visit().

                                                                       {
   const auto operand = uoper->get_operand();
   const auto operand_str = visit(operand);
   const auto optype = uoper->get_optype();
   switch (optype) {
     case kNOT: {
       return "NOT (" + operand_str + ")";
     }
     case kUMINUS: {
       return "-" + operand_str;
     }
     case kISNULL: {
       return operand_str + " IS NULL";
     }
     case kCAST: {
       const auto& operand_ti = operand->get_type_info();
       const auto& target_ti = uoper->get_type_info();
       if (!is_supported_type_for_extern_execution(target_ti)) {
         throw std::runtime_error("Type not supported yet for extern execution: " +
                                  target_ti.get_type_name());
       }
       if ((operand_ti.get_type() == target_ti.get_type()) ||
           ((operand_ti.is_string() && target_ti.is_string()))) {
         return operand_str;
       }
       return "CAST(" + operand_str + " AS " + target_ti.get_type_name() + ")";
     }
     default: {
       throw std::runtime_error("Unary operator type: " + std::to_string(optype) +
                                " not supported");
     }
   }
 }

Here is the call graph for this function:

std::string ScalarExprToSql::visitVar ( const Analyzer::Var * var ) const

overridevirtual

Reimplemented from ScalarExprVisitor< std::string >.

Definition at line 23 of file SerializeToSql.cpp.

References Analyzer::Var::get_varno(), RelAlgExecutionUnit::groupby_exprs, ra_exe_unit_, and ScalarExprVisitor< std::string >::visit().

                                                                 {
   auto it = ra_exe_unit_->groupby_exprs.begin();
   std::advance(it, var->get_varno() - 1);
   return visit(it->get());
 }

Here is the call graph for this function:

std::string ScalarExprToSql::visitWindowFunction ( const Analyzer::WindowFunction * window_func ) const

overridevirtual

Reimplemented from ScalarExprVisitor< std::string >.

Definition at line 149 of file SerializeToSql.cpp.

References CHECK_EQ, Analyzer::WindowFunction::getArgs(), Analyzer::WindowFunction::getCollation(), Analyzer::WindowFunction::getKind(), Analyzer::WindowFunction::getOrderKeys(), Analyzer::WindowFunction::getPartitionKeys(), join(), run_benchmark_import::result, toString(), ScalarExprVisitor< std::string >::visit(), and visitList().

                                                      {
   std::string result = ::toString(window_func->getKind());
   {
     const auto arg_strs = visitList(window_func->getArgs());
     result += "(" + boost::algorithm::join(arg_strs, ",") + ")";
   }
   result += " OVER (";
   {
     const auto partition_strs = visitList(window_func->getPartitionKeys());
     if (!partition_strs.empty()) {
       result += "PARTITION BY " + boost::algorithm::join(partition_strs, ",");
     }
   }
   {
     std::vector<std::string> order_strs;
     const auto& order_keys = window_func->getOrderKeys();
     const auto& collation = window_func->getCollation();
     CHECK_EQ(order_keys.size(), collation.size());
     for (size_t i = 0; i < order_keys.size(); ++i) {
       std::string order_str = visit(order_keys[i].get());
       order_str += collation[i].is_desc ? " DESC" : " ASC";
       // TODO: handle nulls first / last
       order_strs.push_back(order_str);
     }
     if (!order_strs.empty()) {
       result += " ORDER BY " + boost::algorithm::join(order_strs, ",");
     }
   }
   result += ")";
   return result;
 }

Here is the call graph for this function:

Member Data Documentation

const RelAlgExecutionUnit* ScalarExprToSql::ra_exe_unit_

private

Definition at line 66 of file SerializeToSql.h.

Referenced by visitAggExpr(), and visitVar().

The documentation for this class was generated from the following files:

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/SerializeToSql.h
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/SerializeToSql.cpp

Public Member Functions

Protected Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation