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 SQLTypeInfo &return_ti, 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 SQLTypeInfo &return_ti, 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 SQLTypeInfo &return_ti, 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

size_t	getNonLiteralsArity () 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

bool	requiresPerRowTranslation () 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 (std::function< bool(const Expr )> f, 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=false, const bool cols_first_arg_only=true) const

Static Private Member Functions
static SQLTypeInfo	get_return_type (const SqlStringOpKind kind, 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 1601 of file Analyzer.h.

Member Typedef Documentation

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

Definition at line 1765 of file Analyzer.h.

Member Enumeration Documentation

enum Analyzer::StringOper::OperandTypeFamily

strong

Enumerator
STRING_FAMILY
INT_FAMILY

Definition at line 1605 of file Analyzer.h.

1605 { 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 1607 of file Analyzer.h.

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

Analyzer::Expr::Expr

Expr(SQLTypes t, bool notnull)

Definition: Analyzer.h:70

run_benchmark_import.args

tuple args

Definition: run_benchmark_import.py:247

Analyzer::StringOper::get_return_type

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

Definition: Analyzer.cpp:4286

Analyzer::StringOper::args_

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

Definition: Analyzer.h:1816

Analyzer::StringOper::kind_

SqlStringOpKind kind_

Definition: Analyzer.h:1815

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

inline

Definition at line 1611 of file Analyzer.h.

1614 : Expr(return_ti), kind_(kind), args_(args) {}

Analyzer::Expr::Expr

Expr(SQLTypes t, bool notnull)

Definition: Analyzer.h:70

run_benchmark_import.args

tuple args

Definition: run_benchmark_import.py:247

Analyzer::StringOper::args_

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

Definition: Analyzer.h:1816

Analyzer::StringOper::kind_

SqlStringOpKind kind_

Definition: Analyzer.h:1815

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 1616 of file Analyzer.h.

References check_operand_types(), CONCAT, and RCONCAT.

       : Expr(StringOper::get_return_type(kind, args)), kind_(kind), args_(args) {
     check_operand_types(min_args,
                         expected_type_families,
                         arg_names,
                         false /* dict_encoded_cols_only */,
                         !(kind == SqlStringOpKind::CONCAT ||
                           kind == SqlStringOpKind::RCONCAT) /* cols_first_arg_only */);
   }

Here is the call graph for this function:

Analyzer::StringOper::StringOper	(	const SqlStringOpKind	kind,
		const SQLTypeInfo &	return_ti,
		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 1630 of file Analyzer.h.

References check_operand_types(), CONCAT, and RCONCAT.

       : Expr(return_ti), kind_(kind), args_(args) {
     check_operand_types(min_args,
                         expected_type_families,
                         arg_names,
                         false /* dict_encoded_cols_only */,
                         !(kind == SqlStringOpKind::CONCAT ||
                           kind == SqlStringOpKind::RCONCAT) /* cols_first_arg_only */);
   }

Here is the call graph for this function:

Analyzer::StringOper::StringOper	(	const SqlStringOpKind	kind,
		const SQLTypeInfo &	return_ti,
		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 1645 of file Analyzer.h.

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

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

inline

Definition at line 1654 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 1661 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 = `false`,
		const bool	cols_first_arg_only = `true`
	)		const

private

Definition at line 4322 of file Analyzer.cpp.

References args_, CHECK_EQ, g_enable_string_functions, get_kind(), Analyzer::Expr::get_type_info(), 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_case =
         dynamic_cast<const Analyzer::CaseExpr*>(decasted_arg.get()) != nullptr;
     if (is_arg_case) {
       oss << "Error instantiating " << ::toString(get_kind()) << " operator. "
           << "Currently string operations cannot be run on output of a case "
           << "statement.";
       throw std::runtime_error(oss.str());
     }
     const bool is_arg_constant =
         dynamic_cast<const Analyzer::Constant*>(decasted_arg.get()) != nullptr;
     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_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 are allowed for argument '" << arg_names[0]
           << "', but a column input was received for argument '" << arg_names[arg_idx]
           << "'.";
       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_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 3572 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 3512 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 3681 of file Analyzer.cpp.

References args_, chained_string_op_exprs_, Analyzer::Expr::get_type_info(), 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_,
                                         get_type_info(),
                                         std::move(args_copy),
                                         std::move(chained_string_op_exprs_copy));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from Analyzer::Expr.

Definition at line 3335 of file Analyzer.cpp.

References Analyzer::Expr::add_unique(), args_, and 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 1668 of file Analyzer.h.

References kind_.

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

1668 { return kind_; }

Analyzer::StringOper::kind_

SqlStringOpKind kind_

Definition: Analyzer.h:1815

Here is the caller graph for this function:

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

staticprivate

Definition at line 4286 of file Analyzer.cpp.

References run_benchmark_import::args, CHECK_NE, kENCODING_DICT, kNULLT, kTEXT, remove_cast(), and TRY_STRING_CAST.

                                                         {
   CHECK_NE(kind, SqlStringOpKind::TRY_STRING_CAST)
       << "get_return_type for TRY_STRING_CAST disallowed.";
   SQLTypeInfo return_ti(kNULLT);
   size_t num_var_string_inputs{0};
   for (const auto& arg : args) {
     const auto raw_arg = arg.get();
     const auto& arg_ti = arg->get_type_info();
     if (dynamic_cast<const Analyzer::CaseExpr*>(remove_cast(raw_arg))) {
       // Currently we disallow case statement inputs to string functions
       // pending a full resolution to QE-359, but the error is thrown
       // downstream in StringOper::check_operand_types
       return SQLTypeInfo(kTEXT, kENCODING_DICT, 0, kNULLT);
     } else if (arg_ti.is_string() && dynamic_cast<const Analyzer::Constant*>(raw_arg)) {
       if (return_ti == SQLTypeInfo(kNULLT)) {
         return_ti = arg_ti;
       }
     } else if (arg_ti.is_none_encoded_string()) {
       return SQLTypeInfo(kTEXT, kENCODING_DICT, 0, kNULLT);
     } else if (arg_ti.is_dict_encoded_string()) {
       if (arg_ti.getStringDictKey().isTransientDict()) {
         return SQLTypeInfo(kTEXT, kENCODING_DICT, 0, kNULLT);
       } else {
         num_var_string_inputs++;
         return_ti = arg_ti;
       }
     }
   }
   if (num_var_string_inputs > 1UL) {
     return SQLTypeInfo(kTEXT, kENCODING_DICT, 0, kNULLT);
   }
   return return_ti;
 }

Here is the call graph for this function:

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

inline

Definition at line 1684 of file Analyzer.h.

References args_, and CHECK_LT.

Referenced by CodeGenerator::codegen(), CodeGenerator::codegenStringFetchAndEncode(), getLiteralArgs(), operator==(), pre_translate_string_ops(), translate_dict_strings(), TransientStringLiteralsVisitor::visitStringOper(), and TextEncodingCastCountVisitor::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 1799 of file Analyzer.h.

References CHECK.

                                                    {
     CHECK(false);
     return {};
   }

size_t Analyzer::StringOper::getArity ( ) const

inline

Definition at line 1670 of file Analyzer.h.

References args_.

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

1670 { return args_.size(); }

Analyzer::StringOper::args_

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

Definition: Analyzer.h:1816

Here is the caller graph for this function:

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

inline

Definition at line 1696 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 1795 of file Analyzer.h.

References CHECK.

                                                                        {
     CHECK(false);
     return {};
   }

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

Definition at line 4258 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 4271 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 1672 of file Analyzer.h.

References args_.

Referenced by getNonLiteralsArity(), and 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 1791 of file Analyzer.h.

References CHECK.

                                     {
     CHECK(false);
     return {};
   }

size_t Analyzer::StringOper::getNonLiteralsArity ( ) const

inline

Definition at line 1682 of file Analyzer.h.

References getArity(), and getLiteralsArity().

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

1682 { return getArity() - getLiteralsArity(); }

Analyzer::StringOper::getArity

size_t getArity() const

Definition: Analyzer.h:1670

Analyzer::StringOper::getLiteralsArity

size_t getLiteralsArity() const

Definition: Analyzer.h:1672

Here is the call graph for this function:

Here is the caller graph for this function:

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

inline

Definition at line 1689 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 1694 of file Analyzer.h.

References args_.

Referenced by ScalarExprVisitor< std::set< shared::TableKey > >::visitStringOper(), and anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitStringOper().

1694 { return args_; }

Analyzer::StringOper::args_

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

Definition: Analyzer.h:1816

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 1785 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 1739 of file Analyzer.h.

References args_, and CHECK.

Referenced by TextEncodingCastCountVisitor::visitStringOper().

                                      {
     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.getStringDictKey().isTransientDict();
   }

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 4244 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 3799 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:

bool Analyzer::StringOper::requiresPerRowTranslation ( ) const

inline

Definition at line 1700 of file Analyzer.h.

References args_, and Analyzer::Expr::get_type_info().

Referenced by CodeGenerator::codegen(), and getExpressionRange().

                                          {
     const auto& return_ti = get_type_info();
     if (return_ti.is_none_encoded_string() ||
         (return_ti.is_dict_encoded_string() &&
          return_ti.getStringDictKey().isTransientDict())) {
       return true;
     }
 
     // Anything that returns the transient dictionary by definition
     // (see StringOper::get_return_type) requires per-row translation,
     // but there is also a path with string->numeric functions (the output is
     // not a string) where we need to see if any of the inputs are none-encoded
     // or transient dictionary encoded, in which case we also need to do per-row
     // translation. The handling of that condition follows below.
 
     size_t num_var_str_args{0};
     for (const auto& arg : args_) {
       const auto arg_is_const = dynamic_cast<const Analyzer::Constant*>(arg.get());
       if (arg_is_const) {
         continue;
       }
       const auto& arg_ti = arg->get_type_info();
       if (arg_ti.is_none_encoded_string() ||
           (arg_ti.is_dict_encoded_string() &&
            arg_ti.getStringDictKey().isTransientDict())) {
         return true;
       }
       num_var_str_args++;
     }
     return num_var_str_args > 1UL;
   }

Here is the call graph for this function:

Here is the caller 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 2058 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 2049 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 2040 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 3853 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 1816 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(), requiresPerRowTranslation(), 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 1817 of file Analyzer.h.

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

SqlStringOpKind Analyzer::StringOper::kind_

private

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