Expression class for string functions The "arg" constructor parameter must be an expression that resolves to a string datatype (e.g. TEXT). More...

#include <Analyzer.h>

Inheritance diagram for Analyzer::StringOper:

Collaboration diagram for Analyzer::StringOper:

Public Types
enum	OperandTypeFamily { OperandTypeFamily::STRING_FAMILY, OperandTypeFamily::INT_FAMILY }

using	LiteralArgMap = std::map< size_t, std::pair< SQLTypes, Datum >>

Public Member Functions
	StringOper (const SqlStringOpKind kind, const std::vector< std::shared_ptr< Analyzer::Expr >> &args)

	StringOper (const SqlStringOpKind kind, const std::vector< std::shared_ptr< Analyzer::Expr >> &args, const size_t min_args, const std::vector< OperandTypeFamily > &expected_type_families, const std::vector< std::string > &arg_names)

	StringOper (const SqlStringOpKind kind, const std::vector< std::shared_ptr< Analyzer::Expr >> &args, const std::vector< std::shared_ptr< Analyzer::Expr >> &chained_string_op_exprs)

	StringOper (const StringOper &other_string_oper)

	StringOper (const std::shared_ptr< StringOper > &other_string_oper)

SqlStringOpKind	get_kind () const

size_t	getArity () const

size_t	getLiteralsArity () const

const Expr *	getArg (const size_t i) const

std::shared_ptr< Analyzer::Expr >	getOwnArg (const size_t i) const

std::vector< std::shared_ptr < Analyzer::Expr > >	getOwnArgs () const

std::vector< std::shared_ptr < Analyzer::Expr > >	getChainedStringOpExprs () const

void	collect_rte_idx (std::set< int > &rte_idx_set) const override

void	collect_column_var (std::set< const ColumnVar , bool()(const ColumnVar , const ColumnVar )> &colvar_set, bool include_agg) const override

bool	hasNoneEncodedTextArg () const

bool	hasSingleDictEncodedColInput () const
	returns whether we have one and only one column involved in this StringOper and all its descendents, and that that column is a dictionary-encoded text type More...

std::vector< size_t >	getLiteralArgIndexes () const

LiteralArgMap	getLiteralArgs () const

std::shared_ptr< Analyzer::Expr >	rewrite_with_targetlist (const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override

std::shared_ptr< Analyzer::Expr >	rewrite_with_child_targetlist (const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override

std::shared_ptr< Analyzer::Expr >	rewrite_agg_to_var (const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override

std::shared_ptr< Analyzer::Expr >	deep_copy () const override

void	group_predicates (std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override

bool	operator== (const Expr &rhs) const override

std::string	toString () const override

void	find_expr (bool(f)(const Expr ), std::list< const Expr * > &expr_list) const override

virtual size_t	getMinArgs () const

virtual std::vector < OperandTypeFamily >	getExpectedTypeFamilies () const

virtual std::vector< std::string >	getArgNames () const

Public Member Functions inherited from Analyzer::Expr
	Expr (SQLTypes t, bool notnull)

	Expr (SQLTypes t, int d, bool notnull)

	Expr (SQLTypes t, int d, int s, bool notnull)

	Expr (const SQLTypeInfo &ti, bool has_agg=false)

virtual	~Expr ()

std::shared_ptr< Analyzer::Expr >	get_shared_ptr ()

const SQLTypeInfo &	get_type_info () const

void	set_type_info (const SQLTypeInfo &ti)

bool	get_contains_agg () const

void	set_contains_agg (bool a)

virtual std::shared_ptr < Analyzer::Expr >	add_cast (const SQLTypeInfo &new_type_info)

virtual void	check_group_by (const std::list< std::shared_ptr< Analyzer::Expr >> &groupby) const

virtual std::shared_ptr < Analyzer::Expr >	normalize_simple_predicate (int &rte_idx) const

virtual size_t	get_num_column_vars (const bool include_agg) const

virtual void	print () const

virtual void	add_unique (std::list< const Expr * > &expr_list) const

std::shared_ptr< Analyzer::Expr >	decompress ()

virtual void	get_domain (DomainSet &domain_set) const

Private Member Functions
void	check_operand_types (const size_t min_args, const std::vector< OperandTypeFamily > &expected_type_families, const std::vector< std::string > &arg_names, const bool dict_encoded_cols_only=true, const bool cols_first_arg_only=true) const

Static Private Member Functions
static SQLTypeInfo	get_return_type (const std::vector< std::shared_ptr< Analyzer::Expr >> args)

Private Attributes
SqlStringOpKind	kind_

std::vector< std::shared_ptr < Analyzer::Expr > >	args_

std::vector< std::shared_ptr < Analyzer::Expr > >	chained_string_op_exprs_

Additional Inherited Members
Protected Attributes inherited from Analyzer::Expr
SQLTypeInfo	type_info

bool	contains_agg

Detailed Description

Expression class for string functions The "arg" constructor parameter must be an expression that resolves to a string datatype (e.g. TEXT).

Definition at line 1464 of file Analyzer.h.

Member Typedef Documentation

using Analyzer::StringOper::LiteralArgMap = std::map<size_t, std::pair<SQLTypes, Datum>>

Definition at line 1568 of file Analyzer.h.

Member Enumeration Documentation

enum Analyzer::StringOper::OperandTypeFamily

strong

Enumerator
STRING_FAMILY
INT_FAMILY

Definition at line 1468 of file Analyzer.h.

1468 { STRING_FAMILY, INT_FAMILY };

Constructor & Destructor Documentation

Analyzer::StringOper::StringOper	(	const SqlStringOpKind	kind,
		const std::vector< std::shared_ptr< Analyzer::Expr >> &	args
	)

inline

Definition at line 1470 of file Analyzer.h.

1472 : Expr(StringOper::get_return_type(args)), kind_(kind), args_(args) {}

Analyzer::Expr::Expr

Expr(SQLTypes t, bool notnull)

Definition: Analyzer.h:73

run_benchmark_import.args

tuple args

Definition: run_benchmark_import.py:247

Analyzer::StringOper::get_return_type

static SQLTypeInfo get_return_type(const std::vector< std::shared_ptr< Analyzer::Expr >> args)

Definition: Analyzer.cpp:4023

Analyzer::StringOper::args_

std::vector< std::shared_ptr< Analyzer::Expr > > args_

Definition: Analyzer.h:1618

Analyzer::StringOper::kind_

SqlStringOpKind kind_

Definition: Analyzer.h:1617

Analyzer::StringOper::StringOper	(	const SqlStringOpKind	kind,
		const std::vector< std::shared_ptr< Analyzer::Expr >> &	args,
		const size_t	min_args,
		const std::vector< OperandTypeFamily > &	expected_type_families,
		const std::vector< std::string > &	arg_names
	)

inline

Definition at line 1474 of file Analyzer.h.

References check_operand_types().

       : Expr(StringOper::get_return_type(args)), kind_(kind), args_(args) {
     check_operand_types(min_args, expected_type_families, arg_names);
   }

Here is the call graph for this function:

Analyzer::StringOper::StringOper	(	const SqlStringOpKind	kind,
		const std::vector< std::shared_ptr< Analyzer::Expr >> &	args,
		const std::vector< std::shared_ptr< Analyzer::Expr >> &	chained_string_op_exprs
	)

inline

Definition at line 1483 of file Analyzer.h.

       : Expr(StringOper::get_return_type(args))
       , kind_(kind)
       , args_(args)
       , chained_string_op_exprs_(chained_string_op_exprs) {}

Analyzer::StringOper::StringOper ( const StringOper & other_string_oper )

inline

Definition at line 1491 of file Analyzer.h.

References args_, chained_string_op_exprs_, and kind_.

       : Expr(other_string_oper.get_type_info()) {
     kind_ = other_string_oper.kind_;
     args_ = other_string_oper.args_;
     chained_string_op_exprs_ = other_string_oper.chained_string_op_exprs_;
   }

Analyzer::StringOper::StringOper ( const std::shared_ptr< StringOper > & other_string_oper )

inline

Definition at line 1498 of file Analyzer.h.

References args_, chained_string_op_exprs_, and kind_.

       : Expr(other_string_oper->get_type_info()) {
     kind_ = other_string_oper->kind_;
     args_ = other_string_oper->args_;
     chained_string_op_exprs_ = other_string_oper->chained_string_op_exprs_;
   }

Member Function Documentation

void Analyzer::StringOper::check_operand_types	(	const size_t	min_args,
		const std::vector< OperandTypeFamily > &	expected_type_families,
		const std::vector< std::string > &	arg_names,
		const bool	dict_encoded_cols_only = `true`,
		const bool	cols_first_arg_only = `true`
	)		const

private

Definition at line 4045 of file Analyzer.cpp.

References args_, CHECK_EQ, g_enable_string_functions, get_kind(), INT_FAMILY, IS_INTEGER, remove_cast(), STRING_FAMILY, and toString().

Referenced by StringOper().

                                           {
   std::ostringstream oss;
   if (!g_enable_string_functions) {
     oss << "Function " << ::toString(get_kind()) << " not supported.";
     throw std::runtime_error(oss.str());
   }
   const size_t num_args = args_.size();
   CHECK_EQ(expected_type_families.size(), arg_names.size());
   if (num_args < min_args || num_args > expected_type_families.size()) {
     oss << "Error instantiating " << ::toString(get_kind()) << " operator. ";
     oss << "Expected " << expected_type_families.size() << " arguments, but received "
         << num_args << ".";
   }
   for (size_t arg_idx = 0; arg_idx < num_args; ++arg_idx) {
     const auto& expected_type_family = expected_type_families[arg_idx];
     // We need to remove any casts that Calcite may add to try the right operand type,
     // even if we don't support them. Need to check how this works with casts we do
     // support.
     auto arg_ti = args_[arg_idx]->get_type_info();
     const auto decasted_arg = remove_cast(args_[arg_idx]);
     const bool is_arg_constant =
         dynamic_cast<const Analyzer::Constant*>(decasted_arg.get()) != nullptr;
     const bool is_arg_column_var =
         dynamic_cast<const Analyzer::ColumnVar*>(decasted_arg.get()) != nullptr;
     const bool is_arg_string_oper =
         dynamic_cast<const Analyzer::StringOper*>(decasted_arg.get()) != nullptr;
     if (!(is_arg_constant || is_arg_column_var || is_arg_string_oper)) {
       oss << "Error instantiating " << ::toString(get_kind()) << " operator. "
           << "Currently only constant, column, or other string operator arguments "
           << "are allowed as inputs.";
       throw std::runtime_error(oss.str());
     }
     auto decasted_arg_ti = decasted_arg->get_type_info();
     // We need to prevent any non-string type from being casted to a string, but can
     // permit non-integer types being casted to integers Todo: Find a cleaner way to
     // handle this (we haven't validated any of the casts that calcite has given us at the
     // point of RelAlgTranslation)
     if (arg_ti != decasted_arg_ti &&
         ((arg_ti.is_string() && !decasted_arg_ti.is_string()) ||
          (arg_ti.is_integer() && decasted_arg_ti.is_string()))) {
       arg_ti = decasted_arg_ti;
     }
 
     if (cols_first_arg_only && !is_arg_constant && arg_idx >= 1UL) {
       oss << "Error instantiating " << ::toString(get_kind()) << " operator. "
           << "Currently only column inputs allowed for the primary argument, "
           << "but a column input was received for argument " << arg_idx + 1 << ".";
       throw std::runtime_error(oss.str());
     }
     switch (expected_type_family) {
       case OperandTypeFamily::STRING_FAMILY: {
         if (!arg_ti.is_string()) {
           oss << "Error instantiating " << ::toString(get_kind()) << " operator. "
               << "Expected text type for argument " << arg_idx + 1 << " ("
               << arg_names[arg_idx] << ").";
           throw std::runtime_error(oss.str());
           break;
         }
         if (dict_encoded_cols_only &&
             (!is_arg_constant && !arg_ti.is_dict_encoded_string())) {
           oss << "Error instantiating " << ::toString(get_kind()) << " operator. "
               << "Currently only text-encoded dictionary-encoded column inputs are "
               << "allowed, but a none-encoded text column argument was received.";
           throw std::runtime_error(oss.str());
           break;
         }
         break;
       }
       case OperandTypeFamily::INT_FAMILY: {
         if (!IS_INTEGER(arg_ti.get_type())) {
           oss << "Error instantiating " << ::toString(get_kind()) << " operator. "
               << "Expected integer type for argument " << arg_idx + 1 << " ("
               << arg_names[arg_idx] << ").";
           throw std::runtime_error(oss.str());
           break;
         }
         if (!is_arg_constant) {
           oss << "Error instantiating " << ::toString(get_kind()) << " operator. "
               << "Currently only text-encoded dictionary column inputs are "
               << "allowed, but an integer-type column was provided.";
           throw std::runtime_error(oss.str());
           break;
         }
         break;
       }
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Analyzer::StringOper::collect_column_var	(	std::set< const ColumnVar , bool()(const ColumnVar , const ColumnVar )> &	colvar_set,
		bool	include_agg
	)		const

overridevirtual

Reimplemented from Analyzer::Expr.

Definition at line 3364 of file Analyzer.cpp.

References args_.

Referenced by hasSingleDictEncodedColInput().

                             {
   for (const auto& arg : args_) {
     arg->collect_column_var(colvar_set, include_agg);
   }
 }

Here is the caller graph for this function:

void Analyzer::StringOper::collect_rte_idx ( std::set< int > & rte_idx_set ) const

overridevirtual

Reimplemented from Analyzer::Expr.

Definition at line 3304 of file Analyzer.cpp.

References args_.

                                                                {
   for (const auto& arg : args_) {
     arg->collect_rte_idx(rte_idx_set);
   }
 }

std::shared_ptr< Analyzer::Expr > Analyzer::StringOper::deep_copy ( ) const

overridevirtual

Implements Analyzer::Expr.

Definition at line 3473 of file Analyzer.cpp.

References args_, chained_string_op_exprs_, and kind_.

                                                         {
   std::vector<std::shared_ptr<Analyzer::Expr>> args_copy;
   for (const auto& arg : args_) {
     args_copy.emplace_back(arg->deep_copy());
   }
   std::vector<std::shared_ptr<Analyzer::Expr>> chained_string_op_exprs_copy;
   for (const auto& chained_string_op_expr : chained_string_op_exprs_) {
     chained_string_op_exprs_copy.emplace_back(chained_string_op_expr->deep_copy());
   }
   return makeExpr<Analyzer::StringOper>(
       kind_, std::move(args_copy), std::move(chained_string_op_exprs_copy));
 }

Here is the caller graph for this function:

void Analyzer::StringOper::find_expr	(	bool()(const Expr )	f,
		std::list< const Expr * > &	expr_list
	)		const

overridevirtual

Reimplemented from Analyzer::Expr.

Definition at line 3139 of file Analyzer.cpp.

References Analyzer::Expr::add_unique(), args_, and anonymous_namespace{Utm.h}::f.

                                                                   {
   if (f(this)) {
     add_unique(expr_list);
     return;
   }
   for (const auto& arg : args_) {
     arg->find_expr(f, expr_list);
   }
 }

Here is the call graph for this function:

SqlStringOpKind Analyzer::StringOper::get_kind ( ) const

inline

Definition at line 1505 of file Analyzer.h.

References kind_.

Referenced by check_operand_types(), operator==(), TransientStringLiteralsVisitor::visitStringOper(), and anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitStringOper().

1505 { return kind_; }

Analyzer::StringOper::kind_

SqlStringOpKind kind_

Definition: Analyzer.h:1617

Here is the caller graph for this function:

SQLTypeInfo Analyzer::StringOper::get_return_type ( const std::vector< std::shared_ptr< Analyzer::Expr >> args )

staticprivate

Definition at line 4023 of file Analyzer.cpp.

References run_benchmark_import::args, Analyzer::Expr::get_type_info(), kENCODING_DICT, kNULLT, kTEXT, and SQLTypeInfo::set_notnull().

                                                        {
   if (args.empty()) {
     return SQLTypeInfo(kNULLT);
   }
   // Constant literal first argument
   if (dynamic_cast<const Analyzer::Constant*>(args[0].get())) {
     return args[0]->get_type_info();
   }
   // None-encoded text column argument
   // Note that whether or not this is allowed is decided separately
   // in check_operand_types
   if (args[0]->get_type_info().is_none_encoded_string()) {
     return SQLTypeInfo(kTEXT, kENCODING_DICT, 0, kNULLT);
   }
   // If here, we have a dict-encoded column arg
   SQLTypeInfo ret_ti(args[0]->get_type_info());
   // Set return as nullable as string op can create nulls
   ret_ti.set_notnull(false);
   return ret_ti;
 }

Here is the call graph for this function:

const Expr* Analyzer::StringOper::getArg ( const size_t i ) const

inline

Definition at line 1519 of file Analyzer.h.

References args_, and CHECK_LT.

Referenced by CodeGenerator::codegen(), CodeGenerator::codegenPerRowStringOper(), getExpressionRange(), getLiteralArgs(), operator==(), pre_translate_string_ops(), and TransientStringLiteralsVisitor::visitStringOper().

                                            {
     CHECK_LT(i, args_.size());
     return args_[i].get();
   }

Here is the caller graph for this function:

virtual std::vector<std::string> Analyzer::StringOper::getArgNames ( ) const

inlinevirtual

Definition at line 1602 of file Analyzer.h.

References CHECK.

                                                    {
     CHECK(false);
     return {};
   }

size_t Analyzer::StringOper::getArity ( ) const

inline

Definition at line 1507 of file Analyzer.h.

References args_.

Referenced by CodeGenerator::codegen(), CodeGenerator::codegenPerRowStringOper(), getLiteralArgs(), operator==(), pre_translate_string_ops(), TransientStringLiteralsVisitor::visitStringOper(), and anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitStringOper().

1507 { return args_.size(); }

Analyzer::StringOper::args_

std::vector< std::shared_ptr< Analyzer::Expr > > args_

Definition: Analyzer.h:1618

Here is the caller graph for this function:

std::vector<std::shared_ptr<Analyzer::Expr> > Analyzer::StringOper::getChainedStringOpExprs ( ) const

inline

Definition at line 1531 of file Analyzer.h.

References chained_string_op_exprs_.

Referenced by getExpressionRange(), getStringOpInfos(), and TransientStringLiteralsVisitor::visitStringOper().

                                                                          {
     return chained_string_op_exprs_;
   }

Here is the caller graph for this function:

virtual std::vector<OperandTypeFamily> Analyzer::StringOper::getExpectedTypeFamilies ( ) const

inlinevirtual

Definition at line 1598 of file Analyzer.h.

References CHECK.

                                                                        {
     CHECK(false);
     return {};
   }

std::vector< size_t > Analyzer::StringOper::getLiteralArgIndexes ( ) const

Definition at line 3995 of file Analyzer.cpp.

References args_.

                                                          {
   std::vector<size_t> literal_arg_indexes;
   const auto num_args = args_.size();
   for (size_t idx = 0; idx < num_args; ++idx) {
     if (dynamic_cast<const Constant*>(args_[idx].get())) {
       literal_arg_indexes.emplace_back(idx);
     }
   }
   return literal_arg_indexes;
 }

LiteralArgMap Analyzer::StringOper::getLiteralArgs ( ) const

Definition at line 4008 of file Analyzer.cpp.

References getArg(), and getArity().

Referenced by TransientStringLiteralsVisitor::visitStringOper(), and anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitStringOper().

                                                {
   LiteralArgMap literal_arg_map;
   const auto num_args = getArity();
   for (size_t idx = 0; idx < num_args; ++idx) {
     const auto constant_arg_expr = dynamic_cast<const Analyzer::Constant*>(getArg(idx));
     if (constant_arg_expr) {
       literal_arg_map.emplace(
           std::make_pair(idx,
                          std::make_pair(constant_arg_expr->get_type_info().get_type(),
                                         constant_arg_expr->get_constval())));
     }
   }
   return literal_arg_map;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t Analyzer::StringOper::getLiteralsArity ( ) const

inline

Definition at line 1509 of file Analyzer.h.

References args_.

Referenced by TransientStringLiteralsVisitor::visitStringOper().

                                   {
     size_t num_literals{0UL};
     for (const auto& arg : args_) {
       if (dynamic_cast<const Constant*>(arg.get())) {
         num_literals++;
       }
     }
     return num_literals;
   }

Here is the caller graph for this function:

virtual size_t Analyzer::StringOper::getMinArgs ( ) const

inlinevirtual

Definition at line 1594 of file Analyzer.h.

References CHECK.

                                     {
     CHECK(false);
     return {};
   }

std::shared_ptr<Analyzer::Expr> Analyzer::StringOper::getOwnArg ( const size_t i ) const

inline

Definition at line 1524 of file Analyzer.h.

References args_, and CHECK_LT.

                                                               {
     CHECK_LT(i, args_.size());
     return args_[i];
   }

std::vector<std::shared_ptr<Analyzer::Expr> > Analyzer::StringOper::getOwnArgs ( ) const

inline

Definition at line 1529 of file Analyzer.h.

References args_.

Referenced by ScalarExprVisitor< std::unordered_set< InputColDescriptor > >::visitStringOper(), and anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitStringOper().

1529 { return args_; }

Analyzer::StringOper::args_

std::vector< std::shared_ptr< Analyzer::Expr > > args_

Definition: Analyzer.h:1618

Here is the caller graph for this function:

void Analyzer::StringOper::group_predicates	(	std::list< const Expr * > &	scan_predicates,
		std::list< const Expr * > &	join_predicates,
		std::list< const Expr * > &	const_predicates
	)		const

overridevirtual

Reimplemented from Analyzer::Expr.

Definition at line 1694 of file Analyzer.cpp.

References args_.

                                                                                 {
   std::set<int> rte_idx_set;
   for (const auto& arg : args_) {
     arg->collect_rte_idx(rte_idx_set);
   }
   if (rte_idx_set.size() > 1) {
     join_predicates.push_back(this);
   } else if (rte_idx_set.size() == 1) {
     scan_predicates.push_back(this);
   } else {
     const_predicates.push_back(this);
   }
 }

bool Analyzer::StringOper::hasNoneEncodedTextArg ( ) const

inline

Definition at line 1542 of file Analyzer.h.

References args_, CHECK, and TRANSIENT_DICT_ID.

Referenced by CodeGenerator::codegen().

                                      {
     if (args_.empty()) {
       return false;
     }
     const auto& arg0_ti = args_[0]->get_type_info();
     if (!arg0_ti.is_string()) {
       return false;
     }
     if (arg0_ti.is_none_encoded_string()) {
       return true;
     }
     CHECK(arg0_ti.is_dict_encoded_string());
     return arg0_ti.get_comp_param() == TRANSIENT_DICT_ID;
   }

Here is the caller graph for this function:

bool Analyzer::StringOper::hasSingleDictEncodedColInput ( ) const

returns whether we have one and only one column involved in this StringOper and all its descendents, and that that column is a dictionary-encoded text type

Returns: std::vector<SqlTypeInfo>

Definition at line 3981 of file Analyzer.cpp.

References CHECK, collect_column_var(), and Analyzer::ColumnVar::colvar_comp().

                                                     {
   auto comparator = Analyzer::ColumnVar::colvar_comp;
   std::set<const Analyzer::ColumnVar*,
            bool (*)(const Analyzer::ColumnVar*, const Analyzer::ColumnVar*)>
       colvar_set(comparator);
   collect_column_var(colvar_set, true);
   if (colvar_set.size() != 1UL) {
     return false;
   }
   auto col_expr_ptr = *colvar_set.begin();
   CHECK(col_expr_ptr);
   return col_expr_ptr->get_type_info().is_dict_encoded_string();
 }

Here is the call graph for this function:

bool Analyzer::StringOper::operator== ( const Expr & rhs ) const

overridevirtual

Implements Analyzer::Expr.

Definition at line 3579 of file Analyzer.cpp.

References chained_string_op_exprs_, get_kind(), getArg(), and getArity().

                                                  {
   const auto rhs_string_oper = dynamic_cast<const StringOper*>(&rhs);
 
   if (!rhs_string_oper) {
     return false;
   }
 
   if (get_kind() != rhs_string_oper->get_kind()) {
     return false;
   }
   if (getArity() != rhs_string_oper->getArity()) {
     return false;
   }
 
   for (size_t i = 0; i < getArity(); ++i) {
     if (!(*getArg(i) == *(rhs_string_oper->getArg(i)))) {
       return false;
     }
   }
   if (chained_string_op_exprs_.size() !=
       rhs_string_oper->chained_string_op_exprs_.size()) {
     return false;
   }
   for (size_t i = 0; i < chained_string_op_exprs_.size(); ++i) {
     if (!(*(chained_string_op_exprs_[i]) ==
           *(rhs_string_oper->chained_string_op_exprs_[i]))) {
       return false;
     }
   }
   return true;
 }

Here is the call graph for this function:

std::shared_ptr< Analyzer::Expr > Analyzer::StringOper::rewrite_agg_to_var ( const std::vector< std::shared_ptr< TargetEntry >> & tlist ) const

overridevirtual

Reimplemented from Analyzer::Expr.

Definition at line 1969 of file Analyzer.cpp.

References args_, and kind_.

                                                               {
   std::vector<std::shared_ptr<Analyzer::Expr>> rewritten_args;
   for (const auto& arg : args_) {
     rewritten_args.emplace_back(arg->rewrite_agg_to_var(tlist));
   }
   return makeExpr<StringOper>(kind_, rewritten_args);
 }

std::shared_ptr< Analyzer::Expr > Analyzer::StringOper::rewrite_with_child_targetlist ( const std::vector< std::shared_ptr< TargetEntry >> & tlist ) const

overridevirtual

Reimplemented from Analyzer::Expr.

Definition at line 1960 of file Analyzer.cpp.

References args_, and kind_.

                                                               {
   std::vector<std::shared_ptr<Analyzer::Expr>> rewritten_args;
   for (const auto& arg : args_) {
     rewritten_args.emplace_back(arg->rewrite_with_child_targetlist(tlist));
   }
   return makeExpr<StringOper>(kind_, rewritten_args);
 }

std::shared_ptr< Analyzer::Expr > Analyzer::StringOper::rewrite_with_targetlist ( const std::vector< std::shared_ptr< TargetEntry >> & tlist ) const

overridevirtual

Reimplemented from Analyzer::Expr.

Definition at line 1951 of file Analyzer.cpp.

References args_, and kind_.

                                                               {
   std::vector<std::shared_ptr<Analyzer::Expr>> rewritten_args;
   for (const auto& arg : args_) {
     rewritten_args.emplace_back(arg->rewrite_with_targetlist(tlist));
   }
   return makeExpr<StringOper>(kind_, rewritten_args);
 }

std::string Analyzer::StringOper::toString ( ) const

overridevirtual

Implements Analyzer::Expr.

Definition at line 3633 of file Analyzer.cpp.

References args_, and kind_.

Referenced by check_operand_types().

                                      {
   std::string str{"(" + ::toString(kind_) + " "};
   for (const auto& arg : args_) {
     str += arg->toString();
   }
   str += ")";
   return str;
 }

Here is the caller graph for this function:

Member Data Documentation

std::vector<std::shared_ptr<Analyzer::Expr> > Analyzer::StringOper::args_

private

Definition at line 1618 of file Analyzer.h.

Referenced by check_operand_types(), collect_column_var(), collect_rte_idx(), deep_copy(), find_expr(), getArg(), getArity(), getLiteralArgIndexes(), getLiteralsArity(), getOwnArg(), getOwnArgs(), group_predicates(), hasNoneEncodedTextArg(), rewrite_agg_to_var(), rewrite_with_child_targetlist(), rewrite_with_targetlist(), StringOper(), and toString().

std::vector<std::shared_ptr<Analyzer::Expr> > Analyzer::StringOper::chained_string_op_exprs_

private

Definition at line 1619 of file Analyzer.h.

Referenced by deep_copy(), getChainedStringOpExprs(), operator==(), and StringOper().

SqlStringOpKind Analyzer::StringOper::kind_

private

Definition at line 1617 of file Analyzer.h.

Referenced by deep_copy(), get_kind(), rewrite_agg_to_var(), rewrite_with_child_targetlist(), rewrite_with_targetlist(), StringOper(), and toString().

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

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

Public Types

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation