#include <Analyzer.h>

Inheritance diagram for Analyzer::TrimStringOper:

Collaboration diagram for Analyzer::TrimStringOper:

Public Member Functions
	TrimStringOper (const SqlStringOpKind trim_op_kind, const std::shared_ptr< Analyzer::Expr > &operand, const std::shared_ptr< Analyzer::Expr > &trim_chars)

	getMinArgs ()

	getExpectedTypeFamilies ()

	getArgNames ())

	TrimStringOper (const SqlStringOpKind trim_op_kind, const std::vector< std::shared_ptr< Analyzer::Expr >> &operands)

	TrimStringOper (const std::shared_ptr< Analyzer::StringOper > &string_oper)

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

size_t	getMinArgs () const override

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

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

Public Member Functions inherited from Analyzer::StringOper
	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

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

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

Static Private Member Functions
static SqlStringOpKind	validate_trim_op_kind (const SqlStringOpKind trim_op_kind)

static SqlStringOpKind	get_and_validate_trim_op_kind (const SqlStringOpKind trim_op_kind_maybe, const std::vector< std::shared_ptr< Analyzer::Expr >> &args)

static std::vector < std::shared_ptr < Analyzer::Expr > >	normalize_operands (const std::vector< std::shared_ptr< Analyzer::Expr >> &operands, const SqlStringOpKind string_op_kind)

Additional Inherited Members
Public Types inherited from Analyzer::StringOper
enum	OperandTypeFamily { OperandTypeFamily::STRING_FAMILY, OperandTypeFamily::INT_FAMILY }

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

Protected Attributes inherited from Analyzer::Expr
SQLTypeInfo	type_info

bool	contains_agg

Detailed Description

Definition at line 2049 of file Analyzer.h.

Constructor & Destructor Documentation

Analyzer::TrimStringOper::TrimStringOper	(	const SqlStringOpKind	trim_op_kind,
		const std::shared_ptr< Analyzer::Expr > &	operand,
		const std::shared_ptr< Analyzer::Expr > &	trim_chars
	)

inline

Definition at line 2051 of file Analyzer.h.

2054 : StringOper(TrimStringOper::validate_trim_op_kind(trim_op_kind),

2055 {operand, trim_chars},

Analyzer::StringOper::StringOper

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

Definition: Analyzer.h:1607

Analyzer::TrimStringOper::validate_trim_op_kind

static SqlStringOpKind validate_trim_op_kind(const SqlStringOpKind trim_op_kind)

Definition: Analyzer.h:2083

Analyzer::TrimStringOper::TrimStringOper	(	const SqlStringOpKind	trim_op_kind,
		const std::vector< std::shared_ptr< Analyzer::Expr >> &	operands
	)

inline

Definition at line 2060 of file Analyzer.h.

       : StringOper(TrimStringOper::get_and_validate_trim_op_kind(trim_op_kind, operands),
                    TrimStringOper::normalize_operands(operands, trim_op_kind),
                    getMinArgs(),
                    getExpectedTypeFamilies(),
                    getArgNames()) {}

Analyzer::TrimStringOper::TrimStringOper ( const std::shared_ptr< Analyzer::StringOper > & string_oper )

inline

Definition at line 2068 of file Analyzer.h.

2069 : StringOper(string_oper) {}

Analyzer::StringOper::StringOper

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

Definition: Analyzer.h:1607

Member Function Documentation

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

overridevirtual

Reimplemented from Analyzer::StringOper.

Definition at line 3726 of file Analyzer.cpp.

References Analyzer::StringOper::deep_copy().

                                                             {
   return makeExpr<Analyzer::TrimStringOper>(
       std::dynamic_pointer_cast<Analyzer::StringOper>(StringOper::deep_copy()));
 }

Here is the call graph for this function:

SqlStringOpKind Analyzer::TrimStringOper::get_and_validate_trim_op_kind	(	const SqlStringOpKind	trim_op_kind_maybe,
		const std::vector< std::shared_ptr< Analyzer::Expr >> &	args
	)

staticprivate

Definition at line 4449 of file Analyzer.cpp.

References run_benchmark_import::args, INVALID, LTRIM, RTRIM, to_upper(), TRIM, and validate_trim_op_kind().

                                                         {
   auto get_trim_type_if_exists = [&args]() {
     if (args.empty()) {
       return SqlStringOpKind::INVALID;
     }
     const auto trim_type_arg = dynamic_cast<const Analyzer::Constant*>(args[0].get());
     if (!trim_type_arg) {
       return SqlStringOpKind::INVALID;
     }
     const auto trim_type_str = to_upper(*trim_type_arg->get_constval().stringval);
     if (trim_type_str == "BOTH") {
       return SqlStringOpKind::TRIM;
     }
     if (trim_type_str == "LEADING") {
       return SqlStringOpKind::LTRIM;
     }
     if (trim_type_str == "TRAILING") {
       return SqlStringOpKind::RTRIM;
     }
     return SqlStringOpKind::INVALID;
   };
 
   const auto trim_op_kind = trim_op_kind_maybe == SqlStringOpKind::TRIM
                                 ? get_trim_type_if_exists()
                                 : trim_op_kind_maybe;
   TrimStringOper::validate_trim_op_kind(trim_op_kind);
   return trim_op_kind;
 }

Here is the call graph for this function:

Analyzer::TrimStringOper::getArgNames ( )

inline

Definition at line 2058 of file Analyzer.h.

2058 {}

std::vector<std::string> Analyzer::TrimStringOper::getArgNames ( ) const

inlineoverridevirtual

Reimplemented from Analyzer::StringOper.

Definition at line 2078 of file Analyzer.h.

                                                     {
     return {"operand", "trim_chars"};
   }

Analyzer::TrimStringOper::getExpectedTypeFamilies ( )

std::vector<OperandTypeFamily> Analyzer::TrimStringOper::getExpectedTypeFamilies ( ) const

inlineoverridevirtual

Reimplemented from Analyzer::StringOper.

Definition at line 2075 of file Analyzer.h.

References Analyzer::StringOper::STRING_FAMILY.

                                                                         {
     return {OperandTypeFamily::STRING_FAMILY, OperandTypeFamily::STRING_FAMILY};
   }

Analyzer::TrimStringOper::getMinArgs ( )

size_t Analyzer::TrimStringOper::getMinArgs ( ) const

inlineoverridevirtual

Reimplemented from Analyzer::StringOper.

Definition at line 2073 of file Analyzer.h.

2073 { return 2UL; }

std::vector< std::shared_ptr< Analyzer::Expr > > Analyzer::TrimStringOper::normalize_operands	(	const std::vector< std::shared_ptr< Analyzer::Expr >> &	operands,
		const SqlStringOpKind	string_op_kind
	)

staticprivate

Definition at line 4480 of file Analyzer.cpp.

References CHECK_EQ, LTRIM, and RTRIM.

                                           {
   if (operands.size() < 2UL) {
     throw std::runtime_error("Trim operator expects 2 arguments.");
   }
 
   // Calcite is returning LTRIM/RTRIM(string_literal1, string_literal2) with the
   // arguments in that order, but LTRIM/TRIM(string_var, string_literal) in the
   // reverse order that the main TRIM operator uses as well
   // Until we can look into that more, reverse order only if we have a const then
   // non-const input order
 
   if (string_op_kind == SqlStringOpKind::LTRIM ||
       string_op_kind == SqlStringOpKind::RTRIM) {
     CHECK_EQ(operands.size(), 2UL);
     if (dynamic_cast<const Analyzer::Constant*>(operands[0].get()) &&
         !dynamic_cast<const Analyzer::Constant*>(operands[1].get())) {
       return {operands[1], operands[0]};
     }
     return operands;
   }
   CHECK_EQ(operands.size(), 3UL);
   return {operands[2], operands[1]};
 }

static SqlStringOpKind Analyzer::TrimStringOper::validate_trim_op_kind ( const SqlStringOpKind trim_op_kind )

inlinestaticprivate

Definition at line 2083 of file Analyzer.h.

References LTRIM, RTRIM, and TRIM.

Referenced by get_and_validate_trim_op_kind().

                                                                                    {
     if (!(trim_op_kind == SqlStringOpKind::TRIM ||
           trim_op_kind == SqlStringOpKind::LTRIM ||
           trim_op_kind == SqlStringOpKind::RTRIM)) {
       // Arguably should CHECK here
       throw std::runtime_error("Invalid trim type supplied to TRIM operator");
     }
     return trim_op_kind;
   }

Here is the caller graph for this function:

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 Member Functions

Static Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation