32 auto rewritten_exe_unit_for_agg_on_gby_col =
40 return ra_exe_unit_in;
43 return ra_exe_unit_in;
46 std::list<std::shared_ptr<Analyzer::Expr>> quals;
47 quals.insert(quals.end(), ra_exe_unit_in.
quals.begin(), ra_exe_unit_in.
quals.end());
50 for (
const auto& join_condition_in : ra_exe_unit_in.
join_quals) {
53 for (
const auto& join_qual_expr_in : join_condition_in.quals) {
55 if (new_overlaps_quals) {
56 const auto& overlaps_quals = *new_overlaps_quals;
59 join_condition.quals.insert(join_condition.quals.end(),
60 overlaps_quals.join_quals.begin(),
61 overlaps_quals.join_quals.end());
64 join_condition.quals.insert(join_condition.quals.end(),
65 overlaps_quals.quals.begin(),
66 overlaps_quals.quals.end());
68 join_condition.quals.push_back(join_qual_expr_in);
71 join_condition_per_nesting_level.push_back(join_condition);
77 join_condition_per_nesting_level,
93 return ra_exe_unit_in;
96 return ra_exe_unit_in;
99 return ra_exe_unit_in;
101 if (ra_exe_unit_in.
quals.size() != 1) {
102 return ra_exe_unit_in;
110 if (!in_vals || in_vals->get_value_list().empty()) {
111 return ra_exe_unit_in;
113 for (
const auto& in_val : in_vals->get_value_list()) {
114 if (!std::dynamic_pointer_cast<Analyzer::Constant>(in_val)) {
118 if (dynamic_cast<const Analyzer::CaseExpr*>(in_vals->get_arg())) {
119 return ra_exe_unit_in;
123 auto it = std::find_if(
126 [&in_val_cv](std::shared_ptr<Analyzer::Expr> groupby_expr) {
127 if (
auto groupby_cv =
128 std::dynamic_pointer_cast<Analyzer::ColumnVar>(groupby_expr)) {
129 return *in_val_cv == *groupby_cv.get();
136 return ra_exe_unit_in;
145 const std::shared_ptr<Analyzer::CaseExpr> case_expr,
147 std::list<std::shared_ptr<Analyzer::Expr>> new_groupby_list;
148 std::vector<Analyzer::Expr*> new_target_exprs;
150 size_t groupby_idx{0};
152 for (
const auto& group_expr : ra_exe_unit_in.
groupby_exprs) {
155 if (*group_expr == *in_vals->
get_arg()) {
161 const size_t range_sz = expr_range.
getIntMax() - expr_range.getIntMin() + 1;
166 new_groupby_list.push_back(case_expr);
167 for (
size_t i = 0; i < ra_exe_unit_in.
target_exprs.size(); ++i) {
169 if (*target == *in_vals->
get_arg()) {
170 auto var_case_expr = makeExpr<Analyzer::Var>(
173 new_target_exprs.push_back(var_case_expr.get());
175 new_target_exprs.push_back(target);
180 new_groupby_list.push_back(group_expr);
185 return ra_exe_unit_in;
190 ra_exe_unit_in.
quals,
205 std::list<std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>
209 auto case_cond = makeExpr<Analyzer::BinOper>(
211 auto in_val_copy = in_val->deep_copy();
212 auto ti = in_val_copy->get_type_info();
214 ti.set_comp_param(0);
216 in_val_copy->set_type_info(ti);
217 case_expr_list.emplace_back(case_cond, in_val_copy);
221 auto else_expr = case_expr_list.front().second;
222 return makeExpr<Analyzer::CaseExpr>(
223 case_expr_list.front().second->get_type_info(),
false, case_expr_list, else_expr);
226 std::shared_ptr<Analyzer::CaseExpr>
228 std::shared_ptr<Analyzer::Expr> expr)
const {
229 std::list<std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>
235 const auto then_constant = makeExpr<Analyzer::Constant>(
kBIGINT,
false, then_d);
236 case_expr_list.emplace_back(is_not_null, then_constant);
239 const auto else_constant = makeExpr<Analyzer::Constant>(
kBIGINT,
false, else_d);
240 auto case_expr = makeExpr<Analyzer::CaseExpr>(
241 then_constant->get_type_info(),
false, case_expr_list, else_constant);
251 return string_id > max_valid_int_value<int8_t>();
253 return string_id > max_valid_int_value<int16_t>();
255 return string_id > max_valid_int_value<int32_t>();
271 std::shared_ptr<Analyzer::Expr> column_to_update)
const {
277 throw std::runtime_error(
"Update via join not yet supported for temporary tables.");
280 auto new_column_value = ra_exe_unit_in.
target_exprs.front()->deep_copy();
281 const auto& new_column_ti = new_column_value->get_type_info();
282 if (column_to_update->get_type_info().is_dict_encoded_string()) {
283 CHECK(new_column_ti.is_dict_encoded_string());
284 if (new_column_ti.get_comp_param() > 0 &&
285 new_column_ti.get_comp_param() !=
286 column_to_update->get_type_info().get_comp_param()) {
287 throw std::runtime_error(
288 "Updating a dictionary encoded string using another dictionary encoded string "
289 "column is not yet supported, unless both columns share dictionaries.");
291 if (
auto uoper = dynamic_cast<Analyzer::UOper*>(new_column_value.get())) {
292 if (uoper->get_optype() ==
kCAST &&
294 const auto original_constant_expr =
296 CHECK(original_constant_expr);
297 CHECK(original_constant_expr->get_type_info().is_string());
303 CHECK(column_to_update->get_type_info().is_dict_encoded_string());
304 const auto dict_id = column_to_update->get_type_info().get_comp_param();
305 std::map<int, StringDictionary*> string_dicts;
306 const auto dd = cat->getMetadataForDict(dict_id,
true);
308 auto string_dict = dd->stringDict;
312 string_dict->getOrAdd(*original_constant_expr->get_constval().stringval);
314 throw std::runtime_error(
315 "Ran out of space in dictionary, cannot update column with dictionary "
316 "encoded string value. Dictionary ID: " +
319 if (string_id == inline_int_null_value<int32_t>()) {
328 new std::string(*original_constant_expr->get_constval().stringval);
329 Datum new_string_datum{datum};
332 makeExpr<Analyzer::Constant>(column_to_update->get_type_info(),
333 original_constant_expr->get_is_null(),
337 auto row_set_mem_owner =
executor_->getRowSetMemoryOwner();
338 CHECK(row_set_mem_owner);
339 auto& str_dict_generations = row_set_mem_owner->getStringDictionaryGenerations();
340 if (str_dict_generations.getGeneration(dict_id) > -1) {
341 str_dict_generations.updateGeneration(dict_id,
342 string_dict->storageEntryCount());
346 str_dict_generations.setGeneration(dict_id, string_dict->storageEntryCount());
354 std::shared_ptr<Analyzer::Expr> filter;
355 std::vector<std::shared_ptr<Analyzer::Expr>> filter_exprs;
356 filter_exprs.insert(filter_exprs.end(),
360 filter_exprs.end(), ra_exe_unit_in.
quals.begin(), ra_exe_unit_in.
quals.end());
362 if (filter_exprs.size() > 0) {
363 std::list<std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>
365 if (filter_exprs.size() == 1) {
366 filter = filter_exprs.front();
369 std::next(filter_exprs.begin()),
371 filter_exprs.front(),
372 [](
const std::shared_ptr<Analyzer::Expr>
a,
373 const std::shared_ptr<Analyzer::Expr> b) {
374 CHECK_EQ(a->get_type_info().get_type(), b->get_type_info().get_type());
375 return makeExpr<Analyzer::BinOper>(a->get_type_info().get_type(),
382 auto when_expr = filter;
383 case_expr_list.emplace_back(std::make_pair(when_expr, new_column_value));
386 auto col_to_update_var =
388 CHECK(col_to_update_var);
389 auto col_to_update_desc =
390 std::make_shared<const InputColDescriptor>(col_to_update_var->get_column_id(),
391 col_to_update_var->get_table_id(),
392 col_to_update_var->get_rte_idx());
393 auto existing_col_desc_it = std::find_if(
394 input_col_descs.begin(),
395 input_col_descs.end(),
396 [&col_to_update_desc](
const std::shared_ptr<const InputColDescriptor>& in) {
397 return *in == *col_to_update_desc;
399 if (existing_col_desc_it == input_col_descs.end()) {
400 input_col_descs.push_back(col_to_update_desc);
408 std::vector<Analyzer::Expr*> target_exprs;
429 return rewritten_exe_unit;
438 std::shared_ptr<Analyzer::ColumnVar> delete_column)
const {
445 throw std::runtime_error(
"Delete via join not yet supported for temporary tables.");
450 const auto deleted_constant =
451 makeExpr<Analyzer::Constant>(delete_column->get_type_info(),
false, true_datum);
455 std::shared_ptr<Analyzer::Expr> filter;
456 std::vector<std::shared_ptr<Analyzer::Expr>> filter_exprs;
457 filter_exprs.insert(filter_exprs.end(),
461 filter_exprs.end(), ra_exe_unit_in.
quals.begin(), ra_exe_unit_in.
quals.end());
463 if (filter_exprs.size() > 0) {
464 std::list<std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>
466 if (filter_exprs.size() == 1) {
467 filter = filter_exprs.front();
470 std::next(filter_exprs.begin()),
472 filter_exprs.front(),
473 [](
const std::shared_ptr<Analyzer::Expr>
a,
474 const std::shared_ptr<Analyzer::Expr> b) {
475 CHECK_EQ(a->get_type_info().get_type(), b->get_type_info().get_type());
476 return makeExpr<Analyzer::BinOper>(a->get_type_info().get_type(),
483 std::shared_ptr<Analyzer::Expr> column_to_update{
nullptr};
484 auto when_expr = filter;
485 case_expr_list.emplace_back(std::make_pair(when_expr, deleted_constant));
489 auto delete_col_desc_it = std::find_if(
490 input_col_descs.begin(),
491 input_col_descs.end(),
492 [&delete_column](
const std::shared_ptr<const InputColDescriptor>& in) {
493 return in->getColId() == delete_column->get_column_id();
495 CHECK(delete_col_desc_it == input_col_descs.end());
496 auto delete_col_desc =
497 std::make_shared<const InputColDescriptor>(delete_column->get_column_id(),
498 delete_column->get_table_id(),
499 delete_column->get_rte_idx());
500 input_col_descs.push_back(delete_col_desc);
504 auto delete_col_desc =
505 std::make_shared<const InputColDescriptor>(delete_column->get_column_id(),
506 delete_column->get_table_id(),
507 delete_column->get_rte_idx());
508 input_col_descs.push_back(delete_col_desc);
512 std::vector<Analyzer::Expr*> target_exprs;
533 return rewritten_exe_unit;
537 const std::list<std::shared_ptr<Analyzer::Expr>>& groupby_exprs)
const {
538 std::set<size_t> gby_col_exprs_hash;
539 for (
auto gby_expr : groupby_exprs) {
540 if (
auto gby_col_var = std::dynamic_pointer_cast<Analyzer::ColumnVar>(gby_expr)) {
541 gby_col_exprs_hash.insert(boost::hash_value(gby_col_var->toString()));
546 return {
true, gby_col_exprs_hash};
554 if (agg_expr->get_arg()) {
556 auto agg_expr_hash = boost::hash_value(agg_expr->get_arg()->toString());
559 if (check_precond.second.count(agg_expr_hash)) {
565 if (!check_precond.first) {
569 return ra_exe_unit_in;
572 std::vector<Analyzer::Expr*> new_target_exprs;
574 bool rewritten =
false;
575 if (
auto agg_expr = dynamic_cast<Analyzer::AggExpr*>(expr)) {
576 if (is_expr_on_gby_col(agg_expr)) {
577 auto target_expr = agg_expr->get_arg();
580 if (target_expr && target_expr->get_type_info().get_type() !=
SQLTypes::kFLOAT) {
581 switch (agg_expr->get_aggtype()) {
585 !agg_expr->get_is_distinct()) {
590 new_target_exprs.push_back(case_expr.get());
602 auto agg_expr_ti = agg_expr->get_type_info();
603 auto target_expr = agg_expr->get_own_arg();
604 if (agg_expr_ti != target_expr->get_type_info()) {
605 target_expr = target_expr->add_cast(agg_expr_ti);
607 new_target_exprs.push_back(target_expr.get());
619 new_target_exprs.push_back(expr);
626 ra_exe_unit_in.
quals,
640 return rewritten_exe_unit;
std::vector< Analyzer::Expr * > target_exprs
static std::shared_ptr< Analyzer::Expr > normalize(const std::list< std::pair< std::shared_ptr< Analyzer::Expr >, std::shared_ptr< Analyzer::Expr >>> &, const std::shared_ptr< Analyzer::Expr >, const Executor *executor=nullptr)
HOST DEVICE int get_size() const
size_t g_constrained_by_in_threshold
QueryPlanHash query_plan_dag_hash
const std::optional< bool > union_all
std::vector< InputDescriptor > input_descs
Constants for Builtin SQL Types supported by OmniSci.
std::vector< JoinCondition > JoinQualsPerNestingLevel
const std::list< std::shared_ptr< Analyzer::Expr > > groupby_exprs
Analyzer::ExpressionPtr rewrite_expr(const Analyzer::Expr *expr)
bool g_enable_overlaps_hashjoin
CONSTEXPR DEVICE bool is_null(const T &value)
Classes representing a parse tree.
RelAlgExecutionUnit rewrite(const RelAlgExecutionUnit &ra_exe_unit_in) const
const JoinQualsPerNestingLevel join_quals
std::pair< bool, std::set< size_t > > is_all_groupby_exprs_are_col_var(const std::list< std::shared_ptr< Analyzer::Expr >> &groupby_exprs) const
TableIdToNodeMap table_id_to_node_map
RelAlgExecutionUnit rewriteOverlapsJoin(const RelAlgExecutionUnit &ra_exe_unit_in) const
DEVICE auto accumulate(ARGS &&...args)
boost::optional< OverlapsJoinConjunction > rewrite_overlaps_conjunction(const std::shared_ptr< Analyzer::Expr > expr)
ExpressionRange getExpressionRange(const Analyzer::BinOper *expr, const std::vector< InputTableInfo > &query_infos, const Executor *, boost::optional< std::list< std::shared_ptr< Analyzer::Expr >>> simple_quals)
const std::shared_ptr< Analyzer::Estimator > estimator
bool check_string_id_overflow(const int32_t string_id, const SQLTypeInfo &ti)
RelAlgExecutionUnit rewriteColumnarUpdate(const RelAlgExecutionUnit &ra_exe_unit_in, std::shared_ptr< Analyzer::Expr > column_to_update) const
const std::list< std::shared_ptr< Analyzer::Expr > > & get_value_list() const
virtual std::shared_ptr< Analyzer::Expr > deep_copy() const =0
const std::vector< InputTableInfo > & query_infos_
std::list< std::shared_ptr< Analyzer::Expr > > quals
int64_t getIntMax() const
RegisteredQueryHint query_hint
int64_t inline_fixed_encoding_null_val(const SQL_TYPE_INFO &ti)
std::shared_ptr< Analyzer::CaseExpr > generateCaseExprForCountDistinctOnGroupByCol(std::shared_ptr< Analyzer::Expr > expr) const
std::shared_ptr< const query_state::QueryState > query_state
std::list< std::shared_ptr< const InputColDescriptor > > input_col_descs
RelAlgExecutionUnit rewriteColumnarDelete(const RelAlgExecutionUnit &ra_exe_unit_in, std::shared_ptr< Analyzer::ColumnVar > delete_column) const
static std::shared_ptr< Analyzer::CaseExpr > generateCaseForDomainValues(const Analyzer::InValues *)
RelAlgExecutionUnit rewriteConstrainedByIn(const RelAlgExecutionUnit &ra_exe_unit_in) const
RelAlgExecutionUnit rewriteAggregateOnGroupByColumn(const RelAlgExecutionUnit &ra_exe_unit_in) const
const Expr * get_arg() const
std::list< std::shared_ptr< Analyzer::Expr > > simple_quals
RelAlgExecutionUnit rewriteConstrainedByInImpl(const RelAlgExecutionUnit &ra_exe_unit_in, const std::shared_ptr< Analyzer::CaseExpr >, const Analyzer::InValues *) const
std::vector< std::shared_ptr< Analyzer::Expr > > target_exprs_owned_
HashTableBuildDagMap hash_table_build_plan_dag