OmniSciDB  c1a53651b2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CompareIR.cpp
Go to the documentation of this file.
1 /*
2  * Copyright 2022 HEAVY.AI, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "CodeGenerator.h"
18 #include "Execute.h"
19 
20 #include <typeinfo>
21 
22 #include "../Parser/ParserNode.h"
23 
24 namespace {
25 
26 llvm::CmpInst::Predicate llvm_icmp_pred(const SQLOps op_type) {
27  switch (op_type) {
28  case kEQ:
29  return llvm::ICmpInst::ICMP_EQ;
30  case kNE:
31  return llvm::ICmpInst::ICMP_NE;
32  case kLT:
33  return llvm::ICmpInst::ICMP_SLT;
34  case kGT:
35  return llvm::ICmpInst::ICMP_SGT;
36  case kLE:
37  return llvm::ICmpInst::ICMP_SLE;
38  case kGE:
39  return llvm::ICmpInst::ICMP_SGE;
40  default:
41  abort();
42  }
43 }
44 
45 std::string icmp_name(const SQLOps op_type) {
46  switch (op_type) {
47  case kEQ:
48  return "eq";
49  case kNE:
50  return "ne";
51  case kLT:
52  return "lt";
53  case kGT:
54  return "gt";
55  case kLE:
56  return "le";
57  case kGE:
58  return "ge";
59  default:
60  abort();
61  }
62 }
63 
64 std::string icmp_arr_name(const SQLOps op_type) {
65  switch (op_type) {
66  case kEQ:
67  return "eq";
68  case kNE:
69  return "ne";
70  case kLT:
71  return "gt";
72  case kGT:
73  return "lt";
74  case kLE:
75  return "ge";
76  case kGE:
77  return "le";
78  default:
79  abort();
80  }
81 }
82 
83 llvm::CmpInst::Predicate llvm_fcmp_pred(const SQLOps op_type) {
84  switch (op_type) {
85  case kEQ:
86  return llvm::CmpInst::FCMP_OEQ;
87  case kNE:
88  return llvm::CmpInst::FCMP_ONE;
89  case kLT:
90  return llvm::CmpInst::FCMP_OLT;
91  case kGT:
92  return llvm::CmpInst::FCMP_OGT;
93  case kLE:
94  return llvm::CmpInst::FCMP_OLE;
95  case kGE:
96  return llvm::CmpInst::FCMP_OGE;
97  default:
98  abort();
99  }
100 }
101 
102 } // namespace
103 
104 namespace {
105 
106 std::string string_cmp_func(const SQLOps optype) {
107  switch (optype) {
108  case kLT:
109  return "string_lt";
110  case kLE:
111  return "string_le";
112  case kGT:
113  return "string_gt";
114  case kGE:
115  return "string_ge";
116  case kEQ:
117  return "string_eq";
118  case kNE:
119  return "string_ne";
120  default:
121  abort();
122  }
123 }
124 
125 std::shared_ptr<Analyzer::BinOper> lower_bw_eq(const Analyzer::BinOper* bw_eq) {
126  const auto eq_oper =
127  std::make_shared<Analyzer::BinOper>(bw_eq->get_type_info(),
128  bw_eq->get_contains_agg(),
129  kEQ,
130  bw_eq->get_qualifier(),
131  bw_eq->get_own_left_operand(),
132  bw_eq->get_own_right_operand());
133  const auto lhs_is_null =
134  std::make_shared<Analyzer::UOper>(kBOOLEAN, kISNULL, bw_eq->get_own_left_operand());
135  const auto rhs_is_null = std::make_shared<Analyzer::UOper>(
137  const auto both_are_null =
138  Parser::OperExpr::normalize(kAND, kONE, lhs_is_null, rhs_is_null);
139  const auto bw_eq_oper = std::dynamic_pointer_cast<Analyzer::BinOper>(
140  Parser::OperExpr::normalize(kOR, kONE, eq_oper, both_are_null));
141  CHECK(bw_eq_oper);
142  return bw_eq_oper;
143 }
144 
145 std::shared_ptr<Analyzer::BinOper> make_eq(const std::shared_ptr<Analyzer::Expr>& lhs,
146  const std::shared_ptr<Analyzer::Expr>& rhs,
147  const SQLOps optype) {
148  CHECK(IS_EQUIVALENCE(optype));
149  // Sides of a tuple equality are stripped of cast operators to simplify the logic
150  // in the hash table construction algorithm. Add them back here.
151  auto eq_oper = std::dynamic_pointer_cast<Analyzer::BinOper>(
152  Parser::OperExpr::normalize(optype, kONE, lhs, rhs));
153  CHECK(eq_oper);
154  return optype == kBW_EQ ? lower_bw_eq(eq_oper.get()) : eq_oper;
155 }
156 
157 // Convert a column tuple equality expression back to a conjunction of comparisons
158 // so that it can be handled by the regular code generation methods.
159 std::shared_ptr<Analyzer::BinOper> lower_multicol_compare(
160  const Analyzer::BinOper* multicol_compare) {
161  const auto left_tuple_expr = dynamic_cast<const Analyzer::ExpressionTuple*>(
162  multicol_compare->get_left_operand());
163  const auto right_tuple_expr = dynamic_cast<const Analyzer::ExpressionTuple*>(
164  multicol_compare->get_right_operand());
165  CHECK(left_tuple_expr && right_tuple_expr);
166  const auto& left_tuple = left_tuple_expr->getTuple();
167  const auto& right_tuple = right_tuple_expr->getTuple();
168  CHECK_EQ(left_tuple.size(), right_tuple.size());
169  CHECK_GT(left_tuple.size(), size_t(1));
170  auto acc =
171  make_eq(left_tuple.front(), right_tuple.front(), multicol_compare->get_optype());
172  for (size_t i = 1; i < left_tuple.size(); ++i) {
173  auto crt = make_eq(left_tuple[i], right_tuple[i], multicol_compare->get_optype());
174  const bool not_null =
175  acc->get_type_info().get_notnull() && crt->get_type_info().get_notnull();
176  acc = makeExpr<Analyzer::BinOper>(
177  SQLTypeInfo(kBOOLEAN, not_null), false, kAND, kONE, acc, crt);
178  }
179  return acc;
180 }
181 
183  auto lhs_cv = dynamic_cast<const Analyzer::ColumnVar*>(bin_oper->get_left_operand());
184  auto rhs_cv = dynamic_cast<const Analyzer::ColumnVar*>(bin_oper->get_right_operand());
185  auto comp_op = IS_COMPARISON(bin_oper->get_optype());
186  if (lhs_cv && rhs_cv && comp_op) {
187  auto lhs_ti = lhs_cv->get_type_info();
188  auto rhs_ti = rhs_cv->get_type_info();
189  if (lhs_ti.is_array() && rhs_ti.is_array()) {
190  throw std::runtime_error(
191  "Comparing two full array columns is not supported yet. Please consider "
192  "rewriting the full array comparison to a comparison between indexed array "
193  "columns "
194  "(i.e., arr1[1] {<, <=, >, >=} arr2[1]).");
195  }
196  }
197  auto lhs_bin_oper =
198  dynamic_cast<const Analyzer::BinOper*>(bin_oper->get_left_operand());
199  auto rhs_bin_oper =
200  dynamic_cast<const Analyzer::BinOper*>(bin_oper->get_right_operand());
201  // we can do (non-)equivalence check of two encoded string
202  // even if they are (indexed) array cols
203  auto theta_comp = IS_COMPARISON(bin_oper->get_optype()) &&
204  !IS_EQUIVALENCE(bin_oper->get_optype()) &&
205  bin_oper->get_optype() != SQLOps::kNE;
206  if (lhs_bin_oper && rhs_bin_oper && theta_comp &&
207  lhs_bin_oper->get_optype() == SQLOps::kARRAY_AT &&
208  rhs_bin_oper->get_optype() == SQLOps::kARRAY_AT) {
209  auto lhs_arr_cv =
210  dynamic_cast<const Analyzer::ColumnVar*>(lhs_bin_oper->get_left_operand());
211  auto lhs_arr_idx =
212  dynamic_cast<const Analyzer::Constant*>(lhs_bin_oper->get_right_operand());
213  auto rhs_arr_cv =
214  dynamic_cast<const Analyzer::ColumnVar*>(rhs_bin_oper->get_left_operand());
215  auto rhs_arr_idx =
216  dynamic_cast<const Analyzer::Constant*>(rhs_bin_oper->get_right_operand());
217  if (lhs_arr_cv && rhs_arr_cv && lhs_arr_idx && rhs_arr_idx &&
218  ((lhs_arr_cv->get_type_info().is_array() &&
219  lhs_arr_cv->get_type_info().get_subtype() == SQLTypes::kTEXT) ||
220  (rhs_arr_cv->get_type_info().is_string() &&
221  rhs_arr_cv->get_type_info().get_subtype() == SQLTypes::kTEXT))) {
222  throw std::runtime_error(
223  "Comparison between string array columns is not supported yet.");
224  }
225  }
226 }
227 
228 } // namespace
229 
230 llvm::Value* CodeGenerator::codegenCmp(const Analyzer::BinOper* bin_oper,
231  const CompilationOptions& co) {
233  const auto qualifier = bin_oper->get_qualifier();
234  const auto lhs = bin_oper->get_left_operand();
235  const auto rhs = bin_oper->get_right_operand();
236  if (dynamic_cast<const Analyzer::ExpressionTuple*>(lhs)) {
237  CHECK(dynamic_cast<const Analyzer::ExpressionTuple*>(rhs));
238  const auto lowered = lower_multicol_compare(bin_oper);
239  const auto lowered_lvs = codegen(lowered.get(), true, co);
240  CHECK_EQ(size_t(1), lowered_lvs.size());
241  return lowered_lvs.front();
242  }
243  const auto optype = bin_oper->get_optype();
244  if (optype == kBW_EQ) {
245  const auto bw_eq_oper = lower_bw_eq(bin_oper);
246  return codegenLogical(bw_eq_oper.get(), co);
247  }
248  if (optype == kOVERLAPS) {
249  return codegenOverlaps(optype,
250  qualifier,
251  bin_oper->get_own_left_operand(),
252  bin_oper->get_own_right_operand(),
253  co);
254  }
255  if (is_unnest(lhs) || is_unnest(rhs)) {
256  throw std::runtime_error("Unnest not supported in comparisons");
257  }
258  check_array_comp_cond(bin_oper);
259  const auto& lhs_ti = lhs->get_type_info();
260  const auto& rhs_ti = rhs->get_type_info();
261 
262  if (lhs_ti.is_string() && rhs_ti.is_string() &&
263  !(IS_EQUIVALENCE(optype) || optype == kNE)) {
264  auto cmp_str = codegenStrCmp(optype,
265  qualifier,
266  bin_oper->get_own_left_operand(),
267  bin_oper->get_own_right_operand(),
268  co);
269  if (cmp_str) {
270  return cmp_str;
271  }
272  }
273 
274  if (lhs_ti.is_decimal()) {
275  auto cmp_decimal_const =
276  codegenCmpDecimalConst(optype, qualifier, lhs, lhs_ti, rhs, co);
277  if (cmp_decimal_const) {
278  return cmp_decimal_const;
279  }
280  }
281  auto lhs_lvs = codegen(lhs, true, co);
282  return codegenCmp(optype, qualifier, lhs_lvs, lhs_ti, rhs, co);
283 }
284 
285 llvm::Value* CodeGenerator::codegenOverlaps(const SQLOps optype,
286  const SQLQualifier qualifier,
287  const std::shared_ptr<Analyzer::Expr> lhs,
288  const std::shared_ptr<Analyzer::Expr> rhs,
289  const CompilationOptions& co) {
291  const auto lhs_ti = lhs->get_type_info();
293  // failed to build a suitable hash table. short circuit the overlaps expression by
294  // always returning true. this will fall into the ST_Contains check, which will do
295  // overlaps checks before the heavier contains computation.
296  VLOG(1) << "Failed to build overlaps hash table, short circuiting overlaps operator.";
297  return llvm::ConstantInt::get(get_int_type(8, cgen_state_->context_), true);
298  }
299  // TODO(adb): we should never get here, but going to leave this in place for now since
300  // it will likely be useful in factoring the bounds check out of ST_Contains
301  CHECK(lhs_ti.is_geometry());
302 
303  if (lhs_ti.is_geometry()) {
304  // only point in linestring/poly/mpoly is currently supported
305  CHECK(lhs_ti.get_type() == kPOINT);
306  const auto lhs_col = dynamic_cast<Analyzer::ColumnVar*>(lhs.get());
307  CHECK(lhs_col);
308 
309  // Get the actual point data column descriptor
310  auto lhs_column_key = lhs_col->getColumnKey();
311  lhs_column_key.column_id = lhs_column_key.column_id + 1;
312  const auto coords_cd = Catalog_Namespace::get_metadata_for_column(lhs_column_key);
313  CHECK(coords_cd);
314 
315  std::vector<std::shared_ptr<Analyzer::Expr>> geoargs;
316  geoargs.push_back(makeExpr<Analyzer::ColumnVar>(
317  coords_cd->columnType,
318  shared::ColumnKey{lhs_col->getTableKey(), coords_cd->columnId},
319  lhs_col->get_rte_idx()));
320 
321  Datum input_compression;
322  input_compression.intval =
323  (lhs_ti.get_compression() == kENCODING_GEOINT && lhs_ti.get_comp_param() == 32)
324  ? 1
325  : 0;
326  geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression));
327  Datum input_srid;
328  input_srid.intval = lhs_ti.get_input_srid();
329  geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_srid));
330  Datum output_srid;
331  output_srid.intval = lhs_ti.get_output_srid();
332  geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, output_srid));
333 
334  const auto x_ptr_oper = makeExpr<Analyzer::FunctionOper>(
335  SQLTypeInfo(kDOUBLE, true), "ST_X_Point", geoargs);
336  const auto y_ptr_oper = makeExpr<Analyzer::FunctionOper>(
337  SQLTypeInfo(kDOUBLE, true), "ST_Y_Point", geoargs);
338 
339  const auto rhs_ti = rhs->get_type_info();
340  CHECK(IS_GEO_POLY(rhs_ti.get_type()));
341  const auto rhs_col = dynamic_cast<Analyzer::ColumnVar*>(rhs.get());
342  CHECK(rhs_col);
343 
344  auto rhs_column_key = rhs_col->getColumnKey();
345  rhs_column_key.column_id =
346  rhs_column_key.column_id + rhs_ti.get_physical_coord_cols() + 1;
347  const auto poly_bounds_cd =
349  CHECK(poly_bounds_cd);
350 
351  auto bbox_col_var = makeExpr<Analyzer::ColumnVar>(
352  poly_bounds_cd->columnType,
353  shared::ColumnKey{rhs_col->getTableKey(), poly_bounds_cd->columnId},
354  rhs_col->get_rte_idx());
355 
356  const auto bbox_contains_func_oper =
357  makeExpr<Analyzer::FunctionOper>(SQLTypeInfo(kBOOLEAN, false),
358  "Point_Overlaps_Box",
359  std::vector<std::shared_ptr<Analyzer::Expr>>{
360  bbox_col_var, x_ptr_oper, y_ptr_oper});
361 
362  return codegenFunctionOper(bbox_contains_func_oper.get(), co);
363  }
364 
365  CHECK(false) << "Unsupported type for overlaps operator: " << lhs_ti.get_type_name();
366  return nullptr;
367 }
368 
369 llvm::Value* CodeGenerator::codegenStrCmp(const SQLOps optype,
370  const SQLQualifier qualifier,
371  const std::shared_ptr<Analyzer::Expr> lhs,
372  const std::shared_ptr<Analyzer::Expr> rhs,
373  const CompilationOptions& co) {
375  const auto lhs_ti = lhs->get_type_info();
376  const auto rhs_ti = rhs->get_type_info();
377 
378  CHECK(lhs_ti.is_string());
379  CHECK(rhs_ti.is_string());
380 
381  const auto null_check_suffix = get_null_check_suffix(lhs_ti, rhs_ti);
382  if (lhs_ti.get_compression() == kENCODING_DICT &&
383  rhs_ti.get_compression() == kENCODING_DICT) {
384  if (lhs_ti.getStringDictKey() == rhs_ti.getStringDictKey()) {
385  // Both operands share a dictionary
386 
387  // check if query is trying to compare a columnt against literal
388 
389  auto ir = codegenDictStrCmp(lhs, rhs, optype, co);
390  if (ir) {
391  return ir;
392  }
393  } else {
394  // Both operands don't share a dictionary
395  return nullptr;
396  }
397  }
398  return nullptr;
399 }
400 
402  const SQLQualifier qualifier,
403  const Analyzer::Expr* lhs,
404  const SQLTypeInfo& lhs_ti,
405  const Analyzer::Expr* rhs,
406  const CompilationOptions& co) {
408  auto u_oper = dynamic_cast<const Analyzer::UOper*>(lhs);
409  if (!u_oper || u_oper->get_optype() != kCAST) {
410  return nullptr;
411  }
412  auto rhs_constant = dynamic_cast<const Analyzer::Constant*>(rhs);
413  if (!rhs_constant) {
414  return nullptr;
415  }
416  const auto operand = u_oper->get_operand();
417  const auto& operand_ti = operand->get_type_info();
418  if (operand_ti.is_decimal() && operand_ti.get_scale() < lhs_ti.get_scale()) {
419  // lhs decimal type has smaller scale
420  } else if (operand_ti.is_integer() && 0 < lhs_ti.get_scale()) {
421  // lhs is integer, no need to scale it all the way up to the cmp expr scale
422  } else {
423  return nullptr;
424  }
425 
426  auto scale_diff = lhs_ti.get_scale() - operand_ti.get_scale() - 1;
427  int64_t bigintval = rhs_constant->get_constval().bigintval;
428  bool negative = false;
429  if (bigintval < 0) {
430  negative = true;
431  bigintval = -bigintval;
432  }
433  int64_t truncated_decimal = bigintval / exp_to_scale(scale_diff);
434  int64_t decimal_tail = bigintval % exp_to_scale(scale_diff);
435  if (truncated_decimal % 10 == 0 && decimal_tail > 0) {
436  truncated_decimal += 1;
437  }
440  lhs_ti.get_scale() - scale_diff,
441  operand_ti.get_notnull());
442  if (negative) {
443  truncated_decimal = -truncated_decimal;
444  }
445  Datum d;
446  d.bigintval = truncated_decimal;
447  const auto new_rhs_lit =
448  makeExpr<Analyzer::Constant>(new_ti, rhs_constant->get_is_null(), d);
449  const auto operand_lv = codegen(operand, true, co).front();
450  const auto lhs_lv = codegenCast(operand_lv, operand_ti, new_ti, false, co);
451  return codegenCmp(optype, qualifier, {lhs_lv}, new_ti, new_rhs_lit.get(), co);
452 }
453 
454 llvm::Value* CodeGenerator::codegenCmp(const SQLOps optype,
455  const SQLQualifier qualifier,
456  std::vector<llvm::Value*> lhs_lvs,
457  const SQLTypeInfo& lhs_ti,
458  const Analyzer::Expr* rhs,
459  const CompilationOptions& co) {
461  CHECK(IS_COMPARISON(optype));
462  const auto& rhs_ti = rhs->get_type_info();
463  if (rhs_ti.is_array()) {
464  return codegenQualifierCmp(optype, qualifier, lhs_lvs, rhs, co);
465  }
466  auto rhs_lvs = codegen(rhs, true, co);
467  CHECK_EQ(kONE, qualifier);
468  if (optype == kOVERLAPS) {
469  CHECK(lhs_ti.is_geometry());
470  CHECK(rhs_ti.is_array() ||
471  rhs_ti.is_geometry()); // allow geo col or bounds col to pass
472  } else {
473  CHECK((lhs_ti.get_type() == rhs_ti.get_type()) ||
474  (lhs_ti.is_string() && rhs_ti.is_string()));
475  }
476  const auto null_check_suffix = get_null_check_suffix(lhs_ti, rhs_ti);
477  if (lhs_ti.is_integer() || lhs_ti.is_decimal() || lhs_ti.is_time() ||
478  lhs_ti.is_boolean() || lhs_ti.is_string() || lhs_ti.is_timeinterval()) {
479  if (lhs_ti.is_string()) {
480  CHECK(rhs_ti.is_string());
481  CHECK_EQ(lhs_ti.get_compression(), rhs_ti.get_compression());
482  if (lhs_ti.get_compression() == kENCODING_NONE) {
483  // unpack pointer + length if necessary
484  if (lhs_lvs.size() != 3) {
485  CHECK_EQ(size_t(1), lhs_lvs.size());
486  lhs_lvs.push_back(cgen_state_->ir_builder_.CreateExtractValue(lhs_lvs[0], 0));
487  lhs_lvs.push_back(cgen_state_->ir_builder_.CreateExtractValue(lhs_lvs[0], 1));
488  lhs_lvs.back() = cgen_state_->ir_builder_.CreateTrunc(
489  lhs_lvs.back(), llvm::Type::getInt32Ty(cgen_state_->context_));
490  }
491  if (rhs_lvs.size() != 3) {
492  CHECK_EQ(size_t(1), rhs_lvs.size());
493  rhs_lvs.push_back(cgen_state_->ir_builder_.CreateExtractValue(rhs_lvs[0], 0));
494  rhs_lvs.push_back(cgen_state_->ir_builder_.CreateExtractValue(rhs_lvs[0], 1));
495  rhs_lvs.back() = cgen_state_->ir_builder_.CreateTrunc(
496  rhs_lvs.back(), llvm::Type::getInt32Ty(cgen_state_->context_));
497  }
498  std::vector<llvm::Value*> str_cmp_args{
499  lhs_lvs[1], lhs_lvs[2], rhs_lvs[1], rhs_lvs[2]};
500  if (!null_check_suffix.empty()) {
501  str_cmp_args.push_back(
503  }
504  return cgen_state_->emitCall(
505  string_cmp_func(optype) + (null_check_suffix.empty() ? "" : "_nullable"),
506  str_cmp_args);
507  } else {
508  CHECK(optype == kEQ || optype == kNE);
509  }
510  }
511 
512  if (lhs_ti.is_boolean() && rhs_ti.is_boolean()) {
513  auto& lhs_lv = lhs_lvs.front();
514  auto& rhs_lv = rhs_lvs.front();
515  CHECK(lhs_lv->getType()->isIntegerTy());
516  CHECK(rhs_lv->getType()->isIntegerTy());
517  if (lhs_lv->getType()->getIntegerBitWidth() <
518  rhs_lv->getType()->getIntegerBitWidth()) {
519  lhs_lv =
520  cgen_state_->castToTypeIn(lhs_lv, rhs_lv->getType()->getIntegerBitWidth());
521  } else {
522  rhs_lv =
523  cgen_state_->castToTypeIn(rhs_lv, lhs_lv->getType()->getIntegerBitWidth());
524  }
525  }
526 
527  return null_check_suffix.empty()
528  ? cgen_state_->ir_builder_.CreateICmp(
529  llvm_icmp_pred(optype), lhs_lvs.front(), rhs_lvs.front())
531  icmp_name(optype) + "_" + numeric_type_name(lhs_ti) +
532  null_check_suffix,
533  {lhs_lvs.front(),
534  rhs_lvs.front(),
537  }
538  if (lhs_ti.get_type() == kFLOAT || lhs_ti.get_type() == kDOUBLE) {
539  return null_check_suffix.empty()
540  ? cgen_state_->ir_builder_.CreateFCmp(
541  llvm_fcmp_pred(optype), lhs_lvs.front(), rhs_lvs.front())
543  icmp_name(optype) + "_" + numeric_type_name(lhs_ti) +
544  null_check_suffix,
545  {lhs_lvs.front(),
546  rhs_lvs.front(),
547  lhs_ti.get_type() == kFLOAT ? cgen_state_->llFp(NULL_FLOAT)
550  }
551  CHECK(false);
552  return nullptr;
553 }
554 
555 llvm::Value* CodeGenerator::codegenQualifierCmp(const SQLOps optype,
556  const SQLQualifier qualifier,
557  std::vector<llvm::Value*> lhs_lvs,
558  const Analyzer::Expr* rhs,
559  const CompilationOptions& co) {
561  const auto& rhs_ti = rhs->get_type_info();
562  const Analyzer::Expr* arr_expr{rhs};
563  if (dynamic_cast<const Analyzer::UOper*>(rhs)) {
564  const auto cast_arr = static_cast<const Analyzer::UOper*>(rhs);
565  CHECK_EQ(kCAST, cast_arr->get_optype());
566  arr_expr = cast_arr->get_operand();
567  }
568  const auto& arr_ti = arr_expr->get_type_info();
569  const auto& elem_ti = arr_ti.get_elem_type();
570  auto rhs_lvs = codegen(arr_expr, true, co);
571  CHECK_NE(kONE, qualifier);
572  std::string fname{std::string("array_") + (qualifier == kANY ? "any" : "all") + "_" +
573  icmp_arr_name(optype)};
574  const auto& target_ti = rhs_ti.get_elem_type();
575  const bool is_real_string{target_ti.is_string() &&
576  target_ti.get_compression() != kENCODING_DICT};
577  if (is_real_string) {
578  if (g_cluster) {
579  throw std::runtime_error(
580  "Comparison between a dictionary-encoded and a none-encoded string not "
581  "supported for distributed queries");
582  }
583  if (g_enable_watchdog) {
584  throw WatchdogException(
585  "Comparison between a dictionary-encoded and a none-encoded string would be "
586  "slow");
587  }
589  throw QueryMustRunOnCpu();
590  }
591  CHECK_EQ(kENCODING_NONE, target_ti.get_compression());
592  fname += "_str";
593  }
594  if (elem_ti.is_integer() || elem_ti.is_boolean() || elem_ti.is_string() ||
595  elem_ti.is_decimal()) {
596  fname += ("_" + numeric_type_name(elem_ti));
597  } else {
598  CHECK(elem_ti.is_fp());
599  fname += elem_ti.get_type() == kDOUBLE ? "_double" : "_float";
600  }
601  if (is_real_string) {
602  CHECK_EQ(size_t(3), lhs_lvs.size());
604  fname,
606  {rhs_lvs.front(),
607  posArg(arr_expr),
608  lhs_lvs[1],
609  lhs_lvs[2],
610  cgen_state_->llInt(int64_t(executor()->getStringDictionaryProxy(
611  elem_ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true))),
612  cgen_state_->inlineIntNull(elem_ti)});
613  }
614  if (target_ti.is_integer() || target_ti.is_boolean() || target_ti.is_string() ||
615  target_ti.is_decimal()) {
616  fname += ("_" + numeric_type_name(target_ti));
617  } else {
618  CHECK(target_ti.is_fp());
619  fname += target_ti.get_type() == kDOUBLE ? "_double" : "_float";
620  }
621  return cgen_state_->emitExternalCall(
622  fname,
623  get_int_type(1, cgen_state_->context_),
624  {rhs_lvs.front(),
625  posArg(arr_expr),
626  lhs_lvs.front(),
627  elem_ti.is_fp() ? static_cast<llvm::Value*>(cgen_state_->inlineFpNull(elem_ti))
628  : static_cast<llvm::Value*>(cgen_state_->inlineIntNull(elem_ti))});
629 }
void check_array_comp_cond(const Analyzer::BinOper *bin_oper)
Definition: CompareIR.cpp:182
static constexpr int32_t kMaxRepresentableNumericPrecision
Definition: sqltypes.h:50
#define CHECK_EQ(x, y)
Definition: Logger.h:301
llvm::Value * castToTypeIn(llvm::Value *val, const size_t bit_width)
Definition: CgenState.cpp:149
#define NULL_DOUBLE
llvm::Value * codegenStrCmp(const SQLOps, const SQLQualifier, const std::shared_ptr< Analyzer::Expr >, const std::shared_ptr< Analyzer::Expr >, const CompilationOptions &)
Definition: CompareIR.cpp:369
std::string icmp_name(const SQLOps op_type)
Definition: CompareIR.cpp:45
#define IS_EQUIVALENCE(X)
Definition: sqldefs.h:69
CgenState * cgen_state_
#define NULL_FLOAT
SQLQualifier
Definition: sqldefs.h:71
std::shared_ptr< Analyzer::BinOper > lower_multicol_compare(const Analyzer::BinOper *multicol_compare)
Definition: CompareIR.cpp:159
HOST DEVICE int get_scale() const
Definition: sqltypes.h:386
const Expr * get_right_operand() const
Definition: Analyzer.h:456
SQLOps
Definition: sqldefs.h:28
Definition: sqldefs.h:34
llvm::IRBuilder ir_builder_
Definition: CgenState.h:377
static std::shared_ptr< Analyzer::Expr > normalize(const SQLOps optype, const SQLQualifier qual, std::shared_ptr< Analyzer::Expr > left_expr, std::shared_ptr< Analyzer::Expr > right_expr, const Executor *executor=nullptr)
Definition: ParserNode.cpp:372
Definition: sqldefs.h:35
llvm::Value * posArg(const Analyzer::Expr *) const
Definition: ColumnIR.cpp:580
Definition: sqldefs.h:37
const ColumnDescriptor * get_metadata_for_column(const ::shared::ColumnKey &column_key)
bool get_contains_agg() const
Definition: Analyzer.h:81
Definition: sqldefs.h:48
Definition: sqldefs.h:29
std::shared_ptr< Analyzer::BinOper > lower_bw_eq(const Analyzer::BinOper *bw_eq)
Definition: CompareIR.cpp:125
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:381
llvm::CmpInst::Predicate llvm_fcmp_pred(const SQLOps op_type)
Definition: CompareIR.cpp:83
llvm::Type * get_int_type(const int width, llvm::LLVMContext &context)
#define CHECK_GT(x, y)
Definition: Logger.h:305
int32_t intval
Definition: Datum.h:71
bool is_time() const
Definition: sqltypes.h:586
std::string icmp_arr_name(const SQLOps op_type)
Definition: CompareIR.cpp:64
bool g_enable_overlaps_hashjoin
Definition: Execute.cpp:102
SQLOps get_optype() const
Definition: Analyzer.h:452
llvm::LLVMContext & context_
Definition: CgenState.h:375
llvm::Value * codegenCmpDecimalConst(const SQLOps, const SQLQualifier, const Analyzer::Expr *, const SQLTypeInfo &, const Analyzer::Expr *, const CompilationOptions &)
Definition: CompareIR.cpp:401
llvm::Value * emitExternalCall(const std::string &fname, llvm::Type *ret_type, const std::vector< llvm::Value * > args, const std::vector< llvm::Attribute::AttrKind > &fnattrs={}, const bool has_struct_return=false)
Definition: CgenState.cpp:396
bool is_integer() const
Definition: sqltypes.h:582
#define CHECK_NE(x, y)
Definition: Logger.h:302
llvm::ConstantInt * inlineIntNull(const SQLTypeInfo &)
Definition: CgenState.cpp:64
int64_t bigintval
Definition: Datum.h:72
bool is_timeinterval() const
Definition: sqltypes.h:591
llvm::Value * codegenFunctionOper(const Analyzer::FunctionOper *, const CompilationOptions &)
Definition: sqldefs.h:36
bool g_enable_watchdog
Definition: sqldefs.h:71
llvm::Value * codegenOverlaps(const SQLOps, const SQLQualifier, const std::shared_ptr< Analyzer::Expr >, const std::shared_ptr< Analyzer::Expr >, const CompilationOptions &)
Definition: CompareIR.cpp:285
llvm::ConstantFP * llFp(const float v) const
Definition: CgenState.h:246
llvm::Value * codegenDictStrCmp(const std::shared_ptr< Analyzer::Expr >, const std::shared_ptr< Analyzer::Expr >, const SQLOps, const CompilationOptions &co)
bool is_boolean() const
Definition: sqltypes.h:587
#define AUTOMATIC_IR_METADATA(CGENSTATE)
std::string get_null_check_suffix(const SQLTypeInfo &lhs_ti, const SQLTypeInfo &rhs_ti)
Definition: Execute.h:1487
const SQLTypeInfo & get_type_info() const
Definition: Analyzer.h:79
llvm::Value * emitCall(const std::string &fname, const std::vector< llvm::Value * > &args)
Definition: CgenState.cpp:216
ExecutorDeviceType device_type
Definition: sqldefs.h:33
std::vector< llvm::Value * > codegen(const Analyzer::Expr *, const bool fetch_columns, const CompilationOptions &)
Definition: IRCodegen.cpp:30
Definition: sqltypes.h:69
Definition: sqldefs.h:71
HOST DEVICE EncodingType get_compression() const
Definition: sqltypes.h:389
std::shared_ptr< Analyzer::BinOper > make_eq(const std::shared_ptr< Analyzer::Expr > &lhs, const std::shared_ptr< Analyzer::Expr > &rhs, const SQLOps optype)
Definition: CompareIR.cpp:145
llvm::Value * codegenQualifierCmp(const SQLOps, const SQLQualifier, std::vector< llvm::Value * >, const Analyzer::Expr *, const CompilationOptions &)
Definition: CompareIR.cpp:555
Definition: sqldefs.h:31
llvm::CmpInst::Predicate llvm_icmp_pred(const SQLOps op_type)
Definition: CompareIR.cpp:26
llvm::Value * codegenCmp(const Analyzer::BinOper *, const CompilationOptions &)
Definition: CompareIR.cpp:230
llvm::ConstantInt * llInt(const T v) const
Definition: CgenState.h:242
#define CHECK(condition)
Definition: Logger.h:291
bool is_geometry() const
Definition: sqltypes.h:592
Definition: sqldefs.h:30
llvm::Value * codegenLogical(const Analyzer::BinOper *, const CompilationOptions &)
Definition: LogicalIR.cpp:298
uint64_t exp_to_scale(const unsigned exp)
int64_t inline_int_null_val(const SQL_TYPE_INFO &ti)
bool g_cluster
Definition: sqldefs.h:32
const Expr * get_left_operand() const
Definition: Analyzer.h:455
llvm::Value * codegenCast(const Analyzer::UOper *, const CompilationOptions &)
Definition: CastIR.cpp:21
std::string numeric_type_name(const SQLTypeInfo &ti)
Definition: Execute.h:209
Definition: sqltypes.h:62
bool is_unnest(const Analyzer::Expr *expr)
Definition: Execute.h:1503
bool is_string() const
Definition: sqltypes.h:580
const std::shared_ptr< Analyzer::Expr > get_own_right_operand() const
Definition: Analyzer.h:460
Definition: Datum.h:67
bool is_decimal() const
Definition: sqltypes.h:583
const std::shared_ptr< Analyzer::Expr > get_own_left_operand() const
Definition: Analyzer.h:457
#define VLOG(n)
Definition: Logger.h:387
std::string string_cmp_func(const SQLOps optype)
Definition: CompareIR.cpp:106
#define IS_COMPARISON(X)
Definition: sqldefs.h:58
SQLQualifier get_qualifier() const
Definition: Analyzer.h:454
Executor * executor() const
#define IS_GEO_POLY(T)
Definition: sqltypes.h:305