#include <TransientStringLiteralsVisitor.h>

Inheritance diagram for TransientStringLiteralsVisitor:

Collaboration diagram for TransientStringLiteralsVisitor:

Public Member Functions
	TransientStringLiteralsVisitor (StringDictionaryProxy sdp, Executor executor)

void *	visitConstant (const Analyzer::Constant *constant) const override

void *	visitUOper (const Analyzer::UOper *uoper) const override

void *	visitStringOper (const Analyzer::StringOper *string_oper) const override

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

Protected Member Functions
void *	defaultResult () const override

Protected Member Functions inherited from ScalarExprVisitor< void * >
virtual void *	visitVar (const Analyzer::Var *) const

virtual void *	visitColumnVar (const Analyzer::ColumnVar *) const

virtual void *	visitColumnVarTuple (const Analyzer::ExpressionTuple *) const

virtual void *	visitBinOper (const Analyzer::BinOper *bin_oper) const

virtual void *	visitGeoExpr (const Analyzer::GeoExpr *geo_expr) const

virtual void *	visitInValues (const Analyzer::InValues *in_values) const

virtual void *	visitInIntegerSet (const Analyzer::InIntegerSet *in_integer_set) const

virtual void *	visitCharLength (const Analyzer::CharLengthExpr *char_length) const

virtual void *	visitKeyForString (const Analyzer::KeyForStringExpr *key_for_string) const

virtual void *	visitSampleRatio (const Analyzer::SampleRatioExpr *sample_ratio) const

virtual void *	visitCardinality (const Analyzer::CardinalityExpr *cardinality) const

virtual void *	visitLikeExpr (const Analyzer::LikeExpr *like) const

virtual void *	visitRegexpExpr (const Analyzer::RegexpExpr *regexp) const

virtual void *	visitWidthBucket (const Analyzer::WidthBucketExpr *width_bucket_expr) const

virtual void *	visitMLPredict (const Analyzer::MLPredictExpr *ml_predict_expr) const

virtual void *	visitPCAProject (const Analyzer::PCAProjectExpr *pca_project_expr) const

virtual void *	visitCaseExpr (const Analyzer::CaseExpr *case_) const

virtual void *	visitDatetruncExpr (const Analyzer::DatetruncExpr *datetrunc) const

virtual void *	visitExtractExpr (const Analyzer::ExtractExpr *extract) const

virtual void *	visitFunctionOperWithCustomTypeHandling (const Analyzer::FunctionOperWithCustomTypeHandling *func_oper) const

virtual void *	visitArrayOper (Analyzer::ArrayExpr const *array_expr) const

virtual void *	visitGeoUOper (const Analyzer::GeoUOper *geo_expr) const

virtual void *	visitGeoBinOper (const Analyzer::GeoBinOper *geo_expr) const

virtual void *	visitFunctionOper (const Analyzer::FunctionOper *func_oper) const

virtual void *	visitWindowFunction (const Analyzer::WindowFunction *window_func) const

virtual void *	visitDatediffExpr (const Analyzer::DatediffExpr *datediff) const

virtual void *	visitDateaddExpr (const Analyzer::DateaddExpr *dateadd) const

virtual void *	visitLikelihood (const Analyzer::LikelihoodExpr *likelihood) const

virtual void *	visitOffsetInFragment (const Analyzer::OffsetInFragment *) const

virtual void *	visitAggExpr (const Analyzer::AggExpr *agg) const

virtual void *	visitRangeJoinOper (const Analyzer::RangeOper *range_oper) const

virtual void *	aggregateResult (const void &aggregate, const void &next_result) const

virtual void	visitBegin () const

Private Attributes
StringDictionaryProxy *	sdp_

Executor *	executor_

bool	parent_feeds_sdp_ {false}

Detailed Description

Definition at line 24 of file TransientStringLiteralsVisitor.h.

Constructor & Destructor Documentation

TransientStringLiteralsVisitor::TransientStringLiteralsVisitor	(	StringDictionaryProxy *	sdp,
		Executor *	executor
	)

inline

Definition at line 26 of file TransientStringLiteralsVisitor.h.

References CHECK.

       : sdp_(sdp), executor_(executor) {
     CHECK(sdp);
   }

Member Function Documentation

void* TransientStringLiteralsVisitor::defaultResult ( ) const

inlineoverrideprotectedvirtual

Reimplemented from ScalarExprVisitor< void * >.

Definition at line 159 of file TransientStringLiteralsVisitor.h.

Referenced by visitConstant(), visitStringOper(), and visitUOper().

159 { return nullptr; }

Here is the caller graph for this function:

void* TransientStringLiteralsVisitor::visitConstant ( const Analyzer::Constant * constant ) const

inlineoverridevirtual

Reimplemented from ScalarExprVisitor< void * >.

Definition at line 31 of file TransientStringLiteralsVisitor.h.

References CHECK, defaultResult(), Analyzer::Constant::get_constval(), Analyzer::Constant::get_is_null(), Analyzer::Expr::get_type_info(), StringDictionaryProxy::getOrAddTransient(), SQLTypeInfo::is_string(), sdp_, and Datum::stringval.

                                                                        {
     if (constant->get_type_info().is_string() && !constant->get_is_null()) {
       CHECK(constant->get_constval().stringval);
       sdp_->getOrAddTransient(*constant->get_constval().stringval);
     }
     return defaultResult();
   }

Here is the call graph for this function:

void* TransientStringLiteralsVisitor::visitStringOper ( const Analyzer::StringOper * string_oper ) const

inlineoverridevirtual

Reimplemented from ScalarExprVisitor< void * >.

Definition at line 89 of file TransientStringLiteralsVisitor.h.

References StringOps_Namespace::apply_string_op_to_literals(), CHECK, CHECK_EQ, CHECK_GE, defaultResult(), executor_, Analyzer::StringOper::get_kind(), Analyzer::Expr::get_type_info(), Analyzer::StringOper::getArg(), Analyzer::StringOper::getArity(), Analyzer::StringOper::getChainedStringOpExprs(), StringDictionaryProxy::getDictKey(), Analyzer::StringOper::getLiteralArgs(), Analyzer::StringOper::getLiteralsArity(), Analyzer::StringOper::getNonLiteralsArity(), StringDictionaryProxy::getOrAddTransient(), Executor::getRowSetMemoryOwner(), Executor::getStringProxyTranslationMap(), SQLTypeInfo::is_string(), parent_feeds_sdp_, sdp_, RowSetMemoryOwner::SOURCE_UNION, and ScalarExprVisitor< void * >::visit().

                                                                               {
     CHECK_GE(string_oper->getArity(), 1UL);
     const auto str_operand = string_oper->getArg(0);
     const auto& string_oper_ti = string_oper->get_type_info();
     const auto& str_operand_ti = str_operand->get_type_info();
     const auto string_oper_kind = string_oper->get_kind();
     if (!string_oper_ti.is_string() || !str_operand_ti.is_string()) {
       return defaultResult();
     }
     if (string_oper->getNonLiteralsArity() >= 2UL) {
       return defaultResult();
     }
     const bool parent_feeds_sdp_already_set = parent_feeds_sdp_;
     const bool outputs_target_sdp =
         string_oper_ti.getStringDictKey() == sdp_->getDictKey();
     if (string_oper_ti.is_dict_encoded_string() &&
         str_operand_ti.is_dict_encoded_string() &&
         (parent_feeds_sdp_ || outputs_target_sdp)) {
       parent_feeds_sdp_ = true;
       visit(str_operand);
       if (!parent_feeds_sdp_already_set) {
         parent_feeds_sdp_ = false;
       }
       // Todo(todd): Dedup the code to get string_op_infos from the same
       // in StringOpsIR.cpp (needs thought as Analyzer and StringOps
       // deliberately are oblivious to each other)
 
       std::vector<StringOps_Namespace::StringOpInfo> string_op_infos;
       const auto chained_string_op_exprs = string_oper->getChainedStringOpExprs();
       for (const auto& chained_string_op_expr : chained_string_op_exprs) {
         auto chained_string_op =
             dynamic_cast<const Analyzer::StringOper*>(chained_string_op_expr.get());
         CHECK(chained_string_op);
         StringOps_Namespace::StringOpInfo string_op_info(
             chained_string_op->get_kind(),
             chained_string_op->get_type_info(),
             chained_string_op->getLiteralArgs());
         string_op_infos.emplace_back(string_op_info);
       }
 
       executor_->getStringProxyTranslationMap(
           str_operand_ti.getStringDictKey(),
           string_oper_ti.getStringDictKey(),
           RowSetMemoryOwner::StringTranslationType::SOURCE_UNION,
           string_op_infos,
           executor_->getRowSetMemoryOwner(),
           true);  // with_generation
     } else if ((parent_feeds_sdp_ || outputs_target_sdp) &&
                (string_oper->getLiteralsArity() == string_oper->getArity())) {
       // This is likely dead code due to ExpressionRewrite of all-literal string ops
       // (meaning when this visitor gets to a string op with all literal args it
       // (would have already been rewritten as a literal string)
       // Todo(todd): Verify and remove if so
       const StringOps_Namespace::StringOpInfo string_op_info(
           string_oper_kind, string_oper->get_type_info(), string_oper->getLiteralArgs());
       CHECK_EQ(string_op_info.numLiterals(), string_oper->getArity());
       const auto str_result_and_null_status =
           StringOps_Namespace::apply_string_op_to_literals(string_op_info);
       if (string_oper->get_type_info().is_string() &&
           !str_result_and_null_status.second &&
           !str_result_and_null_status.first
                .empty()) {  // Todo(todd): Is there a central/non-magic function/constant
                             // to determine if a none-encoded string is null
         sdp_->getOrAddTransient(str_result_and_null_status.first);
       }
     }
     return defaultResult();
   }

Here is the call graph for this function:

void* TransientStringLiteralsVisitor::visitUOper ( const Analyzer::UOper * uoper ) const

inlineoverridevirtual

Reimplemented from ScalarExprVisitor< void * >.

Definition at line 50 of file TransientStringLiteralsVisitor.h.

References defaultResult(), executor_, Analyzer::UOper::get_operand(), Analyzer::UOper::get_optype(), Analyzer::Expr::get_type_info(), StringDictionaryProxy::getDictKey(), Executor::getRowSetMemoryOwner(), Executor::getStringProxyTranslationMap(), kCAST, parent_feeds_sdp_, sdp_, RowSetMemoryOwner::SOURCE_UNION, and ScalarExprVisitor< void * >::visit().

                                                               {
     const auto& uoper_ti = uoper->get_type_info();
     const auto& operand_ti = uoper->get_operand()->get_type_info();
     if (!(uoper->get_optype() == kCAST && uoper_ti.is_dict_encoded_string())) {
       return defaultResult();
     }
     const bool outputs_target_sdp = uoper_ti.getStringDictKey() == sdp_->getDictKey();
 
     if (!parent_feeds_sdp_ && !outputs_target_sdp) {
       // If we are not casting to our dictionary (sdp_)
       return defaultResult();
     }
     if (uoper_ti.is_dict_intersection()) {
       // Intersection translations don't add transients to the dest proxy,
       // and hence can be ignored for the purposes of populating transients
       return defaultResult();
     }
     const bool parent_feeds_sdp_already_set = parent_feeds_sdp_;
     parent_feeds_sdp_ = true;
 
     visit(uoper->get_operand());
 
     if (!parent_feeds_sdp_already_set) {
       parent_feeds_sdp_ = false;
     }
 
     if (operand_ti.is_dict_encoded_string() &&
         uoper_ti.getStringDictKey() != operand_ti.getStringDictKey()) {
       executor_->getStringProxyTranslationMap(
           operand_ti.getStringDictKey(),
           uoper_ti.getStringDictKey(),
           RowSetMemoryOwner::StringTranslationType::SOURCE_UNION,
           {},
           executor_->getRowSetMemoryOwner(),
           true);  // with_generation
     }
     return defaultResult();
   }