OmniSciDB  c1a53651b2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Analyzer::StringOper Class Reference

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 ExprgetArg (const size_t i) const
 
std::shared_ptr< Analyzer::ExprgetOwnArg (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::Exprrewrite_with_targetlist (const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
 
std::shared_ptr< Analyzer::Exprrewrite_with_child_targetlist (const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
 
std::shared_ptr< Analyzer::Exprrewrite_agg_to_var (const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
 
std::shared_ptr< Analyzer::Exprdeep_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::Exprget_shared_ptr ()
 
const SQLTypeInfoget_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::Exprdecompress ()
 
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 1479 of file Analyzer.h.

Member Typedef Documentation

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

Definition at line 1643 of file Analyzer.h.

Member Enumeration Documentation

Enumerator
STRING_FAMILY 
INT_FAMILY 

Definition at line 1483 of file Analyzer.h.

1483 { 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 1485 of file Analyzer.h.

1487  : Expr(StringOper::get_return_type(kind, args)), kind_(kind), args_(args) {}
Expr(SQLTypes t, bool notnull)
Definition: Analyzer.h:70
static SQLTypeInfo get_return_type(const SqlStringOpKind kind, const std::vector< std::shared_ptr< Analyzer::Expr >> &args)
Definition: Analyzer.cpp:4092
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
SqlStringOpKind kind_
Definition: Analyzer.h:1693
Analyzer::StringOper::StringOper ( const SqlStringOpKind  kind,
const SQLTypeInfo return_ti,
const std::vector< std::shared_ptr< Analyzer::Expr >> &  args 
)
inline

Definition at line 1489 of file Analyzer.h.

1492  : Expr(return_ti), kind_(kind), args_(args) {}
Expr(SQLTypes t, bool notnull)
Definition: Analyzer.h:70
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
SqlStringOpKind kind_
Definition: Analyzer.h:1693
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 1494 of file Analyzer.h.

References check_operand_types(), CONCAT, and RCONCAT.

1499  : Expr(StringOper::get_return_type(kind, args)), kind_(kind), args_(args) {
1500  check_operand_types(min_args,
1501  expected_type_families,
1502  arg_names,
1503  false /* dict_encoded_cols_only */,
1504  !(kind == SqlStringOpKind::CONCAT ||
1505  kind == SqlStringOpKind::RCONCAT) /* cols_first_arg_only */);
1506  }
Expr(SQLTypes t, bool notnull)
Definition: Analyzer.h:70
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
Definition: Analyzer.cpp:4128
static SQLTypeInfo get_return_type(const SqlStringOpKind kind, const std::vector< std::shared_ptr< Analyzer::Expr >> &args)
Definition: Analyzer.cpp:4092
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
SqlStringOpKind kind_
Definition: Analyzer.h:1693

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

References check_operand_types(), CONCAT, and RCONCAT.

1514  : Expr(return_ti), kind_(kind), args_(args) {
1515  check_operand_types(min_args,
1516  expected_type_families,
1517  arg_names,
1518  false /* dict_encoded_cols_only */,
1519  !(kind == SqlStringOpKind::CONCAT ||
1520  kind == SqlStringOpKind::RCONCAT) /* cols_first_arg_only */);
1521  }
Expr(SQLTypes t, bool notnull)
Definition: Analyzer.h:70
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
Definition: Analyzer.cpp:4128
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
SqlStringOpKind kind_
Definition: Analyzer.h:1693

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

1527  : Expr(return_ti)
1528  , kind_(kind)
1529  , args_(args)
1530  , chained_string_op_exprs_(chained_string_op_exprs) {}
Expr(SQLTypes t, bool notnull)
Definition: Analyzer.h:70
std::vector< std::shared_ptr< Analyzer::Expr > > chained_string_op_exprs_
Definition: Analyzer.h:1695
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
SqlStringOpKind kind_
Definition: Analyzer.h:1693
Analyzer::StringOper::StringOper ( const StringOper other_string_oper)
inline

Definition at line 1532 of file Analyzer.h.

References args_, chained_string_op_exprs_, and kind_.

1533  : Expr(other_string_oper.get_type_info()) {
1534  kind_ = other_string_oper.kind_;
1535  args_ = other_string_oper.args_;
1536  chained_string_op_exprs_ = other_string_oper.chained_string_op_exprs_;
1537  }
Expr(SQLTypes t, bool notnull)
Definition: Analyzer.h:70
std::vector< std::shared_ptr< Analyzer::Expr > > chained_string_op_exprs_
Definition: Analyzer.h:1695
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
SqlStringOpKind kind_
Definition: Analyzer.h:1693
Analyzer::StringOper::StringOper ( const std::shared_ptr< StringOper > &  other_string_oper)
inline

Definition at line 1539 of file Analyzer.h.

References args_, chained_string_op_exprs_, and kind_.

1540  : Expr(other_string_oper->get_type_info()) {
1541  kind_ = other_string_oper->kind_;
1542  args_ = other_string_oper->args_;
1543  chained_string_op_exprs_ = other_string_oper->chained_string_op_exprs_;
1544  }
Expr(SQLTypes t, bool notnull)
Definition: Analyzer.h:70
std::vector< std::shared_ptr< Analyzer::Expr > > chained_string_op_exprs_
Definition: Analyzer.h:1695
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
SqlStringOpKind kind_
Definition: Analyzer.h:1693

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 4128 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().

4133  {
4134  std::ostringstream oss;
4136  oss << "Function " << ::toString(get_kind()) << " not supported.";
4137  throw std::runtime_error(oss.str());
4138  }
4139  const size_t num_args = args_.size();
4140  CHECK_EQ(expected_type_families.size(), arg_names.size());
4141  if (num_args < min_args || num_args > expected_type_families.size()) {
4142  oss << "Error instantiating " << ::toString(get_kind()) << " operator. ";
4143  oss << "Expected " << expected_type_families.size() << " arguments, but received "
4144  << num_args << ".";
4145  }
4146  for (size_t arg_idx = 0; arg_idx < num_args; ++arg_idx) {
4147  const auto& expected_type_family = expected_type_families[arg_idx];
4148  // We need to remove any casts that Calcite may add to try the right operand type,
4149  // even if we don't support them. Need to check how this works with casts we do
4150  // support.
4151  auto arg_ti = args_[arg_idx]->get_type_info();
4152  const auto decasted_arg = remove_cast(args_[arg_idx]);
4153  const bool is_arg_case =
4154  dynamic_cast<const Analyzer::CaseExpr*>(decasted_arg.get()) != nullptr;
4155  if (is_arg_case) {
4156  oss << "Error instantiating " << ::toString(get_kind()) << " operator. "
4157  << "Currently string operations cannot be run on output of a case "
4158  << "statement.";
4159  throw std::runtime_error(oss.str());
4160  }
4161  const bool is_arg_constant =
4162  dynamic_cast<const Analyzer::Constant*>(decasted_arg.get()) != nullptr;
4163  auto decasted_arg_ti = decasted_arg->get_type_info();
4164  // We need to prevent any non-string type from being casted to a string, but can
4165  // permit non-integer types being casted to integers Todo: Find a cleaner way to
4166  // handle this (we haven't validated any of the casts that calcite has given us at
4167  // the point of RelAlgTranslation)
4168  if (arg_ti != decasted_arg_ti &&
4169  (arg_ti.is_integer() && decasted_arg_ti.is_string())) {
4170  arg_ti = decasted_arg_ti;
4171  }
4172 
4173  if (cols_first_arg_only && !is_arg_constant && arg_idx >= 1UL) {
4174  oss << "Error instantiating " << ::toString(get_kind()) << " operator. "
4175  << "Currently only column inputs are allowed for argument '" << arg_names[0]
4176  << "', but a column input was received for argument '" << arg_names[arg_idx]
4177  << "'.";
4178  throw std::runtime_error(oss.str());
4179  }
4180  switch (expected_type_family) {
4182  if (!arg_ti.is_string()) {
4183  oss << "Error instantiating " << ::toString(get_kind()) << " operator. "
4184  << "Expected text type for argument '" << arg_names[arg_idx] << "'";
4185  throw std::runtime_error(oss.str());
4186  break;
4187  }
4188  if (dict_encoded_cols_only &&
4189  (!is_arg_constant && !arg_ti.is_dict_encoded_string())) {
4190  oss << "Error instantiating " << ::toString(get_kind()) << " operator. "
4191  << "Currently only text-encoded dictionary-encoded column inputs are "
4192  << "allowed, but a none-encoded text column argument was received.";
4193  throw std::runtime_error(oss.str());
4194  break;
4195  }
4196  break;
4197  }
4199  if (!IS_INTEGER(arg_ti.get_type())) {
4200  oss << "Error instantiating " << ::toString(get_kind()) << " operator. "
4201  << "Expected integer type for argument " << arg_idx + 1 << " ('"
4202  << arg_names[arg_idx] << "').";
4203  throw std::runtime_error(oss.str());
4204  break;
4205  }
4206  if (!is_arg_constant) {
4207  oss << "Error instantiating " << ::toString(get_kind()) << " operator. "
4208  << "Currently only text-encoded dictionary column inputs are "
4209  << "allowed, but an integer-type column was provided.";
4210  throw std::runtime_error(oss.str());
4211  break;
4212  }
4213  break;
4214  }
4215  }
4216  }
4217 }
#define CHECK_EQ(x, y)
Definition: Logger.h:301
std::shared_ptr< Analyzer::Expr > remove_cast(const std::shared_ptr< Analyzer::Expr > &expr)
Definition: Analyzer.cpp:4339
bool g_enable_string_functions
const SQLTypeInfo & get_type_info() const
Definition: Analyzer.h:79
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
SqlStringOpKind get_kind() const
Definition: Analyzer.h:1546
#define IS_INTEGER(T)
Definition: sqltypes.h:294
std::string toString() const override
Definition: Analyzer.cpp:3702

+ 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 3421 of file Analyzer.cpp.

References args_.

Referenced by hasSingleDictEncodedColInput().

3423  {
3424  for (const auto& arg : args_) {
3425  arg->collect_column_var(colvar_set, include_agg);
3426  }
3427 }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694

+ 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 3361 of file Analyzer.cpp.

References args_.

3361  {
3362  for (const auto& arg : args_) {
3363  arg->collect_rte_idx(rte_idx_set);
3364  }
3365 }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
std::shared_ptr< Analyzer::Expr > Analyzer::StringOper::deep_copy ( ) const
overridevirtual

Implements Analyzer::Expr.

Reimplemented in Analyzer::PositionStringOper, Analyzer::TryStringCastOper, Analyzer::Base64DecodeStringOper, Analyzer::Base64EncodeStringOper, Analyzer::JsonValueStringOper, Analyzer::RegexpSubstrStringOper, Analyzer::RegexpReplaceStringOper, Analyzer::SplitPartStringOper, Analyzer::ReplaceStringOper, Analyzer::OverlayStringOper, Analyzer::SubstringStringOper, Analyzer::TrimStringOper, Analyzer::PadStringOper, Analyzer::ConcatStringOper, Analyzer::RepeatStringOper, Analyzer::ReverseStringOper, Analyzer::InitCapStringOper, Analyzer::UpperStringOper, and Analyzer::LowerStringOper.

Definition at line 3530 of file Analyzer.cpp.

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

Referenced by Analyzer::LowerStringOper::deep_copy(), Analyzer::UpperStringOper::deep_copy(), Analyzer::InitCapStringOper::deep_copy(), Analyzer::ReverseStringOper::deep_copy(), Analyzer::RepeatStringOper::deep_copy(), Analyzer::ConcatStringOper::deep_copy(), Analyzer::PadStringOper::deep_copy(), Analyzer::TrimStringOper::deep_copy(), Analyzer::SubstringStringOper::deep_copy(), Analyzer::OverlayStringOper::deep_copy(), Analyzer::ReplaceStringOper::deep_copy(), Analyzer::SplitPartStringOper::deep_copy(), Analyzer::RegexpReplaceStringOper::deep_copy(), Analyzer::RegexpSubstrStringOper::deep_copy(), Analyzer::JsonValueStringOper::deep_copy(), Analyzer::Base64EncodeStringOper::deep_copy(), Analyzer::Base64DecodeStringOper::deep_copy(), Analyzer::TryStringCastOper::deep_copy(), Analyzer::PositionStringOper::deep_copy(), and DeepCopyVisitor::visitStringOper().

3530  {
3531  std::vector<std::shared_ptr<Analyzer::Expr>> args_copy;
3532  for (const auto& arg : args_) {
3533  args_copy.emplace_back(arg->deep_copy());
3534  }
3535  std::vector<std::shared_ptr<Analyzer::Expr>> chained_string_op_exprs_copy;
3536  for (const auto& chained_string_op_expr : chained_string_op_exprs_) {
3537  chained_string_op_exprs_copy.emplace_back(chained_string_op_expr->deep_copy());
3538  }
3539  return makeExpr<Analyzer::StringOper>(kind_,
3540  get_type_info(),
3541  std::move(args_copy),
3542  std::move(chained_string_op_exprs_copy));
3543 }
std::vector< std::shared_ptr< Analyzer::Expr > > chained_string_op_exprs_
Definition: Analyzer.h:1695
const SQLTypeInfo & get_type_info() const
Definition: Analyzer.h:79
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
SqlStringOpKind kind_
Definition: Analyzer.h:1693

+ 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 3184 of file Analyzer.cpp.

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

3185  {
3186  if (f(this)) {
3187  add_unique(expr_list);
3188  return;
3189  }
3190  for (const auto& arg : args_) {
3191  arg->find_expr(f, expr_list);
3192  }
3193 }
virtual void add_unique(std::list< const Expr * > &expr_list) const
Definition: Analyzer.cpp:3116
constexpr double f
Definition: Utm.h:31
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694

+ Here is the call graph for this function:

SqlStringOpKind Analyzer::StringOper::get_kind ( ) const
inline

Definition at line 1546 of file Analyzer.h.

References kind_.

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

1546 { return kind_; }
SqlStringOpKind kind_
Definition: Analyzer.h:1693

+ 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 4092 of file Analyzer.cpp.

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

4094  {
4096  << "get_return_type for TRY_STRING_CAST disallowed.";
4097  SQLTypeInfo return_ti(kNULLT);
4098  size_t num_var_string_inputs{0};
4099  for (const auto& arg : args) {
4100  const auto raw_arg = arg.get();
4101  const auto& arg_ti = arg->get_type_info();
4102  if (dynamic_cast<const Analyzer::CaseExpr*>(remove_cast(raw_arg))) {
4103  // Currently we disallow case statement inputs to string functions
4104  // pending a full resolution to QE-359, but the error is thrown
4105  // downstream in StringOper::check_operand_types
4106  return SQLTypeInfo(kTEXT, kENCODING_DICT, 0, kNULLT);
4107  } else if (arg_ti.is_string() && dynamic_cast<const Analyzer::Constant*>(raw_arg)) {
4108  if (return_ti == SQLTypeInfo(kNULLT)) {
4109  return_ti = arg_ti;
4110  }
4111  } else if (arg_ti.is_none_encoded_string()) {
4112  return SQLTypeInfo(kTEXT, kENCODING_DICT, 0, kNULLT);
4113  } else if (arg_ti.is_dict_encoded_string()) {
4114  if (arg_ti.getStringDictKey().isTransientDict()) {
4115  return SQLTypeInfo(kTEXT, kENCODING_DICT, 0, kNULLT);
4116  } else {
4117  num_var_string_inputs++;
4118  return_ti = arg_ti;
4119  }
4120  }
4121  }
4122  if (num_var_string_inputs > 1UL) {
4123  return SQLTypeInfo(kTEXT, kENCODING_DICT, 0, kNULLT);
4124  }
4125  return return_ti;
4126 }
std::shared_ptr< Analyzer::Expr > remove_cast(const std::shared_ptr< Analyzer::Expr > &expr)
Definition: Analyzer.cpp:4339
#define CHECK_NE(x, y)
Definition: Logger.h:302
Definition: sqltypes.h:69

+ Here is the call graph for this function:

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

Definition at line 1562 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 anonymous_namespace{RelAlgExecutor.cpp}::TextEncodingCastCountVisitor::visitStringOper().

1562  {
1563  CHECK_LT(i, args_.size());
1564  return args_[i].get();
1565  }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
#define CHECK_LT(x, y)
Definition: Logger.h:303

+ Here is the caller graph for this function:

size_t Analyzer::StringOper::getArity ( ) const
inline

Definition at line 1548 of file Analyzer.h.

References args_.

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

1548 { return args_.size(); }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694

+ Here is the caller graph for this function:

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

Definition at line 1574 of file Analyzer.h.

References chained_string_op_exprs_.

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

1574  {
1575  return chained_string_op_exprs_;
1576  }
std::vector< std::shared_ptr< Analyzer::Expr > > chained_string_op_exprs_
Definition: Analyzer.h:1695

+ Here is the caller graph for this function:

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

Definition at line 4064 of file Analyzer.cpp.

References args_.

4064  {
4065  std::vector<size_t> literal_arg_indexes;
4066  const auto num_args = args_.size();
4067  for (size_t idx = 0; idx < num_args; ++idx) {
4068  if (dynamic_cast<const Constant*>(args_[idx].get())) {
4069  literal_arg_indexes.emplace_back(idx);
4070  }
4071  }
4072  return literal_arg_indexes;
4073 }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
LiteralArgMap Analyzer::StringOper::getLiteralArgs ( ) const

Definition at line 4077 of file Analyzer.cpp.

References getArg(), and getArity().

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

4077  {
4078  LiteralArgMap literal_arg_map;
4079  const auto num_args = getArity();
4080  for (size_t idx = 0; idx < num_args; ++idx) {
4081  const auto constant_arg_expr = dynamic_cast<const Analyzer::Constant*>(getArg(idx));
4082  if (constant_arg_expr) {
4083  literal_arg_map.emplace(
4084  std::make_pair(idx,
4085  std::make_pair(constant_arg_expr->get_type_info().get_type(),
4086  constant_arg_expr->get_constval())));
4087  }
4088  }
4089  return literal_arg_map;
4090 }
std::map< size_t, std::pair< SQLTypes, Datum >> LiteralArgMap
Definition: Analyzer.h:1643
size_t getArity() const
Definition: Analyzer.h:1548
const Expr * getArg(const size_t i) const
Definition: Analyzer.h:1562

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

References args_.

Referenced by getNonLiteralsArity(), and TransientStringLiteralsVisitor::visitStringOper().

1550  {
1551  size_t num_literals{0UL};
1552  for (const auto& arg : args_) {
1553  if (dynamic_cast<const Constant*>(arg.get())) {
1554  num_literals++;
1555  }
1556  }
1557  return num_literals;
1558  }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694

+ Here is the caller graph for this function:

size_t Analyzer::StringOper::getNonLiteralsArity ( ) const
inline

Definition at line 1560 of file Analyzer.h.

References getArity(), and getLiteralsArity().

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

1560 { return getArity() - getLiteralsArity(); }
size_t getArity() const
Definition: Analyzer.h:1548
size_t getLiteralsArity() const
Definition: Analyzer.h:1550

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

References args_, and CHECK_LT.

1567  {
1568  CHECK_LT(i, args_.size());
1569  return args_[i];
1570  }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
#define CHECK_LT(x, y)
Definition: Logger.h:303
std::vector<std::shared_ptr<Analyzer::Expr> > Analyzer::StringOper::getOwnArgs ( ) const
inline

Definition at line 1572 of file Analyzer.h.

References args_.

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

1572 { return args_; }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694

+ 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 1726 of file Analyzer.cpp.

References args_.

1728  {
1729  std::set<int> rte_idx_set;
1730  for (const auto& arg : args_) {
1731  arg->collect_rte_idx(rte_idx_set);
1732  }
1733  if (rte_idx_set.size() > 1) {
1734  join_predicates.push_back(this);
1735  } else if (rte_idx_set.size() == 1) {
1736  scan_predicates.push_back(this);
1737  } else {
1738  const_predicates.push_back(this);
1739  }
1740 }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
bool Analyzer::StringOper::hasNoneEncodedTextArg ( ) const
inline

Definition at line 1617 of file Analyzer.h.

References args_, and CHECK.

Referenced by anonymous_namespace{RelAlgExecutor.cpp}::TextEncodingCastCountVisitor::visitStringOper().

1617  {
1618  if (args_.empty()) {
1619  return false;
1620  }
1621  const auto& arg0_ti = args_[0]->get_type_info();
1622  if (!arg0_ti.is_string()) {
1623  return false;
1624  }
1625  if (arg0_ti.is_none_encoded_string()) {
1626  return true;
1627  }
1628  CHECK(arg0_ti.is_dict_encoded_string());
1629  return arg0_ti.getStringDictKey().isTransientDict();
1630  }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
#define CHECK(condition)
Definition: Logger.h:291

+ 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 4050 of file Analyzer.cpp.

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

4050  {
4051  auto comparator = Analyzer::ColumnVar::colvar_comp;
4052  std::set<const Analyzer::ColumnVar*,
4053  bool (*)(const Analyzer::ColumnVar*, const Analyzer::ColumnVar*)>
4054  colvar_set(comparator);
4055  collect_column_var(colvar_set, true);
4056  if (colvar_set.size() != 1UL) {
4057  return false;
4058  }
4059  auto col_expr_ptr = *colvar_set.begin();
4060  CHECK(col_expr_ptr);
4061  return col_expr_ptr->get_type_info().is_dict_encoded_string();
4062 }
static bool colvar_comp(const ColumnVar *l, const ColumnVar *r)
Definition: Analyzer.h:215
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.cpp:3421
#define CHECK(condition)
Definition: Logger.h:291

+ Here is the call graph for this function:

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

Implements Analyzer::Expr.

Definition at line 3648 of file Analyzer.cpp.

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

3648  {
3649  const auto rhs_string_oper = dynamic_cast<const StringOper*>(&rhs);
3650 
3651  if (!rhs_string_oper) {
3652  return false;
3653  }
3654 
3655  if (get_kind() != rhs_string_oper->get_kind()) {
3656  return false;
3657  }
3658  if (getArity() != rhs_string_oper->getArity()) {
3659  return false;
3660  }
3661 
3662  for (size_t i = 0; i < getArity(); ++i) {
3663  if (!(*getArg(i) == *(rhs_string_oper->getArg(i)))) {
3664  return false;
3665  }
3666  }
3667  if (chained_string_op_exprs_.size() !=
3668  rhs_string_oper->chained_string_op_exprs_.size()) {
3669  return false;
3670  }
3671  for (size_t i = 0; i < chained_string_op_exprs_.size(); ++i) {
3672  if (!(*(chained_string_op_exprs_[i]) ==
3673  *(rhs_string_oper->chained_string_op_exprs_[i]))) {
3674  return false;
3675  }
3676  }
3677  return true;
3678 }
size_t getArity() const
Definition: Analyzer.h:1548
std::vector< std::shared_ptr< Analyzer::Expr > > chained_string_op_exprs_
Definition: Analyzer.h:1695
StringOper(const SqlStringOpKind kind, const std::vector< std::shared_ptr< Analyzer::Expr >> &args)
Definition: Analyzer.h:1485
SqlStringOpKind get_kind() const
Definition: Analyzer.h:1546
const Expr * getArg(const size_t i) const
Definition: Analyzer.h:1562

+ Here is the call graph for this function:

bool Analyzer::StringOper::requiresPerRowTranslation ( ) const
inline

Definition at line 1578 of file Analyzer.h.

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

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

1578  {
1579  const auto& return_ti = get_type_info();
1580  if (return_ti.is_none_encoded_string() ||
1581  (return_ti.is_dict_encoded_string() &&
1582  return_ti.getStringDictKey().isTransientDict())) {
1583  return true;
1584  }
1585 
1586  // Anything that returns the transient dictionary by definition
1587  // (see StringOper::get_return_type) requires per-row translation,
1588  // but there is also a path with string->numeric functions (the output is
1589  // not a string) where we need to see if any of the inputs are none-encoded
1590  // or transient dictionary encoded, in which case we also need to do per-row
1591  // translation. The handling of that condition follows below.
1592 
1593  size_t num_var_str_args{0};
1594  for (const auto& arg : args_) {
1595  const auto arg_is_const = dynamic_cast<const Analyzer::Constant*>(arg.get());
1596  if (arg_is_const) {
1597  continue;
1598  }
1599  const auto& arg_ti = arg->get_type_info();
1600  if (arg_ti.is_none_encoded_string() ||
1601  (arg_ti.is_dict_encoded_string() &&
1602  arg_ti.getStringDictKey().isTransientDict())) {
1603  return true;
1604  }
1605  num_var_str_args++;
1606  }
1607  return num_var_str_args > 1UL;
1608  }
const SQLTypeInfo & get_type_info() const
Definition: Analyzer.h:79
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694

+ 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 1999 of file Analyzer.cpp.

References args_, and kind_.

2000  {
2001  std::vector<std::shared_ptr<Analyzer::Expr>> rewritten_args;
2002  for (const auto& arg : args_) {
2003  rewritten_args.emplace_back(arg->rewrite_agg_to_var(tlist));
2004  }
2005  return makeExpr<StringOper>(kind_, rewritten_args);
2006 }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
SqlStringOpKind kind_
Definition: Analyzer.h:1693
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 1990 of file Analyzer.cpp.

References args_, and kind_.

1991  {
1992  std::vector<std::shared_ptr<Analyzer::Expr>> rewritten_args;
1993  for (const auto& arg : args_) {
1994  rewritten_args.emplace_back(arg->rewrite_with_child_targetlist(tlist));
1995  }
1996  return makeExpr<StringOper>(kind_, rewritten_args);
1997 }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
SqlStringOpKind kind_
Definition: Analyzer.h:1693
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 1981 of file Analyzer.cpp.

References args_, and kind_.

1982  {
1983  std::vector<std::shared_ptr<Analyzer::Expr>> rewritten_args;
1984  for (const auto& arg : args_) {
1985  rewritten_args.emplace_back(arg->rewrite_with_targetlist(tlist));
1986  }
1987  return makeExpr<StringOper>(kind_, rewritten_args);
1988 }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
SqlStringOpKind kind_
Definition: Analyzer.h:1693
std::string Analyzer::StringOper::toString ( ) const
overridevirtual

Implements Analyzer::Expr.

Definition at line 3702 of file Analyzer.cpp.

References args_, and kind_.

Referenced by check_operand_types().

3702  {
3703  std::string str{"(" + ::toString(kind_) + " "};
3704  for (const auto& arg : args_) {
3705  str += arg->toString();
3706  }
3707  str += ")";
3708  return str;
3709 }
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
SqlStringOpKind kind_
Definition: Analyzer.h:1693
std::string toString() const override
Definition: Analyzer.cpp:3702

+ Here is the caller graph for this function:

Member Data Documentation

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

Definition at line 1695 of file Analyzer.h.

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

SqlStringOpKind Analyzer::StringOper::kind_
private

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