RelAlgTranslator Class Reference

#include <RelAlgTranslator.h>

Collaboration diagram for RelAlgTranslator:

Public Member Functions
	RelAlgTranslator (const Catalog_Namespace::Catalog &cat, std::shared_ptr< const query_state::QueryState > q_s, const Executor *executor, const std::unordered_map< const RelAlgNode *, int > &input_to_nest_level, const std::vector< JoinType > &join_types, const time_t now, const bool just_explain)
std::shared_ptr< Analyzer::Expr >	translateScalarRex (const RexScalar *rex) const
bool	generated_geos_ops ()

Static Public Member Functions
static std::shared_ptr < Analyzer::Expr >	translateAggregateRex (const RexAgg *rex, const std::vector< std::shared_ptr< Analyzer::Expr >> &scalar_sources)
static std::shared_ptr < Analyzer::Expr >	translateLiteral (const RexLiteral *)

Private Member Functions
std::shared_ptr< Analyzer::Expr >	translateScalarSubquery (const RexSubQuery *) const
std::shared_ptr< Analyzer::Expr >	translateInput (const RexInput *) const
std::shared_ptr< Analyzer::Expr >	translateUoper (const RexOperator *) const
std::shared_ptr< Analyzer::Expr >	translateInOper (const RexOperator *) const
std::shared_ptr< Analyzer::Expr >	getInIntegerSetExpr (std::shared_ptr< Analyzer::Expr > arg, const ResultSet &val_set) const
std::shared_ptr< Analyzer::Expr >	translateOper (const RexOperator *) const
std::shared_ptr< Analyzer::Expr >	translateOverlapsOper (const RexOperator *) const
std::shared_ptr< Analyzer::Expr >	translateCase (const RexCase *) const
std::shared_ptr< Analyzer::Expr >	translateWidthBucket (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateLike (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateRegexp (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateLikely (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateUnlikely (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateExtract (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateDateadd (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateDatePlusMinus (const RexOperator *) const
std::shared_ptr< Analyzer::Expr >	translateDatediff (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateDatepart (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateLength (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateKeyForString (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateSampleRatio (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateCurrentUser (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateStringOper (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateCardinality (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateItem (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateCurrentDate () const
std::shared_ptr< Analyzer::Expr >	translateCurrentTime () const
std::shared_ptr< Analyzer::Expr >	translateCurrentTimestamp () const
std::shared_ptr< Analyzer::Expr >	translateDatetime (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateHPTLiteral (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateAbs (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateSign (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateOffsetInFragment () const
std::shared_ptr< Analyzer::Expr >	translateArrayFunction (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateFunction (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateWindowFunction (const RexWindowFunctionOperator *) const
Analyzer::ExpressionPtrVector	translateFunctionArgs (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateUnaryGeoFunction (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateBinaryGeoFunction (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateTernaryGeoFunction (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateFunctionWithGeoArg (const RexFunctionOperator *) const
std::shared_ptr< Analyzer::Expr >	translateGeoComparison (const RexOperator *) const
std::shared_ptr< Analyzer::Expr >	translateGeoProjection (const RexFunctionOperator *, SQLTypeInfo &, const bool with_bounds) const
std::shared_ptr< Analyzer::Expr >	translateUnaryGeoPredicate (const RexFunctionOperator *, SQLTypeInfo &, const bool with_bounds) const
std::shared_ptr< Analyzer::Expr >	translateBinaryGeoPredicate (const RexFunctionOperator *, SQLTypeInfo &, const bool with_bounds) const
std::shared_ptr< Analyzer::Expr >	translateBinaryGeoConstructor (const RexFunctionOperator *, SQLTypeInfo &, const bool with_bounds) const
std::shared_ptr< Analyzer::Expr >	translateGeoOverlapsOper (const RexOperator *) const
std::vector< std::shared_ptr < Analyzer::Expr > >	translateGeoFunctionArg (const RexScalar *rex_scalar, SQLTypeInfo &arg_ti, const bool with_bounds, const bool with_render_group, const bool expand_geo_col, const bool is_projection=false, const bool use_geo_expressions=false, const bool try_to_compress=false, const bool allow_gdal_transforms=false) const
std::vector< std::shared_ptr < Analyzer::Expr > >	translateGeoColumn (const RexInput *, SQLTypeInfo &, const bool with_bounds, const bool with_render_group, const bool expand_geo_col) const
std::vector< std::shared_ptr < Analyzer::Expr > >	translateGeoLiteral (const RexLiteral *, SQLTypeInfo &, bool) const

Private Attributes
const Catalog_Namespace::Catalog &	cat_
std::shared_ptr< const query_state::QueryState >	query_state_
const Executor *	executor_
const std::unordered_map < const RelAlgNode *, int >	input_to_nest_level_
const std::vector< JoinType >	join_types_
time_t	now_
bool	generated_geos_ops_
const bool	just_explain_

Detailed Description

Definition at line 47 of file RelAlgTranslator.h.

Constructor & Destructor Documentation

RelAlgTranslator::RelAlgTranslator ( const Catalog_Namespace::Catalog &  cat, std::shared_ptr< const query_state::QueryState >  q_s, const Executor *  executor, const std::unordered_map< const RelAlgNode *, int > &  input_to_nest_level, const std::vector< JoinType > &  join_types, const time_t  now, const bool  just_explain  )

inline

Definition at line 49 of file RelAlgTranslator.h.

      : cat_(cat)
      , query_state_(q_s)
      , executor_(executor)
      , input_to_nest_level_(input_to_nest_level)
      , join_types_(join_types)
      , now_(now)
      , generated_geos_ops_(false)
      , just_explain_(just_explain) {}

Member Function Documentation

bool RelAlgTranslator::generated_geos_ops ( )

inline

Definition at line 73 of file RelAlgTranslator.h.

References generated_geos_ops_.

{ return generated_geos_ops_; }

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::getInIntegerSetExpr ( std::shared_ptr< Analyzer::Expr >  arg, const ResultSet &  val_set  ) const

private

Definition at line 812 of file RelAlgTranslator.cpp.

References threading_serial::async(), result_set::can_use_parallel_algorithms(), cat_, CHECK, CHECK_EQ, CHECK_GE, cpu_threads(), executor_, anonymous_namespace{RelAlgTranslator.cpp}::fill_dictionary_encoded_in_vals(), anonymous_namespace{RelAlgTranslator.cpp}::fill_integer_in_vals(), g_cluster, Catalog_Namespace::Catalog::getDatabaseId(), Catalog_Namespace::Catalog::getStringDictionaryHosts(), inline_int_null_val(), and kENCODING_DICT.

Referenced by translateInOper().

                                    {
  if (!result_set::can_use_parallel_algorithms(val_set)) {
    return nullptr;
  }
  std::vector<int64_t> value_exprs;
  const size_t fetcher_count = cpu_threads();
  std::vector<std::vector<int64_t>> expr_set(fetcher_count);
  std::vector<std::future<void>> fetcher_threads;
  const auto& arg_type = arg->get_type_info();
  const auto entry_count = val_set.entryCount();
  CHECK_EQ(size_t(1), val_set.colCount());
  const auto& col_type = val_set.getColType(0);
  if (g_cluster && arg_type.is_string() &&
      (col_type.get_comp_param() <= 0 || arg_type.get_comp_param() <= 0)) {
    // Skip this case for now, see comment for fill_dictionary_encoded_in_vals.
    return nullptr;
  }
  std::atomic<size_t> total_in_vals_count{0};
  for (size_t i = 0,
              start_entry = 0,
              stride = (entry_count + fetcher_count - 1) / fetcher_count;
       i < fetcher_count && start_entry < entry_count;
       ++i, start_entry += stride) {
    expr_set[i].reserve(entry_count / fetcher_count);
    const auto end_entry = std::min(start_entry + stride, entry_count);
    if (arg_type.is_string()) {
      CHECK_EQ(kENCODING_DICT, arg_type.get_compression());
      // const int32_t dest_dict_id = arg_type.get_comp_param();
      // const int32_t source_dict_id = col_type.get_comp_param();
      const DictRef dest_dict_ref(arg_type.get_comp_param(), cat_.getDatabaseId());
      const DictRef source_dict_ref(col_type.get_comp_param(), cat_.getDatabaseId());
      const auto dd = executor_->getStringDictionaryProxy(
          arg_type.get_comp_param(), val_set.getRowSetMemOwner(), true);
      const auto sd = executor_->getStringDictionaryProxy(
          col_type.get_comp_param(), val_set.getRowSetMemOwner(), true);
      CHECK(sd);
      const auto needle_null_val = inline_int_null_val(arg_type);
      fetcher_threads.push_back(std::async(
          std::launch::async,
          [this,
           &val_set,
           &total_in_vals_count,
           sd,
           dd,
           source_dict_ref,
           dest_dict_ref,
           needle_null_val](
              std::vector<int64_t>& in_vals, const size_t start, const size_t end) {
            if (g_cluster) {
              CHECK_GE(dd->getGeneration(), 0);
              fill_dictionary_encoded_in_vals(in_vals,
                                              total_in_vals_count,
                                              &val_set,
                                              {start, end},
                                              cat_.getStringDictionaryHosts(),
                                              source_dict_ref,
                                              dest_dict_ref,
                                              dd->getGeneration(),
                                              needle_null_val);
            } else {
              fill_dictionary_encoded_in_vals(in_vals,
                                              total_in_vals_count,
                                              &val_set,
                                              {start, end},
                                              sd,
                                              dd,
                                              needle_null_val);
            }
          },
          std::ref(expr_set[i]),
          start_entry,
          end_entry));
    } else {
      CHECK(arg_type.is_integer());
      fetcher_threads.push_back(std::async(
          std::launch::async,
          [&val_set, &total_in_vals_count](
              std::vector<int64_t>& in_vals, const size_t start, const size_t end) {
            fill_integer_in_vals(in_vals, total_in_vals_count, &val_set, {start, end});
          },
          std::ref(expr_set[i]),
          start_entry,
          end_entry));
    }
  }
  for (auto& child : fetcher_threads) {
    child.get();
  }

  val_set.moveToBegin();
  value_exprs.reserve(entry_count);
  for (auto& exprs : expr_set) {
    value_exprs.insert(value_exprs.end(), exprs.begin(), exprs.end());
  }
  return makeExpr<Analyzer::InIntegerSet>(
      arg, value_exprs, arg_type.get_notnull() && col_type.get_notnull());
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateAbs ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1457 of file RelAlgTranslator.cpp.

References CHECK, CHECK_EQ, RexOperator::getOperand(), kBOOLEAN, kLT, kONE, kUMINUS, anonymous_namespace{RelAlgTranslator.cpp}::makeNumericConstant(), RexOperator::size(), and translateScalarRex().

Referenced by translateFunction().

                                                   {
  std::list<std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>
      expr_list;
  CHECK_EQ(size_t(1), rex_function->size());
  const auto operand = translateScalarRex(rex_function->getOperand(0));
  const auto& operand_ti = operand->get_type_info();
  CHECK(operand_ti.is_number());
  const auto zero = makeNumericConstant(operand_ti, 0);
  const auto lt_zero = makeExpr<Analyzer::BinOper>(kBOOLEAN, kLT, kONE, operand, zero);
  const auto uminus_operand =
      makeExpr<Analyzer::UOper>(operand_ti.get_type(), kUMINUS, operand);
  expr_list.emplace_back(lt_zero, uminus_operand);
  return makeExpr<Analyzer::CaseExpr>(operand_ti, false, expr_list, operand);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateAggregateRex ( const RexAgg *  rex, const std::vector< std::shared_ptr< Analyzer::Expr >> &  scalar_sources  )

static

Definition at line 227 of file RelAlgTranslator.cpp.

References CHECK_LE, CHECK_LT, Datum::doubleval, g_cluster, get_agg_type(), RexAgg::getKind(), RexAgg::getOperand(), anonymous_namespace{RelAlgTranslator.cpp}::is_agg_supported_for_type(), anonymous_namespace{RelAlgOptimizer.cpp}::is_distinct(), RexAgg::isDistinct(), kAPPROX_COUNT_DISTINCT, kAPPROX_QUANTILE, kDOUBLE, kINT, RexAgg::size(), and ThriftSerializers::takes_arg().

Referenced by anonymous_namespace{RelAlgExecutor.cpp}::translate_targets().

                                                                  {
  SQLAgg agg_kind = rex->getKind();
  const bool is_distinct = rex->isDistinct();
  const bool takes_arg{rex->size() > 0};
  std::shared_ptr<Analyzer::Expr> arg_expr;
  std::shared_ptr<Analyzer::Constant> arg1;  // 2nd aggregate parameter
  if (takes_arg) {
    const auto operand = rex->getOperand(0);
    CHECK_LT(operand, scalar_sources.size());
    CHECK_LE(rex->size(), 2u);
    arg_expr = scalar_sources[operand];
    if (agg_kind == kAPPROX_COUNT_DISTINCT && rex->size() == 2) {
      arg1 = std::dynamic_pointer_cast<Analyzer::Constant>(
          scalar_sources[rex->getOperand(1)]);
      if (!arg1 || arg1->get_type_info().get_type() != kINT ||
          arg1->get_constval().intval < 1 || arg1->get_constval().intval > 100) {
        throw std::runtime_error(
            "APPROX_COUNT_DISTINCT's second parameter should be SMALLINT literal between "
            "1 and 100");
      }
    } else if (agg_kind == kAPPROX_QUANTILE) {
      if (g_cluster) {
        throw std::runtime_error(
            "APPROX_PERCENTILE/MEDIAN is not supported in distributed mode at this "
            "time.");
      }
      // If second parameter is not given then APPROX_MEDIAN is assumed.
      if (rex->size() == 2) {
        arg1 = std::dynamic_pointer_cast<Analyzer::Constant>(
            std::dynamic_pointer_cast<Analyzer::Constant>(
                scalar_sources[rex->getOperand(1)])
                ->add_cast(SQLTypeInfo(kDOUBLE)));
      } else {
#ifdef _WIN32
        Datum median;
        median.doubleval = 0.5;
#else
        constexpr Datum median{.doubleval = 0.5};
#endif
        arg1 = std::make_shared<Analyzer::Constant>(kDOUBLE, false, median);
      }
    }
    const auto& arg_ti = arg_expr->get_type_info();
    if (!is_agg_supported_for_type(agg_kind, arg_ti)) {
      throw std::runtime_error("Aggregate on " + arg_ti.get_type_name() +
                               " is not supported yet.");
    }
  }
  const auto agg_ti = get_agg_type(agg_kind, arg_expr.get());
  return makeExpr<Analyzer::AggExpr>(agg_ti, agg_kind, arg_expr, is_distinct, arg1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Analyzer::ExpressionPtr RelAlgTranslator::translateArrayFunction ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1499 of file RelAlgTranslator.cpp.

References CHECK, get_nullable_logical_type_info(), SQLTypeInfo::get_subtype(), RexOperator::getType(), kARRAY, kBOOLEAN, kENCODING_FIXED, kNULLT, to_string(), TRANSIENT_DICT_ID, and translateFunctionArgs().

Referenced by translateFunction().

                                                   {
  if (rex_function->getType().get_subtype() == kNULLT) {
    auto sql_type = rex_function->getType();
    CHECK(sql_type.get_type() == kARRAY);

    // FIX-ME:  Deal with NULL arrays
    auto translated_function_args(translateFunctionArgs(rex_function));
    if (translated_function_args.size() > 0) {
      const auto first_element_logical_type =
          get_nullable_logical_type_info(translated_function_args[0]->get_type_info());

      auto diff_elem_itr =
          std::find_if(translated_function_args.begin(),
                       translated_function_args.end(),
                       [first_element_logical_type](const auto expr) {
                         return first_element_logical_type !=
                                get_nullable_logical_type_info(expr->get_type_info());
                       });
      if (diff_elem_itr != translated_function_args.end()) {
        throw std::runtime_error(
            "Element " +
            std::to_string(diff_elem_itr - translated_function_args.begin()) +
            " is not of the same type as other elements of the array. Consider casting "
            "to force this condition.\nElement Type: " +
            get_nullable_logical_type_info((*diff_elem_itr)->get_type_info())
                .to_string() +
            "\nArray type: " + first_element_logical_type.to_string());
      }

      if (first_element_logical_type.is_string() &&
          !first_element_logical_type.is_dict_encoded_string()) {
        sql_type.set_subtype(first_element_logical_type.get_type());
        sql_type.set_compression(kENCODING_FIXED);
      } else if (first_element_logical_type.is_dict_encoded_string()) {
        sql_type.set_subtype(first_element_logical_type.get_type());
        sql_type.set_comp_param(TRANSIENT_DICT_ID);
      } else {
        sql_type.set_subtype(first_element_logical_type.get_type());
        sql_type.set_scale(first_element_logical_type.get_scale());
        sql_type.set_precision(first_element_logical_type.get_precision());
      }

      return makeExpr<Analyzer::ArrayExpr>(sql_type, translated_function_args);
    } else {
      // defaulting to valid sub-type for convenience
      sql_type.set_subtype(kBOOLEAN);
      return makeExpr<Analyzer::ArrayExpr>(sql_type, translated_function_args);
    }
  } else {
    return makeExpr<Analyzer::ArrayExpr>(rex_function->getType(),
                                         translateFunctionArgs(rex_function));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateBinaryGeoConstructor ( const RexFunctionOperator *  rex_function, SQLTypeInfo &  ti, const bool  with_bounds  ) const

private

Definition at line 906 of file RelAlgTranslatorGeo.cpp.

References func_resolve, SQLTypeInfo::get_input_srid(), SQLTypeInfo::get_output_srid(), RexFunctionOperator::getName(), RexOperator::getOperand(), Geospatial::GeoBase::kBUFFER, Geospatial::GeoBase::kDIFFERENCE, kDOUBLE, kENCODING_NONE, kGEOMETRY, Geospatial::GeoBase::kINTERSECTION, kMULTIPOLYGON, Geospatial::GeoBase::kUNION, SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), SQLTypeInfo::set_input_srid(), SQLTypeInfo::set_output_srid(), SQLTypeInfo::set_subtype(), SQLTypeInfo::set_type(), translateGeoFunctionArg(), and translateScalarRex().

Referenced by translateFunction(), and translateGeoFunctionArg().

                                  {
#ifndef ENABLE_GEOS
  throw QueryNotSupported(rex_function->getName() +
                          " geo constructor requires enabled GEOS support");
#endif
  Geospatial::GeoBase::GeoOp op = Geospatial::GeoBase::GeoOp::kINTERSECTION;
  if (rex_function->getName() == "ST_Difference"sv) {
    op = Geospatial::GeoBase::GeoOp::kDIFFERENCE;
  } else if (rex_function->getName() == "ST_Union"sv) {
    op = Geospatial::GeoBase::GeoOp::kUNION;
  } else if (rex_function->getName() == "ST_Buffer"sv) {
    op = Geospatial::GeoBase::GeoOp::kBUFFER;
  }

  Analyzer::ExpressionPtrVector geoargs0{};
  Analyzer::ExpressionPtrVector geoargs1{};
  SQLTypeInfo arg0_ti;
  SQLTypeInfo arg1_ti;
  if (func_resolve(rex_function->getName(),
                   "ST_Intersection"sv,
                   "ST_Difference"sv,
                   "ST_Union"sv,
                   "ST_Buffer"sv)) {
    // First arg: geometry
    geoargs0 = translateGeoFunctionArg(rex_function->getOperand(0),
                                       arg0_ti,
                                       false,
                                       false,
                                       true,
                                       true,
                                       false,
                                       false,
                                       /* allow_gdal_transforms = */ true);
  }
  if (func_resolve(rex_function->getName(),
                   "ST_Intersection"sv,
                   "ST_Difference"sv,
                   "ST_Union"sv)) {
    // Second arg: geometry
    geoargs1 = translateGeoFunctionArg(rex_function->getOperand(1),
                                       arg1_ti,
                                       false,
                                       false,
                                       true,
                                       true,
                                       false,
                                       false,
                                       /* allow_gdal_transforms = */ true);
    if (arg0_ti.get_output_srid() != arg1_ti.get_output_srid()) {
      throw QueryNotSupported(rex_function->getName() +
                              " geo constructor requires arguments with matching srids");
    }
  } else if (func_resolve(rex_function->getName(), "ST_Buffer"sv)) {
    // Second arg: double scalar
    auto param_expr = translateScalarRex(rex_function->getOperand(1));
    arg1_ti = SQLTypeInfo(kDOUBLE, false);
    if (param_expr->get_type_info().get_type() != kDOUBLE) {
      param_expr = param_expr->add_cast(arg1_ti);
    }
    geoargs1 = {param_expr};
  }

  // Record the optional transform request that can be sent by an ecompassing TRANSFORM
  auto srid = ti.get_output_srid();
  // Build the typeinfo of the constructed geometry
  SQLTypeInfo arg_ti = arg0_ti;
  arg_ti.set_type(kMULTIPOLYGON);
  arg_ti.set_subtype(kGEOMETRY);
  arg_ti.set_compression(kENCODING_NONE);  // Constructed geometries are not compressed
  arg_ti.set_comp_param(0);
  arg_ti.set_input_srid(arg0_ti.get_output_srid());
  if (srid > 0) {
    if (arg_ti.get_input_srid() > 0) {
      // Constructed geometry to be transformed to srid given by encompassing transform
      arg_ti.set_output_srid(srid);
    } else {
      throw QueryNotSupported("Transform of geo constructor " + rex_function->getName() +
                              " requires its argument(s) to have a valid srid");
    }
  } else {
    arg_ti.set_output_srid(arg_ti.get_input_srid());  // No encompassing transform
  }
  // If there was an output transform, it's now embedded into arg_ti and the geo operator.
  // Now de-register the transform from the return typeinfo:
  ti = arg_ti;
  ti.set_input_srid(ti.get_output_srid());
  return makeExpr<Analyzer::GeoBinOper>(op, arg_ti, arg0_ti, arg1_ti, geoargs0, geoargs1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateBinaryGeoFunction ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1236 of file RelAlgTranslatorGeo.cpp.

References run_benchmark_import::args, CHECK, CHECK_EQ, CHECK_GT, Datum::doubleval, fold_expr(), func_resolve, g_enable_geo_ops_on_uncompressed_coords, SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), Geospatial::get_compression_scheme(), SQLTypeInfo::get_input_srid(), SQLTypeInfo::get_output_srid(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), RexFunctionOperator::getName(), RexOperator::getOperand(), RexOperator::getType(), Datum::intval, kBOOLEAN, kDOUBLE, kENCODING_GEOINT, kENCODING_NONE, kGEOGRAPHY, kINT, kLE, kLINESTRING, kMULTIPOLYGON, kNOT, kNULLT, kONE, kPOINT, kPOLYGON, run_benchmark_import::result, RexOperator::size(), spatial_type::suffix(), TOLERANCE_GEOINT32, translateGeoColumn(), translateGeoFunctionArg(), and translateScalarRex().

Referenced by translateFunction(), and translateTernaryGeoFunction().

                                                   {
  auto function_name = rex_function->getName();
  auto return_type = rex_function->getType();

  if (function_name == "ST_Overlaps"sv) {
    // Overlaps join is the only implementation supported for now, only translate bounds
    CHECK_EQ(size_t(2), rex_function->size());
    auto extract_geo_bounds_from_input =
        [this, &rex_function](const size_t index) -> std::shared_ptr<Analyzer::Expr> {
      const auto rex_input =
          dynamic_cast<const RexInput*>(rex_function->getOperand(index));
      if (rex_input) {
        SQLTypeInfo ti;
        const auto exprs = translateGeoColumn(rex_input, ti, true, false, false);
        CHECK_GT(exprs.size(), size_t(0));
        if (ti.get_type() == kPOINT) {
          throw std::runtime_error("ST_Overlaps is not supported for point arguments.");
        } else {
          return exprs.back();
        }
      } else {
        throw std::runtime_error(
            "Only inputs are supported as arguments to ST_Overlaps for now.");
      }
    };
    std::vector<std::shared_ptr<Analyzer::Expr>> geo_args;
    geo_args.push_back(extract_geo_bounds_from_input(0));
    geo_args.push_back(extract_geo_bounds_from_input(1));

    return makeExpr<Analyzer::FunctionOper>(return_type, function_name, geo_args);
  }

  if (function_name == "ST_Distance"sv || function_name == "ST_MaxDistance"sv) {
    CHECK_EQ(size_t(2), rex_function->size());
    std::vector<std::shared_ptr<Analyzer::Expr>> args;
    int legacy_transform_srid = 0;
    for (size_t i = 0; i < rex_function->size(); i++) {
      SQLTypeInfo arg0_ti;  // discard
      auto geoargs = translateGeoFunctionArg(rex_function->getOperand(i),
                                             arg0_ti,
                                             /*with_bounds=*/false,  // TODO
                                             /*with_render_group=*/false,
                                             /*expand_geo_col=*/false,
                                             /*is_projection = */ false,
                                             /*use_geo_expressions=*/true);
      if (arg0_ti.get_input_srid() != arg0_ti.get_output_srid() &&
          arg0_ti.get_output_srid() > 0 &&
          std::dynamic_pointer_cast<Analyzer::ColumnVar>(geoargs.front())) {
        // legacy transform
        CHECK(legacy_transform_srid == 0 ||
              legacy_transform_srid == arg0_ti.get_output_srid());
        legacy_transform_srid = arg0_ti.get_output_srid();
      }
      args.insert(args.end(), geoargs.begin(), geoargs.end());
    }
    return makeExpr<Analyzer::GeoOperator>(
        SQLTypeInfo(kDOUBLE, /*not_null=*/false),
        function_name,
        args,
        legacy_transform_srid > 0 ? std::make_optional<int>(legacy_transform_srid)
                                  : std::nullopt);
  }

  bool swap_args = false;
  bool with_bounds = false;
  bool negate_result = false;
  Analyzer::ExpressionPtr threshold_expr = nullptr;
  Analyzer::ExpressionPtr compare_expr = nullptr;
  if (function_name == "ST_DWithin"sv) {
    CHECK_EQ(size_t(3), rex_function->size());
    function_name = "ST_Distance";
    return_type = SQLTypeInfo(kDOUBLE, false);
    // Inject ST_DWithin's short-circuiting threshold into ST_MaxDistance
    threshold_expr = translateScalarRex(rex_function->getOperand(2));
  } else if (function_name == "ST_Equals"sv) {
    // Translate ST_Equals(g1,g2) to ST_Distance(g1,g2)<=0.0
    CHECK_EQ(size_t(2), rex_function->size());
    function_name = "ST_Distance";
    return_type = SQLTypeInfo(kDOUBLE, false);
    threshold_expr = nullptr;
    Datum d;
    d.doubleval = 0.0;
    compare_expr = makeExpr<Analyzer::Constant>(kDOUBLE, false, d);
  } else if (function_name == "ST_DFullyWithin"sv) {
    CHECK_EQ(size_t(3), rex_function->size());
    function_name = "ST_MaxDistance";
    return_type = SQLTypeInfo(kDOUBLE, false);
    // TODO: inject ST_DFullyWithin's short-circuiting threshold into ST_MaxDistance
    threshold_expr = nullptr;
  } else if (function_name == "ST_Distance"sv) {
    // TODO: pick up an outside short-circuiting threshold and inject into ST_Distance
    threshold_expr = nullptr;
  } else if (function_name == "ST_MaxDistance"sv) {
    // TODO: pick up an outside short-circuiting threshold and inject into
    // ST_MaxDistance
    threshold_expr = nullptr;
  } else {
    CHECK_EQ(size_t(2), rex_function->size());
  }
  if (function_name == "ST_Within"sv) {
    function_name = "ST_Contains";
    swap_args = true;
  } else if (function_name == "ST_Disjoint"sv) {
    function_name = "ST_Intersects";
    negate_result = true;
  }
  if (func_resolve(
          function_name, "ST_Contains"sv, "ST_Intersects"sv, "ST_Approx_Overlaps"sv)) {
    with_bounds = true;
  }

  std::vector<std::shared_ptr<Analyzer::Expr>> geoargs;
  SQLTypeInfo arg0_ti;
  SQLTypeInfo arg1_ti;

  // Proactively try to compress the first arg of ST_Intersects to preempt arg swap
  bool try_to_compress_arg0 = g_enable_geo_ops_on_uncompressed_coords &&
                              func_resolve(function_name, "ST_Intersects"sv);

  auto geoargs0 = translateGeoFunctionArg(rex_function->getOperand(swap_args ? 1 : 0),
                                          arg0_ti,
                                          with_bounds,
                                          false,
                                          false,
                                          false,
                                          false,
                                          try_to_compress_arg0);
  geoargs.insert(geoargs.end(), geoargs0.begin(), geoargs0.end());

  // If first arg is compressed, try to compress the second one to be able to
  // switch to faster implementations working directly on uncompressed coords
  bool try_to_compress_arg1 =
      (g_enable_geo_ops_on_uncompressed_coords &&
       func_resolve(function_name, "ST_Contains"sv, "ST_Intersects"sv) &&
       arg0_ti.get_compression() == kENCODING_GEOINT &&
       arg0_ti.get_output_srid() == 4326);

  auto geoargs1 = translateGeoFunctionArg(rex_function->getOperand(swap_args ? 0 : 1),
                                          arg1_ti,
                                          with_bounds,
                                          false,
                                          false,
                                          false,
                                          false,
                                          try_to_compress_arg1);
  geoargs.insert(geoargs.end(), geoargs1.begin(), geoargs1.end());

  if (arg0_ti.get_subtype() != kNULLT && arg0_ti.get_subtype() != arg1_ti.get_subtype()) {
    throw QueryNotSupported(rex_function->getName() +
                            " accepts either two GEOGRAPHY or two GEOMETRY arguments");
  }
  // Check SRID match if at least one is set/valid
  if ((arg0_ti.get_output_srid() > 0 || arg1_ti.get_output_srid() > 0) &&
      arg0_ti.get_output_srid() != arg1_ti.get_output_srid()) {
    throw QueryNotSupported(rex_function->getName() + " cannot accept different SRIDs");
  }
  if (compare_expr) {
    // We could fold the check to false here if argument geo types are different, e.g.
    // POLYGON vs POINT. However, tiny POLYGON could be "spatially" equal to a POINT.
    if (arg0_ti.get_type() != kPOINT || arg1_ti.get_type() != kPOINT) {
      // ST_Equals is translated to a simple distance check for POINTs,
      // otherwise geometries are passed to GEOS's Equals
      return nullptr;
    }
    // Look at POINT compression modes.
    if (arg0_ti.get_compression() != arg1_ti.get_compression()) {
      if ((arg0_ti.get_compression() == kENCODING_GEOINT &&
           arg0_ti.get_comp_param() == 32 &&
           arg1_ti.get_compression() == kENCODING_NONE) ||
          (arg0_ti.get_compression() == kENCODING_NONE &&
           arg1_ti.get_compression() == kENCODING_GEOINT &&
           arg0_ti.get_comp_param() == 32)) {
        // Spatial equality comparison of a compressed point vs uncompressed point.
        // Introduce tolerance into distance calculation and comparison, translate
        // ST_Equals(g1,g2) to ST_Distance(g1,g2,thereshold=tolerance)<=tolerance
        Datum tolerance;
        // Tolerance representing 0.44" to cover shifts due to GEOINT(32) compression
        tolerance.doubleval = TOLERANCE_GEOINT32;
        threshold_expr = makeExpr<Analyzer::Constant>(kDOUBLE, false, tolerance);
        compare_expr = threshold_expr;
      } else {
        throw QueryNotSupported(
            rex_function->getName() +
            " unable to calculate compression tolerance for arguments");
      }
    }
  }

  auto can_use_compressed_coords = [](const SQLTypeInfo& i0_ti,
                                      const Analyzer::ExpressionPtrVector& i0_operands,
                                      const SQLTypeInfo& i1_ti,
                                      const Analyzer::ExpressionPtrVector& i1_operands) {
    const bool i0_is_poly =
        i0_ti.get_type() == kPOLYGON || i0_ti.get_type() == kMULTIPOLYGON;
    const bool i1_is_point = i1_ti.get_type() == kPOINT;
    const bool i1_is_literal =
        i1_operands.size() == 1 && std::dynamic_pointer_cast<const Analyzer::Constant>(
                                       i1_operands.front()) != nullptr;
    return (i0_is_poly && !i1_is_literal && i1_is_point &&
            i0_ti.get_compression() == kENCODING_GEOINT &&
            i0_ti.get_input_srid() == i0_ti.get_output_srid() &&
            i0_ti.get_compression() == i1_ti.get_compression() &&
            i1_ti.get_input_srid() == i1_ti.get_output_srid());
  };
  if (g_enable_geo_ops_on_uncompressed_coords && function_name == "ST_Contains"sv) {
    if (can_use_compressed_coords(arg0_ti, geoargs0, arg1_ti, geoargs1)) {
      // Switch to Contains implementation working directly on uncompressed coords
      function_name = "ST_cContains";
    }
  }
  if (g_enable_geo_ops_on_uncompressed_coords && function_name == "ST_Intersects"sv) {
    if (can_use_compressed_coords(arg0_ti, geoargs0, arg1_ti, geoargs1)) {
      // Switch to Intersects implementation working directly on uncompressed coords
      function_name = "ST_cIntersects";
    } else if (can_use_compressed_coords(arg1_ti, geoargs1, arg0_ti, geoargs0)) {
      // Switch to Intersects implementation working on uncompressed coords, swapped args
      function_name = "ST_cIntersects";
      geoargs.clear();
      geoargs.insert(geoargs.end(), geoargs1.begin(), geoargs1.end());
      geoargs.insert(geoargs.end(), geoargs0.begin(), geoargs0.end());
      auto tmp_ti = arg0_ti;
      arg0_ti = arg1_ti;
      arg1_ti = tmp_ti;
    }
  }

  std::string specialized_geofunc{function_name + suffix(arg0_ti.get_type()) +
                                  suffix(arg1_ti.get_type())};

  if (arg0_ti.get_subtype() == kGEOGRAPHY && arg0_ti.get_output_srid() == 4326) {
    // Need to call geodesic runtime functions
    if (function_name == "ST_Distance"sv) {
      if ((arg0_ti.get_type() == kPOINT && arg1_ti.get_type() == kPOINT) ||
          (arg0_ti.get_type() == kLINESTRING && arg1_ti.get_type() == kPOINT) ||
          (arg0_ti.get_type() == kPOINT && arg1_ti.get_type() == kLINESTRING)) {
        // Geodesic distance between points
        specialized_geofunc += "_Geodesic"s;
      } else {
        throw QueryNotSupported(function_name +
                                " currently doesn't accept non-POINT geographies");
      }
    } else if (rex_function->getName() == "ST_Contains"sv) {
      // We currently don't have a geodesic implementation of ST_Contains,
      // allowing calls to a [less precise] cartesian implementation.
    } else {
      throw QueryNotSupported(function_name + " doesn't accept geographies");
    }
  } else if (function_name == "ST_Distance"sv && rex_function->size() == 3) {
    if (arg0_ti.get_type() == kPOINT && arg1_ti.get_type() == kPOINT) {
      // Cartesian distance between points used by ST_DWithin - switch to faster Squared
      specialized_geofunc += "_Squared"s;
    }
  }

  // Add first input's compression mode and SRID args to enable on-the-fly
  // decompression/transforms
  Datum input_compression0;
  input_compression0.intval = Geospatial::get_compression_scheme(arg0_ti);
  geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression0));
  Datum input_srid0;
  input_srid0.intval = arg0_ti.get_input_srid();
  geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_srid0));

  // Add second input's compression mode and SRID args to enable on-the-fly
  // decompression/transforms
  Datum input_compression1;
  input_compression1.intval = Geospatial::get_compression_scheme(arg1_ti);
  geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression1));
  Datum input_srid1;
  input_srid1.intval = arg1_ti.get_input_srid();
  geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_srid1));

  // Add output SRID arg to enable on-the-fly transforms
  Datum output_srid;
  output_srid.intval = arg0_ti.get_output_srid();
  geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, output_srid));

  // Some geo distance functions will be injected with a short-circuit threshold.
  // Threshold value would come from Geo comparison operations or from other outer
  // geo operations, e.g. ST_DWithin
  // At this point, only ST_Distance_LineString_LineString requires a threshold arg.
  // TODO: Other combinations that involve LINESTRING, POLYGON and MULTIPOLYGON args
  // TODO: Inject threshold into ST_MaxDistance
  if (function_name == "ST_Distance"sv && arg0_ti.get_subtype() != kGEOGRAPHY &&
      (arg0_ti.get_type() != kPOINT || arg1_ti.get_type() != kPOINT)) {
    if (threshold_expr) {
      if (threshold_expr->get_type_info().get_type() != kDOUBLE) {
        const auto& threshold_ti = SQLTypeInfo(kDOUBLE, false);
        threshold_expr = threshold_expr->add_cast(threshold_ti);
      }
      threshold_expr = fold_expr(threshold_expr.get());
    } else {
      Datum d;
      d.doubleval = 0.0;
      threshold_expr = makeExpr<Analyzer::Constant>(kDOUBLE, false, d);
    }
    geoargs.push_back(threshold_expr);
  }

  auto result =
      makeExpr<Analyzer::FunctionOper>(return_type, specialized_geofunc, geoargs);
  if (negate_result) {
    return makeExpr<Analyzer::UOper>(kBOOLEAN, kNOT, result);
  }
  if (compare_expr) {
    return makeExpr<Analyzer::BinOper>(kBOOLEAN, kLE, kONE, result, compare_expr);
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateBinaryGeoPredicate ( const RexFunctionOperator *  rex_function, SQLTypeInfo &  ti, const bool  with_bounds  ) const

private

Definition at line 1016 of file RelAlgTranslatorGeo.cpp.

References RexFunctionOperator::getName(), RexOperator::getOperand(), kBOOLEAN, Geospatial::GeoBase::kEQUALS, and translateGeoFunctionArg().

Referenced by translateFunction(), and translateGeoFunctionArg().

                                  {
  if (rex_function->getName() != "ST_Equals"sv) {
    throw QueryNotSupported(rex_function->getName() + " geo predicate is not supported");
  }
#ifndef ENABLE_GEOS
  throw QueryNotSupported(rex_function->getName() +
                          " geo predicate requires enabled GEOS support");
#endif
  SQLTypeInfo arg0_ti;
  auto geoargs0 = translateGeoFunctionArg(
      rex_function->getOperand(0), arg0_ti, false, false, true, true);
  SQLTypeInfo arg1_ti;
  auto geoargs1 = translateGeoFunctionArg(
      rex_function->getOperand(1), arg1_ti, false, false, true, true);
  ti = SQLTypeInfo(kBOOLEAN, false);
  auto op = Geospatial::GeoBase::GeoOp::kEQUALS;
  return makeExpr<Analyzer::GeoBinOper>(op, ti, arg0_ti, arg1_ti, geoargs0, geoargs1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Analyzer::ExpressionPtr RelAlgTranslator::translateCardinality ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1387 of file RelAlgTranslator.cpp.

References RexFunctionOperator::getName(), RexOperator::getOperand(), RexOperator::getType(), kARRAY, anonymous_namespace{RelAlgTranslator.cpp}::makeNumericConstant(), and translateScalarRex().

Referenced by translateFunction().

                                                   {
  const auto ret_ti = rex_function->getType();
  const auto arg = translateScalarRex(rex_function->getOperand(0));
  const auto arg_ti = arg->get_type_info();
  if (!arg_ti.is_array()) {
    throw std::runtime_error(rex_function->getName() + " expects an array expression.");
  }
  if (arg_ti.get_subtype() == kARRAY) {
    throw std::runtime_error(rex_function->getName() +
                             " expects one-dimension array expression.");
  }
  const auto array_size = arg_ti.get_size();
  const auto array_elem_size = arg_ti.get_elem_type().get_array_context_logical_size();

  if (array_size > 0) {
    if (array_elem_size <= 0) {
      throw std::runtime_error(rex_function->getName() +
                               ": unexpected array element type.");
    }
    // Return cardinality of a fixed length array
    return makeNumericConstant(ret_ti, array_size / array_elem_size);
  }
  // Variable length array cardinality will be calculated at runtime
  return makeExpr<Analyzer::CardinalityExpr>(arg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateCase ( const RexCase *  rex_case ) const

private

Definition at line 969 of file RelAlgTranslator.cpp.

References RexCase::branchCount(), executor_, RexCase::getElse(), RexCase::getThen(), RexCase::getWhen(), Parser::CaseExpr::normalize(), and translateScalarRex().

Referenced by translateScalarRex().

                                   {
  std::shared_ptr<Analyzer::Expr> else_expr;
  std::list<std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>
      expr_list;
  for (size_t i = 0; i < rex_case->branchCount(); ++i) {
    const auto when_expr = translateScalarRex(rex_case->getWhen(i));
    const auto then_expr = translateScalarRex(rex_case->getThen(i));
    expr_list.emplace_back(when_expr, then_expr);
  }
  if (rex_case->getElse()) {
    else_expr = translateScalarRex(rex_case->getElse());
  }
  return Parser::CaseExpr::normalize(expr_list, else_expr, executor_);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateCurrentDate ( ) const

private

Definition at line 1423 of file RelAlgTranslator.cpp.

References Datum::bigintval, is_null(), kDATE, and now_.

Referenced by translateFunction().

                                                                         {
  constexpr bool is_null = false;
  Datum datum;
  datum.bigintval = now_ - now_ % (24 * 60 * 60);  // Assumes 0 < now_.
  return makeExpr<Analyzer::Constant>(kDATE, is_null, datum);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateCurrentTime ( ) const

private

Definition at line 1430 of file RelAlgTranslator.cpp.

References Datum::bigintval, is_null(), kTIME, and now_.

Referenced by translateFunction().

                                                                         {
  constexpr bool is_null = false;
  Datum datum;
  datum.bigintval = now_ % (24 * 60 * 60);  // Assumes 0 < now_.
  return makeExpr<Analyzer::Constant>(kTIME, is_null, datum);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateCurrentTimestamp ( ) const

private

Definition at line 1437 of file RelAlgTranslator.cpp.

References Parser::TimestampLiteral::get(), and now_.

Referenced by translateDatetime(), and translateFunction().

                                                                              {
  return Parser::TimestampLiteral::get(now_);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateCurrentUser ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1314 of file RelAlgTranslator.cpp.

References Parser::UserLiteral::get(), and query_state_.

Referenced by translateFunction().

                                                   {
  std::string user{"SESSIONLESS_USER"};
  if (query_state_) {
    user = query_state_->getConstSessionInfo()->get_currentUser().userName;
  }
  return Parser::UserLiteral::get(user);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateDateadd ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1143 of file RelAlgTranslator.cpp.

References CHECK_EQ, field(), RexOperator::getOperand(), kBIGINT, kTIME, kTIMESTAMP, RexOperator::size(), to_dateadd_field(), translateScalarRex(), and anonymous_namespace{RelAlgTranslator.cpp}::validate_datetime_datepart_argument().

Referenced by translateFunction().

                                                   {
  CHECK_EQ(size_t(3), rex_function->size());
  const auto timeunit = translateScalarRex(rex_function->getOperand(0));
  const auto timeunit_lit = std::dynamic_pointer_cast<Analyzer::Constant>(timeunit);
  validate_datetime_datepart_argument(timeunit_lit);
  const auto number_units = translateScalarRex(rex_function->getOperand(1));
  const auto number_units_const =
      std::dynamic_pointer_cast<Analyzer::Constant>(number_units);
  if (number_units_const && number_units_const->get_is_null()) {
    throw std::runtime_error("The 'Interval' argument literal must not be 'null'.");
  }
  const auto cast_number_units = number_units->add_cast(SQLTypeInfo(kBIGINT, false));
  const auto datetime = translateScalarRex(rex_function->getOperand(2));
  const auto& datetime_ti = datetime->get_type_info();
  if (datetime_ti.get_type() == kTIME) {
    throw std::runtime_error("DateAdd operation not supported for TIME.");
  }
  const auto& field = to_dateadd_field(*timeunit_lit->get_constval().stringval);
  const int dim = datetime_ti.get_dimension();
  return makeExpr<Analyzer::DateaddExpr>(
      SQLTypeInfo(kTIMESTAMP, dim, 0, false), field, cast_number_units, datetime);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateDatediff ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1258 of file RelAlgTranslator.cpp.

References CHECK_EQ, field(), RexOperator::getOperand(), kBIGINT, RexOperator::size(), to_datediff_field(), translateScalarRex(), and anonymous_namespace{RelAlgTranslator.cpp}::validate_datetime_datepart_argument().

Referenced by translateFunction().

                                                   {
  CHECK_EQ(size_t(3), rex_function->size());
  const auto timeunit = translateScalarRex(rex_function->getOperand(0));
  const auto timeunit_lit = std::dynamic_pointer_cast<Analyzer::Constant>(timeunit);
  validate_datetime_datepart_argument(timeunit_lit);
  const auto start = translateScalarRex(rex_function->getOperand(1));
  const auto end = translateScalarRex(rex_function->getOperand(2));
  const auto field = to_datediff_field(*timeunit_lit->get_constval().stringval);
  return makeExpr<Analyzer::DatediffExpr>(SQLTypeInfo(kBIGINT, false), field, start, end);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateDatepart ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1270 of file RelAlgTranslator.cpp.

References CHECK_EQ, ExtractExpr::generate(), RexOperator::getOperand(), RexOperator::size(), to_datepart_field(), translateScalarRex(), and anonymous_namespace{RelAlgTranslator.cpp}::validate_datetime_datepart_argument().

Referenced by translateFunction().

                                                   {
  CHECK_EQ(size_t(2), rex_function->size());
  const auto timeunit = translateScalarRex(rex_function->getOperand(0));
  const auto timeunit_lit = std::dynamic_pointer_cast<Analyzer::Constant>(timeunit);
  validate_datetime_datepart_argument(timeunit_lit);
  const auto from_expr = translateScalarRex(rex_function->getOperand(1));
  return ExtractExpr::generate(
      from_expr, to_datepart_field(*timeunit_lit->get_constval().stringval));
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateDatePlusMinus ( const RexOperator *  rex_operator ) const

private

Definition at line 1176 of file RelAlgTranslator.cpp.

References run_benchmark_import::args, CHECK, daMONTH, daSECOND, dtMONTH, dtSECOND, fold_expr(), anonymous_namespace{RelAlgTranslator.cpp}::get_datetimeplus_rewrite_funcname(), RexOperator::getOperand(), RexOperator::getOperator(), RexOperator::getType(), kBIGINT, kDATE, kDIVIDE, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kMINUS, kMULTIPLY, kONE, kPLUS, kTIME, kTIMESTAMP, kUMINUS, anonymous_namespace{RelAlgTranslator.cpp}::makeNumericConstant(), run_benchmark_import::result, rewrite_to_date_trunc(), RexOperator::size(), and translateScalarRex().

Referenced by translateOper().

                                           {
  if (rex_operator->size() != 2) {
    return nullptr;
  }
  const auto datetime = translateScalarRex(rex_operator->getOperand(0));
  const auto datetime_ti = datetime->get_type_info();
  if (!datetime_ti.is_timestamp() && !datetime_ti.is_date()) {
    if (datetime_ti.get_type() == kTIME) {
      throw std::runtime_error("DateTime addition/subtraction not supported for TIME.");
    }
    return nullptr;
  }
  const auto rhs = translateScalarRex(rex_operator->getOperand(1));
  const auto rhs_ti = rhs->get_type_info();
  if (rhs_ti.get_type() == kTIMESTAMP || rhs_ti.get_type() == kDATE) {
    if (datetime_ti.is_high_precision_timestamp() ||
        rhs_ti.is_high_precision_timestamp()) {
      throw std::runtime_error(
          "High Precision timestamps are not supported for TIMESTAMPDIFF operation. "
          "Use "
          "DATEDIFF.");
    }
    auto bigint_ti = SQLTypeInfo(kBIGINT, false);
    const auto& rex_operator_ti = rex_operator->getType();
    const auto datediff_field =
        (rex_operator_ti.get_type() == kINTERVAL_DAY_TIME) ? dtSECOND : dtMONTH;
    auto result =
        makeExpr<Analyzer::DatediffExpr>(bigint_ti, datediff_field, rhs, datetime);
    // multiply 1000 to result since expected result should be in millisecond precision.
    if (rex_operator_ti.get_type() == kINTERVAL_DAY_TIME) {
      return makeExpr<Analyzer::BinOper>(bigint_ti.get_type(),
                                         kMULTIPLY,
                                         kONE,
                                         result,
                                         makeNumericConstant(bigint_ti, 1000));
    } else {
      return result;
    }
  }
  const auto op = rex_operator->getOperator();
  if (op == kPLUS) {
    std::vector<std::shared_ptr<Analyzer::Expr>> args = {datetime, rhs};
    auto dt_plus = makeExpr<Analyzer::FunctionOper>(
        datetime_ti, get_datetimeplus_rewrite_funcname(op), args);
    const auto date_trunc = rewrite_to_date_trunc(dt_plus.get());
    if (date_trunc) {
      return date_trunc;
    }
  }
  const auto interval = fold_expr(rhs.get());
  auto interval_ti = interval->get_type_info();
  auto bigint_ti = SQLTypeInfo(kBIGINT, false);
  const auto interval_lit = std::dynamic_pointer_cast<Analyzer::Constant>(interval);
  if (interval_ti.get_type() == kINTERVAL_DAY_TIME) {
    std::shared_ptr<Analyzer::Expr> interval_sec;
    if (interval_lit) {
      interval_sec =
          makeNumericConstant(bigint_ti,
                              (op == kMINUS ? -interval_lit->get_constval().bigintval
                                            : interval_lit->get_constval().bigintval) /
                                  1000);
    } else {
      interval_sec = makeExpr<Analyzer::BinOper>(bigint_ti.get_type(),
                                                 kDIVIDE,
                                                 kONE,
                                                 interval,
                                                 makeNumericConstant(bigint_ti, 1000));
      if (op == kMINUS) {
        interval_sec =
            std::make_shared<Analyzer::UOper>(bigint_ti, false, kUMINUS, interval_sec);
      }
    }
    return makeExpr<Analyzer::DateaddExpr>(datetime_ti, daSECOND, interval_sec, datetime);
  }
  CHECK(interval_ti.get_type() == kINTERVAL_YEAR_MONTH);
  const auto interval_months = op == kMINUS ? std::make_shared<Analyzer::UOper>(
                                                  bigint_ti, false, kUMINUS, interval)
                                            : interval;
  return makeExpr<Analyzer::DateaddExpr>(datetime_ti, daMONTH, interval_months, datetime);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateDatetime ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1441 of file RelAlgTranslator.cpp.

References CHECK, CHECK_EQ, RexOperator::getOperand(), RexOperator::size(), translateCurrentTimestamp(), and translateScalarRex().

Referenced by translateFunction().

                                                   {
  CHECK_EQ(size_t(1), rex_function->size());
  const auto arg = translateScalarRex(rex_function->getOperand(0));
  const auto arg_lit = std::dynamic_pointer_cast<Analyzer::Constant>(arg);
  const std::string datetime_err{R"(Only DATETIME('NOW') supported for now.)"};
  if (!arg_lit || arg_lit->get_is_null()) {
    throw std::runtime_error(datetime_err);
  }
  CHECK(arg_lit->get_type_info().is_string());
  if (*arg_lit->get_constval().stringval != "NOW"sv) {
    throw std::runtime_error(datetime_err);
  }
  return translateCurrentTimestamp();
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateExtract ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1084 of file RelAlgTranslator.cpp.

References CHECK_EQ, ExtractExpr::generate(), DateTruncExpr::generate(), RexFunctionOperator::getName(), RexOperator::getOperand(), RexOperator::size(), translateScalarRex(), and anonymous_namespace{RelAlgTranslator.cpp}::validate_datetime_datepart_argument().

Referenced by translateFunction().

                                                   {
  CHECK_EQ(size_t(2), rex_function->size());
  const auto timeunit = translateScalarRex(rex_function->getOperand(0));
  const auto timeunit_lit = std::dynamic_pointer_cast<Analyzer::Constant>(timeunit);
  validate_datetime_datepart_argument(timeunit_lit);
  const auto from_expr = translateScalarRex(rex_function->getOperand(1));
  const bool is_date_trunc = rex_function->getName() == "PG_DATE_TRUNC"sv;
  if (is_date_trunc) {
    return DateTruncExpr::generate(from_expr, *timeunit_lit->get_constval().stringval);
  } else {
    return ExtractExpr::generate(from_expr, *timeunit_lit->get_constval().stringval);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateFunction ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1554 of file RelAlgTranslator.cpp.

References run_benchmark_import::args, bind_function(), CHECK, CHECK_EQ, ext_arg_type_to_type_info(), func_resolve, RexFunctionOperator::getName(), RexOperator::getOperand(), RexOperator::getType(), SQLTypeInfo::is_decimal(), kDIVIDE, kONE, kSMALLINT, kTEXT, LOG, Parser::OperExpr::normalize(), rewrite_to_date_trunc(), SQLTypeInfo::set_notnull(), RexOperator::size(), Datum::smallintval, translateAbs(), translateArrayFunction(), translateBinaryGeoConstructor(), translateBinaryGeoFunction(), translateBinaryGeoPredicate(), translateCardinality(), translateCurrentDate(), translateCurrentTime(), translateCurrentTimestamp(), translateCurrentUser(), translateDateadd(), translateDatediff(), translateDatepart(), translateDatetime(), translateExtract(), translateFunctionArgs(), translateFunctionWithGeoArg(), translateGeoProjection(), translateHPTLiteral(), translateItem(), translateKeyForString(), translateLength(), translateLike(), translateLikely(), translateOffsetInFragment(), translateRegexp(), translateSampleRatio(), translateScalarRex(), translateSign(), translateStringOper(), translateTernaryGeoFunction(), translateUnaryGeoFunction(), translateUnaryGeoPredicate(), translateUnlikely(), translateWidthBucket(), and logger::WARNING.

Referenced by translateScalarRex().

                                                   {
  if (func_resolve(rex_function->getName(), "LIKE"sv, "PG_ILIKE"sv)) {
    return translateLike(rex_function);
  }
  if (rex_function->getName() == "REGEXP_LIKE"sv) {
    return translateRegexp(rex_function);
  }
  if (rex_function->getName() == "LIKELY"sv) {
    return translateLikely(rex_function);
  }
  if (rex_function->getName() == "UNLIKELY"sv) {
    return translateUnlikely(rex_function);
  }
  if (func_resolve(rex_function->getName(), "PG_EXTRACT"sv, "PG_DATE_TRUNC"sv)) {
    return translateExtract(rex_function);
  }
  if (rex_function->getName() == "DATEADD"sv) {
    return translateDateadd(rex_function);
  }
  if (rex_function->getName() == "DATEDIFF"sv) {
    return translateDatediff(rex_function);
  }
  if (rex_function->getName() == "DATEPART"sv) {
    return translateDatepart(rex_function);
  }
  if (func_resolve(rex_function->getName(), "LENGTH"sv, "CHAR_LENGTH"sv)) {
    return translateLength(rex_function);
  }
  if (rex_function->getName() == "KEY_FOR_STRING"sv) {
    return translateKeyForString(rex_function);
  }
  if (rex_function->getName() == "WIDTH_BUCKET"sv) {
    return translateWidthBucket(rex_function);
  }
  if (rex_function->getName() == "SAMPLE_RATIO"sv) {
    return translateSampleRatio(rex_function);
  }
  if (rex_function->getName() == "CURRENT_USER"sv) {
    return translateCurrentUser(rex_function);
  }
  if (func_resolve(rex_function->getName(),
                   "LOWER"sv,
                   "UPPER"sv,
                   "INITCAP"sv,
                   "REVERSE"sv,
                   "REPEAT"sv,
                   "||"sv,
                   "LPAD"sv,
                   "RPAD"sv,
                   "TRIM"sv,
                   "LTRIM"sv,
                   "RTRIM"sv,
                   "SUBSTRING"sv,
                   "OVERLAY"sv,
                   "REPLACE"sv,
                   "SPLIT_PART"sv,
                   "REGEXP_REPLACE"sv,
                   "REGEXP_SUBSTR"sv,
                   "REGEXP_MATCH"sv)) {
    return translateStringOper(rex_function);
  }
  if (func_resolve(rex_function->getName(), "CARDINALITY"sv, "ARRAY_LENGTH"sv)) {
    return translateCardinality(rex_function);
  }
  if (rex_function->getName() == "ITEM"sv) {
    return translateItem(rex_function);
  }
  if (rex_function->getName() == "CURRENT_DATE"sv) {
    return translateCurrentDate();
  }
  if (rex_function->getName() == "CURRENT_TIME"sv) {
    return translateCurrentTime();
  }
  if (rex_function->getName() == "CURRENT_TIMESTAMP"sv) {
    return translateCurrentTimestamp();
  }
  if (rex_function->getName() == "NOW"sv) {
    return translateCurrentTimestamp();
  }
  if (rex_function->getName() == "DATETIME"sv) {
    return translateDatetime(rex_function);
  }
  if (func_resolve(rex_function->getName(), "usTIMESTAMP"sv, "nsTIMESTAMP"sv)) {
    return translateHPTLiteral(rex_function);
  }
  if (rex_function->getName() == "ABS"sv) {
    return translateAbs(rex_function);
  }
  if (rex_function->getName() == "SIGN"sv) {
    return translateSign(rex_function);
  }
  if (func_resolve(rex_function->getName(), "CEIL"sv, "FLOOR"sv)) {
    return makeExpr<Analyzer::FunctionOperWithCustomTypeHandling>(
        rex_function->getType(),
        rex_function->getName(),
        translateFunctionArgs(rex_function));
  } else if (rex_function->getName() == "ROUND"sv) {
    std::vector<std::shared_ptr<Analyzer::Expr>> args =
        translateFunctionArgs(rex_function);

    if (rex_function->size() == 1) {
      // push a 0 constant if 2nd operand is missing.
      // this needs to be done as calcite returns
      // only the 1st operand without defaulting the 2nd one
      // when the user did not specify the 2nd operand.
      SQLTypes t = kSMALLINT;
      Datum d;
      d.smallintval = 0;
      args.push_back(makeExpr<Analyzer::Constant>(t, false, d));
    }

    // make sure we have only 2 operands
    CHECK(args.size() == 2);

    if (!args[0]->get_type_info().is_number()) {
      throw std::runtime_error("Only numeric 1st operands are supported");
    }

    // the 2nd operand does not need to be a constant
    // it can happily reference another integer column
    if (!args[1]->get_type_info().is_integer()) {
      throw std::runtime_error("Only integer 2nd operands are supported");
    }

    // Calcite may upcast decimals in a way that is
    // incompatible with the extension function input. Play it safe and stick with the
    // argument type instead.
    const SQLTypeInfo ret_ti = args[0]->get_type_info().is_decimal()
                                   ? args[0]->get_type_info()
                                   : rex_function->getType();

    return makeExpr<Analyzer::FunctionOperWithCustomTypeHandling>(
        ret_ti, rex_function->getName(), args);
  }
  if (rex_function->getName() == "DATETIME_PLUS"sv) {
    auto dt_plus = makeExpr<Analyzer::FunctionOper>(rex_function->getType(),
                                                    rex_function->getName(),
                                                    translateFunctionArgs(rex_function));
    const auto date_trunc = rewrite_to_date_trunc(dt_plus.get());
    if (date_trunc) {
      return date_trunc;
    }
    return translateDateadd(rex_function);
  }
  if (rex_function->getName() == "/INT"sv) {
    CHECK_EQ(size_t(2), rex_function->size());
    std::shared_ptr<Analyzer::Expr> lhs = translateScalarRex(rex_function->getOperand(0));
    std::shared_ptr<Analyzer::Expr> rhs = translateScalarRex(rex_function->getOperand(1));
    const auto rhs_lit = std::dynamic_pointer_cast<Analyzer::Constant>(rhs);
    return Parser::OperExpr::normalize(kDIVIDE, kONE, lhs, rhs);
  }
  if (rex_function->getName() == "Reinterpret"sv) {
    CHECK_EQ(size_t(1), rex_function->size());
    return translateScalarRex(rex_function->getOperand(0));
  }
  if (func_resolve(rex_function->getName(),
                   "ST_X"sv,
                   "ST_Y"sv,
                   "ST_XMin"sv,
                   "ST_YMin"sv,
                   "ST_XMax"sv,
                   "ST_YMax"sv,
                   "ST_NRings"sv,
                   "ST_NPoints"sv,
                   "ST_Length"sv,
                   "ST_Perimeter"sv,
                   "ST_Area"sv,
                   "ST_SRID"sv,
                   "HeavyDB_Geo_PolyBoundsPtr"sv,
                   "HeavyDB_Geo_PolyRenderGroup"sv)) {
    CHECK_EQ(rex_function->size(), size_t(1));
    return translateUnaryGeoFunction(rex_function);
  }
  if (func_resolve(rex_function->getName(),
                   "convert_meters_to_pixel_width"sv,
                   "convert_meters_to_pixel_height"sv,
                   "is_point_in_view"sv,
                   "is_point_size_in_view"sv)) {
    return translateFunctionWithGeoArg(rex_function);
  }
  if (func_resolve(rex_function->getName(),
                   "ST_Distance"sv,
                   "ST_MaxDistance"sv,
                   "ST_Intersects"sv,
                   "ST_Disjoint"sv,
                   "ST_Contains"sv,
                   "ST_Overlaps"sv,
                   "ST_Approx_Overlaps"sv,
                   "ST_Within"sv)) {
    CHECK_EQ(rex_function->size(), size_t(2));
    return translateBinaryGeoFunction(rex_function);
  }
  if (func_resolve(rex_function->getName(), "ST_DWithin"sv, "ST_DFullyWithin"sv)) {
    CHECK_EQ(rex_function->size(), size_t(3));
    return translateTernaryGeoFunction(rex_function);
  }
  if (rex_function->getName() == "OFFSET_IN_FRAGMENT"sv) {
    CHECK_EQ(size_t(0), rex_function->size());
    return translateOffsetInFragment();
  }
  if (rex_function->getName() == "ARRAY"sv) {
    // Var args; currently no check.  Possible fix-me -- can array have 0 elements?
    return translateArrayFunction(rex_function);
  }
  if (func_resolve(rex_function->getName(),
                   "ST_GeomFromText"sv,
                   "ST_GeogFromText"sv,
                   "ST_Centroid"sv,
                   "ST_SetSRID"sv,
                   "ST_Point"sv,  // TODO: where should this and below live?
                   "ST_PointN"sv,
                   "ST_StartPoint"sv,
                   "ST_EndPoint"sv,
                   "ST_Transform"sv)) {
    SQLTypeInfo ti;
    return translateGeoProjection(rex_function, ti, false);
  }
  if (func_resolve(rex_function->getName(),
                   "ST_Intersection"sv,
                   "ST_Difference"sv,
                   "ST_Union"sv,
                   "ST_Buffer"sv)) {
    SQLTypeInfo ti;
    return translateBinaryGeoConstructor(rex_function, ti, false);
  }
  if (func_resolve(rex_function->getName(), "ST_IsEmpty"sv, "ST_IsValid"sv)) {
    CHECK_EQ(rex_function->size(), size_t(1));
    SQLTypeInfo ti;
    return translateUnaryGeoPredicate(rex_function, ti, false);
  }
  if (func_resolve(rex_function->getName(), "ST_Equals"sv)) {
    CHECK_EQ(rex_function->size(), size_t(2));
    // Attempt to generate a distance based check for points
    if (auto distance_check = translateBinaryGeoFunction(rex_function)) {
      return distance_check;
    }
    SQLTypeInfo ti;
    return translateBinaryGeoPredicate(rex_function, ti, false);
  }

  auto arg_expr_list = translateFunctionArgs(rex_function);
  if (rex_function->getName() == std::string("||") ||
      rex_function->getName() == std::string("SUBSTRING")) {
    SQLTypeInfo ret_ti(kTEXT, false);
    return makeExpr<Analyzer::FunctionOper>(
        ret_ti, rex_function->getName(), arg_expr_list);
  }
  // Reset possibly wrong return type of rex_function to the return
  // type of the optimal valid implementation. The return type can be
  // wrong in the case of multiple implementations of UDF functions
  // that have different return types but Calcite specifies the return
  // type according to the first implementation.
  SQLTypeInfo ret_ti;
  try {
    auto ext_func_sig = bind_function(rex_function->getName(), arg_expr_list);

    auto ext_func_args = ext_func_sig.getArgs();
    CHECK_EQ(arg_expr_list.size(), ext_func_args.size());
    for (size_t i = 0; i < arg_expr_list.size(); i++) {
      // fold casts on constants
      if (auto constant =
              std::dynamic_pointer_cast<Analyzer::Constant>(arg_expr_list[i])) {
        auto ext_func_arg_ti = ext_arg_type_to_type_info(ext_func_args[i]);
        if (ext_func_arg_ti != arg_expr_list[i]->get_type_info()) {
          arg_expr_list[i] = constant->add_cast(ext_func_arg_ti);
        }
      }
    }

    ret_ti = ext_arg_type_to_type_info(ext_func_sig.getRet());
  } catch (ExtensionFunctionBindingError& e) {
    LOG(WARNING) << "RelAlgTranslator::translateFunction: " << e.what();
    throw;
  }

  // By default, the extension function type will not allow nulls. If one of the arguments
  // is nullable, the extension function must also explicitly allow nulls.
  bool arguments_not_null = true;
  for (const auto& arg_expr : arg_expr_list) {
    if (!arg_expr->get_type_info().get_notnull()) {
      arguments_not_null = false;
      break;
    }
  }
  ret_ti.set_notnull(arguments_not_null);

  return makeExpr<Analyzer::FunctionOper>(ret_ti, rex_function->getName(), arg_expr_list);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Analyzer::ExpressionPtrVector RelAlgTranslator::translateFunctionArgs ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1923 of file RelAlgTranslator.cpp.

References run_benchmark_import::args, RexOperator::getOperand(), RexOperator::size(), and translateScalarRex().

Referenced by translateArrayFunction(), translateFunction(), translateKeyForString(), and translateStringOper().

                                                   {
  std::vector<std::shared_ptr<Analyzer::Expr>> args;
  for (size_t i = 0; i < rex_function->size(); ++i) {
    args.push_back(translateScalarRex(rex_function->getOperand(i)));
  }
  return args;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateFunctionWithGeoArg ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1673 of file RelAlgTranslatorGeo.cpp.

References run_benchmark_import::args, CHECK, CHECK_EQ, func_resolve, Geospatial::get_compression_scheme(), RexFunctionOperator::getName(), RexOperator::getOperand(), RexOperator::getType(), Datum::intval, kINT, kPOINT, RexOperator::size(), translateGeoFunctionArg(), and translateScalarRex().

Referenced by translateFunction().

                                                   {
  std::string specialized_geofunc{rex_function->getName()};
  if (func_resolve(rex_function->getName(),
                   "convert_meters_to_pixel_width"sv,
                   "convert_meters_to_pixel_height"sv)) {
    CHECK_EQ(rex_function->size(), 6u);
    SQLTypeInfo arg_ti;
    std::vector<std::shared_ptr<Analyzer::Expr>> args;
    args.push_back(translateScalarRex(rex_function->getOperand(0)));
    auto geoargs =
        translateGeoFunctionArg(rex_function->getOperand(1), arg_ti, false, true, false);
    // only works on points
    if (arg_ti.get_type() != kPOINT) {
      throw QueryNotSupported(rex_function->getName() +
                              " expects a point for the second argument");
    }

    args.insert(args.end(), geoargs.begin(), geoargs.begin() + 1);

    // Add compression information
    Datum input_compression;
    input_compression.intval = Geospatial::get_compression_scheme(arg_ti);
    args.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression));
    if (arg_ti.get_input_srid() != 4326) {
      throw QueryNotSupported(
          rex_function->getName() +
          " currently only supports points of with SRID WGS84/EPSG:4326");
    }
    Datum input_srid;
    input_srid.intval = arg_ti.get_input_srid();
    args.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_srid));
    Datum output_srid;
    // Forcing web-mercator projection for now
    // TODO(croot): check that the input-to-output conversion routines exist?
    output_srid.intval =
        arg_ti.get_output_srid() != 900913 ? 900913 : arg_ti.get_output_srid();
    args.push_back(makeExpr<Analyzer::Constant>(kINT, false, output_srid));

    args.push_back(translateScalarRex(rex_function->getOperand(2)));
    args.push_back(translateScalarRex(rex_function->getOperand(3)));
    args.push_back(translateScalarRex(rex_function->getOperand(4)));
    args.push_back(translateScalarRex(rex_function->getOperand(5)));
    return makeExpr<Analyzer::FunctionOper>(
        rex_function->getType(), specialized_geofunc, args);
  } else if (rex_function->getName() == "is_point_in_view"sv) {
    CHECK_EQ(rex_function->size(), 5u);
    SQLTypeInfo arg_ti;
    std::vector<std::shared_ptr<Analyzer::Expr>> args;
    auto geoargs =
        translateGeoFunctionArg(rex_function->getOperand(0), arg_ti, false, true, false);
    // only works on points
    if (arg_ti.get_type() != kPOINT) {
      throw QueryNotSupported(rex_function->getName() +
                              " expects a point for the second argument");
    }

    args.insert(args.end(), geoargs.begin(), geoargs.begin() + 1);

    // Add compression information
    Datum input_compression;
    input_compression.intval = Geospatial::get_compression_scheme(arg_ti);
    args.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression));
    if (arg_ti.get_input_srid() != 4326) {
      throw QueryNotSupported(
          rex_function->getName() +
          " currently only supports points of with SRID WGS84/EPSG:4326");
    }
    args.push_back(translateScalarRex(rex_function->getOperand(1)));
    args.push_back(translateScalarRex(rex_function->getOperand(2)));
    args.push_back(translateScalarRex(rex_function->getOperand(3)));
    args.push_back(translateScalarRex(rex_function->getOperand(4)));
    return makeExpr<Analyzer::FunctionOper>(
        rex_function->getType(), specialized_geofunc, args);
  } else if (rex_function->getName() == "is_point_size_in_view"sv) {
    CHECK_EQ(rex_function->size(), 6u);
    SQLTypeInfo arg_ti;
    std::vector<std::shared_ptr<Analyzer::Expr>> args;
    auto geoargs =
        translateGeoFunctionArg(rex_function->getOperand(0), arg_ti, false, true, false);
    // only works on points
    if (arg_ti.get_type() != kPOINT) {
      throw QueryNotSupported(rex_function->getName() +
                              " expects a point for the second argument");
    }

    args.insert(args.end(), geoargs.begin(), geoargs.begin() + 1);

    // Add compression information
    Datum input_compression;
    input_compression.intval = Geospatial::get_compression_scheme(arg_ti);
    args.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression));
    if (arg_ti.get_input_srid() != 4326) {
      throw QueryNotSupported(
          rex_function->getName() +
          " currently only supports points of with SRID WGS84/EPSG:4326");
    }
    args.push_back(translateScalarRex(rex_function->getOperand(1)));
    args.push_back(translateScalarRex(rex_function->getOperand(2)));
    args.push_back(translateScalarRex(rex_function->getOperand(3)));
    args.push_back(translateScalarRex(rex_function->getOperand(4)));
    args.push_back(translateScalarRex(rex_function->getOperand(5)));
    return makeExpr<Analyzer::FunctionOper>(
        rex_function->getType(), specialized_geofunc, args);
  }
  CHECK(false);
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< std::shared_ptr< Analyzer::Expr > > RelAlgTranslator::translateGeoColumn ( const RexInput *  rex_input, SQLTypeInfo &  ti, const bool  with_bounds, const bool  with_render_group, const bool  expand_geo_col  ) const

private

Definition at line 28 of file RelAlgTranslatorGeo.cpp.

References run_benchmark_import::args, cat_, CHECK, CHECK_GE, CHECK_LT, ColumnDescriptor::columnType, SQLTypeInfo::get_physical_coord_cols(), SQLTypeInfo::get_type(), RexAbstractInput::getIndex(), Catalog_Namespace::Catalog::getMetadataForColumnBySpi(), RexInput::getSourceNode(), SQLTypeInfo::has_bounds(), SQLTypeInfo::has_render_group(), input_to_nest_level_, IS_GEO, and SPIMAP_GEO_PHYSICAL_INPUT.

Referenced by translateBinaryGeoFunction(), translateGeoFunctionArg(), and translateGeoOverlapsOper().

                                     {
  std::vector<std::shared_ptr<Analyzer::Expr>> args;
  const auto source = rex_input->getSourceNode();
  const auto it_rte_idx = input_to_nest_level_.find(source);
  CHECK(it_rte_idx != input_to_nest_level_.end());
  const int rte_idx = it_rte_idx->second;
  const auto& in_metainfo = source->getOutputMetainfo();

  int32_t table_id{0};
  int column_id{-1};
  const auto scan_source = dynamic_cast<const RelScan*>(source);
  if (scan_source) {
    // We're at leaf (scan) level and not supposed to have input metadata,
    // the name and type information come directly from the catalog.
    CHECK(in_metainfo.empty());

    const auto td = scan_source->getTableDescriptor();
    table_id = td->tableId;

    const auto gcd = cat_.getMetadataForColumnBySpi(table_id, rex_input->getIndex() + 1);
    CHECK(gcd);
    ti = gcd->columnType;
    column_id = gcd->columnId;

  } else {
    // Likely backed by a temp table. Read the table ID from the source node and negate it
    // (see RelAlgTranslator::translateInput)
    table_id = -source->getId();

    if (with_bounds || with_render_group) {
      throw QueryNotSupported(
          "Geospatial columns not yet supported in intermediate results.");
    }

    CHECK(!in_metainfo.empty());
    CHECK_GE(rte_idx, 0);
    column_id = rex_input->getIndex();
    CHECK_LT(static_cast<size_t>(column_id), in_metainfo.size());
    ti = in_metainfo[column_id].get_type_info();
    if (expand_geo_col && ti.is_geometry()) {
      throw QueryNotSupported(
          "Geospatial columns not yet supported in this temporary table context.");
    }
  }

  if (!IS_GEO(ti.get_type())) {
    throw QueryNotSupported(
        "Geospatial expression and operator require geospatial column as their input "
        "argument(s)");
  }

  // Return geo column reference. The geo column may be expanded if required for extension
  // function arguments. Otherwise, the geo column reference will be translated into
  // physical columns as required. Bounds column will be added if present and requested.
  if (expand_geo_col) {
    for (auto i = 0; i < ti.get_physical_coord_cols(); i++) {
      const auto pcd = cat_.getMetadataForColumnBySpi(
          table_id, SPIMAP_GEO_PHYSICAL_INPUT(rex_input->getIndex(), i + 1));
      auto pcol_ti = pcd->columnType;
      args.push_back(std::make_shared<Analyzer::ColumnVar>(
          pcol_ti, table_id, pcd->columnId, rte_idx));
    }
  } else {
    args.push_back(
        std::make_shared<Analyzer::ColumnVar>(ti, table_id, column_id, rte_idx));
  }
  if (with_bounds && ti.has_bounds()) {
    const auto bounds_cd = cat_.getMetadataForColumnBySpi(
        table_id,
        SPIMAP_GEO_PHYSICAL_INPUT(rex_input->getIndex(),
                                  ti.get_physical_coord_cols() + 1));
    auto bounds_ti = bounds_cd->columnType;
    args.push_back(std::make_shared<Analyzer::ColumnVar>(
        bounds_ti, table_id, bounds_cd->columnId, rte_idx));
  }
  if (with_render_group && ti.has_render_group()) {
    const auto render_group_cd = cat_.getMetadataForColumnBySpi(
        table_id,
        SPIMAP_GEO_PHYSICAL_INPUT(rex_input->getIndex(),
                                  ti.get_physical_coord_cols() + 2));
    auto render_group_ti = render_group_cd->columnType;
    args.push_back(std::make_shared<Analyzer::ColumnVar>(
        render_group_ti, table_id, render_group_cd->columnId, rte_idx));
  }
  return args;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateGeoComparison ( const RexOperator *  rex_operator ) const

private

Definition at line 1652 of file RelAlgTranslatorGeo.cpp.

References fold_expr(), RexOperator::getOperand(), RexOperator::getOperator(), kBOOLEAN, kDOUBLE, kONE, RexOperator::size(), and translateScalarRex().

Referenced by translateOper().

                                           {
  if (rex_operator->size() != size_t(2)) {
    return nullptr;
  }

  auto geo_distance_expr = translateScalarRex(rex_operator->getOperand(0));
  auto func_oper = dynamic_cast<Analyzer::GeoOperator*>(geo_distance_expr.get());
  if (func_oper && func_oper->getName() == "ST_Distance"sv) {
    const auto& distance_ti = SQLTypeInfo(kDOUBLE, false);
    auto distance_expr = translateScalarRex(rex_operator->getOperand(1));
    if (distance_expr->get_type_info().get_type() != kDOUBLE) {
      distance_expr = distance_expr->add_cast(distance_ti);
    }
    distance_expr = fold_expr(distance_expr.get());
    return makeExpr<Analyzer::BinOper>(
        kBOOLEAN, rex_operator->getOperator(), kONE, geo_distance_expr, distance_expr);
  }
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< std::shared_ptr< Analyzer::Expr > > RelAlgTranslator::translateGeoFunctionArg ( const RexScalar *  rex_scalar, SQLTypeInfo &  arg_ti, const bool  with_bounds, const bool  with_render_group, const bool  expand_geo_col, const bool  is_projection = false, const bool  use_geo_expressions = false, const bool  try_to_compress = false, const bool  allow_gdal_transforms = false  ) const

private

Definition at line 258 of file RelAlgTranslatorGeo.cpp.

References run_benchmark_import::args, CHECK, CHECK_EQ, CHECK_GE, Geospatial::GeoTypesFactory::createGeoType(), fold_expr(), func_resolve, SQLTypeInfo::get_compression(), SQLTypeInfo::get_input_srid(), SQLTypeInfo::get_output_srid(), SQLTypeInfo::get_subtype(), Analyzer::anonymous_namespace{Analyzer.cpp}::get_ti_from_geo(), SQLTypeInfo::get_type(), IS_GEO, anonymous_namespace{RelAlgExecutor.cpp}::is_projection(), spatial_type::Transform::isUtm(), kARRAY, kCAST, kDOUBLE, kENCODING_GEOINT, kENCODING_NONE, kGEOGRAPHY, kGEOMETRY, kINT, kLINESTRING, kNULLT, kPOINT, kSMALLINT, kTEXT, kTINYINT, SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), SQLTypeInfo::set_input_srid(), SQLTypeInfo::set_notnull(), SQLTypeInfo::set_output_srid(), SQLTypeInfo::set_subtype(), SQLTypeInfo::set_type(), to_string(), translateBinaryGeoConstructor(), translateBinaryGeoPredicate(), translateGeoColumn(), translateGeoLiteral(), translateInput(), translateLiteral(), translateScalarRex(), and translateUnaryGeoPredicate().

Referenced by translateBinaryGeoConstructor(), translateBinaryGeoFunction(), translateBinaryGeoPredicate(), translateFunctionWithGeoArg(), translateGeoProjection(), translateTernaryGeoFunction(), translateUnaryGeoFunction(), and translateUnaryGeoPredicate().

                                            {
  std::vector<std::shared_ptr<Analyzer::Expr>> geoargs;

  const auto rex_input = dynamic_cast<const RexInput*>(rex_scalar);
  if (rex_input) {
    const auto input = translateInput(rex_input);
    const auto column = dynamic_cast<const Analyzer::ColumnVar*>(input.get());
    if (!column || !column->get_type_info().is_geometry()) {
      throw QueryNotSupported("Geo function is expecting a geo column argument");
    }
    if (use_geo_expressions) {
      arg_ti = column->get_type_info();
      return {makeExpr<Analyzer::GeoColumnVar>(column, with_bounds, with_render_group)};
    }
    return translateGeoColumn(
        rex_input, arg_ti, with_bounds, with_render_group, expand_geo_col);
  }
  const auto rex_function = dynamic_cast<const RexFunctionOperator*>(rex_scalar);
  if (rex_function) {
    if (rex_function->getName() == "ST_Transform"sv) {
      CHECK_EQ(size_t(2), rex_function->size());
      const auto rex_scalar0 =
          dynamic_cast<const RexScalar*>(rex_function->getOperand(0));
      if (!rex_scalar0) {
        throw QueryNotSupported(rex_function->getName() + ": unexpected first argument");
      }

      const auto rex_literal =
          dynamic_cast<const RexLiteral*>(rex_function->getOperand(1));
      if (!rex_literal) {
        throw QueryNotSupported(rex_function->getName() +
                                ": second argument is expected to be a literal");
      }
      const auto e = translateLiteral(rex_literal);
      auto ce = std::dynamic_pointer_cast<Analyzer::Constant>(e);
      if (!ce || !e->get_type_info().is_integer()) {
        throw QueryNotSupported(rex_function->getName() + ": expecting integer SRID");
      }
      int32_t srid = 0;
      if (e->get_type_info().get_type() == kSMALLINT) {
        srid = static_cast<int32_t>(ce->get_constval().smallintval);
      } else if (e->get_type_info().get_type() == kTINYINT) {
        srid = static_cast<int32_t>(ce->get_constval().tinyintval);
      } else if (e->get_type_info().get_type() == kINT) {
        srid = static_cast<int32_t>(ce->get_constval().intval);
      } else {
        throw QueryNotSupported(rex_function->getName() + ": expecting integer SRID");
      }
      bool allow_result_gdal_transform = false;
      const auto rex_function0 = dynamic_cast<const RexFunctionOperator*>(rex_scalar0);
      if (rex_function0 && func_resolve(rex_function0->getName(),
                                        "ST_Intersection"sv,
                                        "ST_Difference"sv,
                                        "ST_Union"sv,
                                        "ST_Buffer"sv)) {
        // TODO: the design of geo operators currently doesn't allow input srid overrides.
        // For example, in case of ST_Area(ST_Transform(ST_Buffer(geo_column,0), 900913))
        // we can ask geos runtime to transform ST_Buffer's output from 4326 to 900913,
        // however, ST_Area geo operator would still rely on the first arg's typeinfo
        // to codegen srid arg values in the ST_Area_ extension function call. And it will
        // still pick up that transform so the coords will be transformed to 900913 twice.

        // Sink result transform into geos runtime
        // allow_result_gdal_transform = true;
      }
      if (!allow_gdal_transforms && !allow_result_gdal_transform) {
        if (srid != 900913 && ((use_geo_expressions || is_projection) && srid != 4326 &&
                               !spatial_type::Transform::isUtm(srid))) {
          throw QueryNotSupported(rex_function->getName() + ": unsupported output SRID " +
                                  std::to_string(srid));
        }
      }
      arg_ti.set_output_srid(srid);  // Forward output srid down to argument translation
      bool arg0_use_geo_expressions = is_projection ? true : use_geo_expressions;
      if (allow_gdal_transforms) {
        arg0_use_geo_expressions = false;
      }
      auto arg0 = translateGeoFunctionArg(rex_scalar0,
                                          arg_ti,
                                          with_bounds,
                                          with_render_group,
                                          expand_geo_col,
                                          is_projection,
                                          arg0_use_geo_expressions);

      if (use_geo_expressions) {
        CHECK_EQ(arg0.size(), size_t(1));
        auto arg0_ti = arg0.front()->get_type_info();  // make a copy so we can override
        arg0_ti.set_output_srid(srid);
        if (arg0_ti.get_type() == kPOINT) {
          // the output type is going to be fully transformed, so set the input srid to
          // the output srid
          const auto input_srid = arg0_ti.get_input_srid();
          arg0_ti.set_input_srid(srid);
          // geo transforms projections leave the result decompressed in a register
          arg0_ti.set_compression(kENCODING_NONE);
          arg0_ti.set_comp_param(0);
          // reset recursive arg_ti, as the output type of transform will be properly
          // transformed to the desired SRID
          arg_ti.set_output_srid(srid);
          arg_ti.set_input_srid(srid);
          return {makeExpr<Analyzer::GeoTransformOperator>(
              arg0_ti, rex_function->getName(), arg0, input_srid, srid)};
        } else {
          if (auto geo_constant =
                  std::dynamic_pointer_cast<Analyzer::GeoConstant>(arg0.front())) {
            // fold transform
            auto cast_geo_constant = geo_constant->add_cast(arg0_ti);
            // update return type info
            arg_ti = cast_geo_constant->get_type_info();
            return {cast_geo_constant};
          } else if (auto col_var =
                         std::dynamic_pointer_cast<Analyzer::ColumnVar>(arg0.front())) {
            const auto& col_ti = col_var->get_type_info();
            CHECK(col_ti.is_geometry());
            if (col_ti.get_type() != kPOINT) {
              arg_ti.set_input_srid(col_ti.get_input_srid());
              // fall through to transform code below
            }
          } else {
            if (!allow_gdal_transforms && !allow_result_gdal_transform) {
              throw std::runtime_error(
                  "Transform on non-POINT geospatial types not yet supported in this "
                  "context.");
            }
          }
        }
      }

      if (arg_ti.get_input_srid() > 0) {
        if (!allow_gdal_transforms && !allow_result_gdal_transform) {
          if (arg_ti.get_input_srid() != 4326) {
            throw QueryNotSupported(rex_function->getName() +
                                    ": unsupported input SRID " +
                                    std::to_string(arg_ti.get_input_srid()));
          }
        }
        // Established that the input SRID is valid
        if (allow_result_gdal_transform) {
          // If gdal transform has been allowed, then it has been sunk into geos runtime.
          // The returning geometry has already been transformed, de-register transform.
          if (arg_ti.get_input_srid() != srid) {
            arg_ti.set_input_srid(srid);
          }
        }
        arg_ti.set_output_srid(srid);
      } else {
        throw QueryNotSupported(rex_function->getName() +
                                ": unexpected input SRID, unable to transform");
      }
      return arg0;
    } else if (func_resolve(
                   rex_function->getName(), "ST_GeomFromText"sv, "ST_GeogFromText"sv)) {
      CHECK(rex_function->size() == size_t(1) || rex_function->size() == size_t(2));
      if (use_geo_expressions) {
        int32_t srid = 0;
        if (rex_function->size() == 2) {
          // user supplied srid
          const auto rex_literal =
              dynamic_cast<const RexLiteral*>(rex_function->getOperand(1));
          if (!rex_literal) {
            throw QueryNotSupported(rex_function->getName() +
                                    ": second argument is expected to be a literal");
          }
          const auto e = translateLiteral(rex_literal);
          auto ce = std::dynamic_pointer_cast<Analyzer::Constant>(e);
          if (!ce || !e->get_type_info().is_integer()) {
            throw QueryNotSupported(rex_function->getName() + ": expecting integer SRID");
          }
          if (e->get_type_info().get_type() == kSMALLINT) {
            srid = static_cast<int32_t>(ce->get_constval().smallintval);
          } else if (e->get_type_info().get_type() == kTINYINT) {
            srid = static_cast<int32_t>(ce->get_constval().tinyintval);
          } else if (e->get_type_info().get_type() == kINT) {
            srid = static_cast<int32_t>(ce->get_constval().intval);
          } else {
            throw QueryNotSupported(rex_function->getName() + " expecting integer SRID");
          }
          if (srid != 0 && srid != 4326 && srid != 900913) {
            throw QueryNotSupported(rex_function->getName() + ": unsupported SRID " +
                                    std::to_string(srid));
          }
        }
        arg_ti.set_input_srid(srid);  // Input SRID
        // leave the output srid unset in case a transform was above us

        if (rex_function->getName() == "ST_GeogFromText"sv) {
          arg_ti.set_subtype(kGEOGRAPHY);
        } else {
          arg_ti.set_subtype(kGEOMETRY);
        }

        auto func_args = translateGeoFunctionArg(rex_function->getOperand(0),
                                                 arg_ti,
                                                 with_bounds,
                                                 with_render_group,
                                                 expand_geo_col,
                                                 is_projection,
                                                 use_geo_expressions);
        CHECK_GE(func_args.size(), size_t(1));
        return func_args;
      }

      // First - register srid, then send it to geo literal translation
      int32_t srid = 0;
      if (rex_function->size() == 2) {
        const auto rex_literal =
            dynamic_cast<const RexLiteral*>(rex_function->getOperand(1));
        if (!rex_literal) {
          throw QueryNotSupported(rex_function->getName() +
                                  ": second argument is expected to be a literal");
        }
        const auto e = translateLiteral(rex_literal);
        auto ce = std::dynamic_pointer_cast<Analyzer::Constant>(e);
        if (!ce || !e->get_type_info().is_integer()) {
          throw QueryNotSupported(rex_function->getName() + ": expecting integer SRID");
        }
        if (e->get_type_info().get_type() == kSMALLINT) {
          srid = static_cast<int32_t>(ce->get_constval().smallintval);
        } else if (e->get_type_info().get_type() == kTINYINT) {
          srid = static_cast<int32_t>(ce->get_constval().tinyintval);
        } else if (e->get_type_info().get_type() == kINT) {
          srid = static_cast<int32_t>(ce->get_constval().intval);
        } else {
          throw QueryNotSupported(rex_function->getName() + " expecting integer SRID");
        }
        if (srid != 0 && srid != 4326 && srid != 900913) {
          throw QueryNotSupported(rex_function->getName() + ": unsupported SRID " +
                                  std::to_string(srid));
        }
      }
      arg_ti.set_input_srid(srid);   // Input SRID
      arg_ti.set_output_srid(srid);  // Output SRID is the same - no transform

      const auto rex_literal =
          dynamic_cast<const RexLiteral*>(rex_function->getOperand(0));
      if (!rex_literal) {
        throw QueryNotSupported(rex_function->getName() +
                                " expects a string literal as first argument");
      }
      auto arg0 = translateGeoLiteral(rex_literal, arg_ti, with_bounds);
      arg_ti.set_subtype((rex_function->getName() == "ST_GeogFromText"sv) ? kGEOGRAPHY
                                                                          : kGEOMETRY);
      return arg0;
    } else if (rex_function->getName() == "ST_PointN"sv) {
      // uses geo expressions
      const auto rex_scalar0 =
          dynamic_cast<const RexScalar*>(rex_function->getOperand(0));
      if (!rex_scalar0) {
        throw QueryNotSupported(rex_function->getName() +
                                ": expects scalar as first argument");
      }
      auto arg0 = translateGeoFunctionArg(rex_scalar0,
                                          arg_ti,
                                          with_bounds,
                                          with_render_group,
                                          expand_geo_col,
                                          /*is_projection=*/false,
                                          /*use_geo_expressions=*/true);
      CHECK_EQ(arg0.size(), size_t(1));
      CHECK(arg0.front());
      if (arg0.front()->get_type_info().get_type() != kLINESTRING) {
        throw QueryNotSupported(rex_function->getName() +
                                " expects LINESTRING as first argument");
      }
      const auto rex_literal =
          dynamic_cast<const RexLiteral*>(rex_function->getOperand(1));
      if (!rex_literal) {
        throw QueryNotSupported(rex_function->getName() +
                                ": second argument is expected to be a literal");
      }
      const auto e = translateLiteral(rex_literal);
      auto ce = std::dynamic_pointer_cast<Analyzer::Constant>(e);
      if (!ce || !e->get_type_info().is_integer()) {
        throw QueryNotSupported(rex_function->getName() +
                                ": expecting integer index as second argument");
      }
      int32_t index = 0;
      if (e->get_type_info().get_type() == kSMALLINT) {
        index = static_cast<int32_t>(ce->get_constval().smallintval);
      } else if (e->get_type_info().get_type() == kTINYINT) {
        index = static_cast<int32_t>(ce->get_constval().tinyintval);
      } else if (e->get_type_info().get_type() == kINT) {
        index = static_cast<int32_t>(ce->get_constval().intval);
      } else {
        throw QueryNotSupported(rex_function->getName() + " expecting integer index");
      }
      if (index == 0) {
        // maybe we will just return NULL here?
        throw QueryNotSupported(rex_function->getName() + ": invalid index");
      }
      arg0.push_back(e);
      auto oper_ti =
          arg0.front()->get_type_info();  // make a copy so we can reset nullness and type
      oper_ti.set_type(kPOINT);
      oper_ti.set_notnull(false);

      arg_ti = oper_ti;  // TODO: remove

      return {makeExpr<Analyzer::GeoOperator>(oper_ti, rex_function->getName(), arg0)};

    } else if (rex_function->getName() == "ST_StartPoint"sv ||
               rex_function->getName() == "ST_EndPoint"sv) {
      std::vector<std::shared_ptr<Analyzer::Expr>> args;
      CHECK_EQ(size_t(1), rex_function->size());
      const auto arg_exprs = translateGeoFunctionArg(rex_function->getOperand(0),
                                                     arg_ti,
                                                     with_bounds,
                                                     with_render_group,
                                                     expand_geo_col,
                                                     is_projection,
                                                     /*use_geo_expressions=*/true);
      CHECK_EQ(arg_exprs.size(), size_t(1));
      CHECK(arg_exprs.front());
      const auto arg_expr_ti = arg_exprs.front()->get_type_info();
      if (arg_expr_ti.get_type() != kLINESTRING) {
        throw QueryNotSupported(rex_function->getName() +
                                " expected LINESTRING argument. Received " +
                                arg_expr_ti.toString());
      }
      args.push_back(arg_exprs.front());

      auto oper_ti = args.back()->get_type_info();  // make a copy so we can override type
      oper_ti.set_type(kPOINT);

      arg_ti = oper_ti;  // TODO: remove

      return {makeExpr<Analyzer::GeoOperator>(oper_ti, rex_function->getName(), args)};
    } else if (rex_function->getName() == "ST_SRID"sv) {
      CHECK_EQ(size_t(1), rex_function->size());
      const auto rex_scalar0 =
          dynamic_cast<const RexScalar*>(rex_function->getOperand(0));
      if (!rex_scalar0) {
        throw QueryNotSupported(rex_function->getName() +
                                ": expects scalar as first argument");
      }
      auto arg0 = translateGeoFunctionArg(
          rex_scalar0, arg_ti, with_bounds, with_render_group, expand_geo_col);
      if (!IS_GEO(arg_ti.get_type())) {
        throw QueryNotSupported(rex_function->getName() + " expects geometry argument");
      }
      return arg0;
    } else if (rex_function->getName() == "ST_SetSRID"sv) {
      CHECK_EQ(size_t(2), rex_function->size());
      const auto rex_literal =
          dynamic_cast<const RexLiteral*>(rex_function->getOperand(1));
      if (!rex_literal) {
        throw QueryNotSupported(rex_function->getName() +
                                ": second argument is expected to be a literal");
      }
      const auto e = translateLiteral(rex_literal);
      auto ce = std::dynamic_pointer_cast<Analyzer::Constant>(e);
      if (!ce || !e->get_type_info().is_integer()) {
        throw QueryNotSupported(rex_function->getName() + ": expecting integer SRID");
      }
      int32_t srid = 0;
      if (e->get_type_info().get_type() == kSMALLINT) {
        srid = static_cast<int32_t>(ce->get_constval().smallintval);
      } else if (e->get_type_info().get_type() == kTINYINT) {
        srid = static_cast<int32_t>(ce->get_constval().tinyintval);
      } else if (e->get_type_info().get_type() == kINT) {
        srid = static_cast<int32_t>(ce->get_constval().intval);
      } else {
        throw QueryNotSupported(rex_function->getName() + ": expecting integer SRID");
      }

      const auto rex_scalar0 =
          dynamic_cast<const RexScalar*>(rex_function->getOperand(0));
      if (!rex_scalar0) {
        throw QueryNotSupported(rex_function->getName() +
                                ": expects scalar as first argument");
      }

      // Only convey the request to compress if dealing with 4326 geo
      auto arg0 = translateGeoFunctionArg(rex_scalar0,
                                          arg_ti,
                                          with_bounds,
                                          with_render_group,
                                          expand_geo_col,
                                          is_projection,
                                          use_geo_expressions,
                                          (try_to_compress && (srid == 4326)));

      CHECK(!arg0.empty() && arg0.front());
      if (!IS_GEO(arg_ti.get_type()) && !use_geo_expressions) {
        throw QueryNotSupported(rex_function->getName() + " expects geometry argument");
      }
      arg_ti.set_input_srid(srid);   // Input SRID
      arg_ti.set_output_srid(srid);  // Output SRID is the same - no transform
      if (auto geo_expr = std::dynamic_pointer_cast<Analyzer::GeoExpr>(arg0.front())) {
        CHECK_EQ(arg0.size(), size_t(1));
        auto ti = geo_expr->get_type_info();
        ti.set_input_srid(srid);
        ti.set_output_srid(srid);
        return {geo_expr->add_cast(ti)};
      }
      return arg0;
    } else if (rex_function->getName() == "CastToGeography"sv) {
      CHECK_EQ(size_t(1), rex_function->size());
      const auto rex_scalar0 =
          dynamic_cast<const RexScalar*>(rex_function->getOperand(0));
      if (!rex_scalar0) {
        throw QueryNotSupported(rex_function->getName() +
                                ": expects scalar as first argument");
      }
      auto arg0 = translateGeoFunctionArg(rex_scalar0,
                                          arg_ti,
                                          with_bounds,
                                          with_render_group,
                                          expand_geo_col,
                                          /*is_projection=*/false,
                                          use_geo_expressions);
      CHECK(!arg0.empty());
      if (auto geo_expr = std::dynamic_pointer_cast<Analyzer::GeoExpr>(arg0.front())) {
        auto arg_ti = geo_expr->get_type_info();  // make a copy
        arg_ti.set_subtype(kGEOGRAPHY);
        return {geo_expr->add_cast(arg_ti)};
      }
      if (use_geo_expressions) {
        arg_ti = arg0.front()->get_type_info();
        arg_ti.set_subtype(kGEOGRAPHY);
        arg0.front()->set_type_info(arg_ti);
      }
      if (!IS_GEO(arg_ti.get_type())) {
        throw QueryNotSupported(rex_function->getName() + " expects geometry argument");
      }
      if (arg_ti.get_output_srid() != 4326) {
        throw QueryNotSupported(rex_function->getName() +
                                " expects geometry with SRID=4326");
      }
      arg_ti.set_subtype(kGEOGRAPHY);
      return arg0;
    } else if (rex_function->getName() == "ST_Point"sv) {
      CHECK_EQ(size_t(2), rex_function->size());
      arg_ti.set_type(kPOINT);
      arg_ti.set_subtype(kGEOMETRY);
      arg_ti.set_input_srid(0);
      arg_ti.set_output_srid(0);
      arg_ti.set_compression(kENCODING_NONE);

      auto coord1 = translateScalarRex(rex_function->getOperand(0));
      auto coord2 = translateScalarRex(rex_function->getOperand(1));
      auto d_ti = SQLTypeInfo(kDOUBLE, false);
      auto cast_coord1 = coord1->add_cast(d_ti);
      auto cast_coord2 = coord2->add_cast(d_ti);
      // First try to fold to geo literal
      auto fold1 = fold_expr(cast_coord1.get());
      auto fold2 = fold_expr(cast_coord2.get());
      auto const_coord1 = std::dynamic_pointer_cast<Analyzer::Constant>(fold1);
      auto const_coord2 = std::dynamic_pointer_cast<Analyzer::Constant>(fold2);
      if (const_coord1 && const_coord2 && !use_geo_expressions) {
        CHECK(const_coord1->get_type_info().get_type() == kDOUBLE);
        CHECK(const_coord2->get_type_info().get_type() == kDOUBLE);
        std::string wkt = "POINT(" +
                          std::to_string(const_coord1->get_constval().doubleval) + " " +
                          std::to_string(const_coord2->get_constval().doubleval) + ")";
        RexLiteral rex_literal{wkt, kTEXT, kNULLT, 0, 0, 0, 0};
        auto args = translateGeoLiteral(&rex_literal, arg_ti, false);
        CHECK(arg_ti.get_type() == kPOINT);
        return args;
      }
      const auto is_local_alloca = !is_projection;
      if (!is_local_alloca || use_geo_expressions) {
        if (try_to_compress) {
          arg_ti.set_input_srid(4326);
          arg_ti.set_output_srid(4326);
        }
        return {makeExpr<Analyzer::GeoOperator>(
            arg_ti,
            rex_function->getName(),
            std::vector<std::shared_ptr<Analyzer::Expr>>{cast_coord1, cast_coord2})};
      }
      // Couldn't fold to geo literal, construct [and compress] on the fly
      auto da_ti = SQLTypeInfo(kARRAY, true);
      da_ti.set_subtype(kDOUBLE);
      da_ti.set_size(16);
      if (try_to_compress) {
        // Switch to compressed coord array
        da_ti.set_subtype(kINT);
        da_ti.set_size(8);
        da_ti.set_input_srid(4326);
        da_ti.set_output_srid(4326);
        da_ti.set_compression(kENCODING_GEOINT);
        da_ti.set_comp_param(32);
        // Register point compression
        arg_ti.set_input_srid(4326);
        arg_ti.set_output_srid(4326);
        arg_ti.set_compression(kENCODING_GEOINT);
        arg_ti.set_comp_param(32);
      }
      auto cast_coords = {cast_coord1, cast_coord2};
      auto ae = makeExpr<Analyzer::ArrayExpr>(da_ti, cast_coords, false, is_local_alloca);
      SQLTypeInfo tia_ti = da_ti;
      tia_ti.set_subtype(kTINYINT);
      return {makeExpr<Analyzer::UOper>(tia_ti, false, kCAST, ae)};
    } else if (rex_function->getName() == "ST_Centroid"sv) {
      CHECK_EQ(size_t(1), rex_function->size());
      arg_ti.set_type(kPOINT);
      arg_ti.set_subtype(kGEOMETRY);
      arg_ti.set_input_srid(0);
      arg_ti.set_output_srid(0);
      arg_ti.set_compression(kENCODING_NONE);

      SQLTypeInfo geo_ti;
      int legacy_transform_srid = 0;  // discard
      auto geoargs = translateGeoFunctionArg(rex_function->getOperand(0),
                                             geo_ti,
                                             /*with_bounds=*/false,
                                             /*with_render_group=*/false,
                                             /*expand_geo_col=*/true,
                                             /*is_projection=*/false,
                                             /*use_geo_expressions=*/true);
      CHECK_EQ(geoargs.size(), size_t(1));
      if (try_to_compress) {
        // Request point compression
        arg_ti.set_input_srid(4326);
        arg_ti.set_output_srid(4326);
        arg_ti.set_compression(kENCODING_GEOINT);
        arg_ti.set_comp_param(32);
      }
      if (geo_ti.get_input_srid() != geo_ti.get_output_srid() &&
          geo_ti.get_output_srid() > 0 &&
          std::dynamic_pointer_cast<Analyzer::ColumnVar>(geoargs.front())) {
        // legacy transform
        legacy_transform_srid = geo_ti.get_output_srid();
      }
      return {makeExpr<Analyzer::GeoOperator>(
          arg_ti,
          rex_function->getName(),
          std::vector<std::shared_ptr<Analyzer::Expr>>{geoargs.front()},
          legacy_transform_srid > 0 ? std::make_optional<int>(legacy_transform_srid)
                                    : std::nullopt)};
    } else if (func_resolve(rex_function->getName(),
                            "ST_Intersection"sv,
                            "ST_Difference"sv,
                            "ST_Union"sv,
                            "ST_Buffer"sv)) {
      CHECK_EQ(size_t(2), rex_function->size());
      // What geo type will the constructor return? Could be anything.
      return {translateBinaryGeoConstructor(rex_function, arg_ti, with_bounds)};
    } else if (func_resolve(rex_function->getName(), "ST_IsEmpty"sv, "ST_IsValid"sv)) {
      CHECK_EQ(size_t(1), rex_function->size());
      return {translateUnaryGeoPredicate(rex_function, arg_ti, with_bounds)};
    } else if (func_resolve(rex_function->getName(), "ST_Equals"sv)) {
      CHECK_EQ(size_t(2), rex_function->size());
      return {translateBinaryGeoPredicate(rex_function, arg_ti, with_bounds)};
    } else {
      throw QueryNotSupported("Unsupported argument: " + rex_function->getName());
    }
  }
  const auto rex_literal = dynamic_cast<const RexLiteral*>(rex_scalar);
  if (rex_literal) {
    if (use_geo_expressions) {
      const auto translated_literal = translateLiteral(rex_literal);
      const auto constant_expr =
          dynamic_cast<const Analyzer::Constant*>(translated_literal.get());
      CHECK(constant_expr);
      if (constant_expr->get_is_null()) {
        // TODO: we could lift this limitation by assuming a minimum type per function
        throw QueryNotSupported("Geospatial functions require typed nulls.");
      }
      const auto& datum = constant_expr->get_constval();
      CHECK(datum.stringval);
      auto geospatial_base = Geospatial::GeoTypesFactory::createGeoType(*datum.stringval);
      CHECK(geospatial_base);
      SQLTypeInfo ti;
      ti.set_type(get_ti_from_geo(geospatial_base.get()));
      if (arg_ti.get_subtype() == kGEOGRAPHY) {
        ti.set_subtype(kGEOGRAPHY);
      } else {
        ti.set_subtype(kGEOMETRY);
      }
      ti.set_input_srid(arg_ti.get_input_srid());
      ti.set_output_srid(arg_ti.get_output_srid() == 0 ? arg_ti.get_input_srid()
                                                       : arg_ti.get_output_srid());
      // TODO: remove dependence on arg_ti
      if (ti.get_output_srid() == 4326 || arg_ti.get_compression() == kENCODING_GEOINT) {
        ti.set_compression(kENCODING_GEOINT);
        ti.set_comp_param(32);
      }
      ti.set_notnull(true);
      // Before removing dependence on arg_ti need to note that ST_Transform uses it
      // as a vehicle to pass transform output SRID to its args.
      // arg_ti is also expected to be filled with relevant data, which wasn't done here.
      // Not filling arg_ti with the geo constant data (which went to ti instead)
      // resulted in GeoConstant::add_cast adopting a corrupt type info,
      // which later killed codegen. Need to complete arg_ti composition:
      arg_ti = ti;
      return {makeExpr<Analyzer::GeoConstant>(std::move(geospatial_base), ti)};
    }
    return translateGeoLiteral(rex_literal, arg_ti, with_bounds);
  }
  throw QueryNotSupported("Geo function argument not supported");
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< std::shared_ptr< Analyzer::Expr > > RelAlgTranslator::translateGeoLiteral ( const RexLiteral *  rex_literal, SQLTypeInfo &  ti, bool  with_bounds  ) const

private

Definition at line 120 of file RelAlgTranslatorGeo.cpp.

References run_benchmark_import::args, CHECK, Geospatial::compress_coords(), Datum::doubleval, SQLTypeInfo::get_compression(), SQLTypeInfo::get_output_srid(), SQLTypeInfo::get_type(), Geospatial::GeoTypesFactory::getGeoColumns(), SQLTypeInfo::has_bounds(), Datum::intval, kARRAY, kDOUBLE, kENCODING_GEOINT, kGEOMETRY, kINT, kMULTIPOLYGON, kPOLYGON, kTEXT, kTINYINT, SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), SQLTypeInfo::set_input_srid(), SQLTypeInfo::set_output_srid(), SQLTypeInfo::set_size(), SQLTypeInfo::set_subtype(), Datum::tinyintval, and translateLiteral().

Referenced by translateGeoFunctionArg().

                            {
  CHECK(rex_literal);
  if (rex_literal->getType() != kTEXT) {
    throw std::runtime_error("Geo literals must be strings");
  }

  // TODO: use geo conversion here
  const auto e = translateLiteral(rex_literal);
  auto wkt = std::dynamic_pointer_cast<Analyzer::Constant>(e);
  CHECK(wkt);
  std::vector<double> coords;
  std::vector<double> bounds;
  std::vector<int> ring_sizes;
  std::vector<int> poly_rings;
  int32_t srid = ti.get_output_srid();
  if (!Geospatial::GeoTypesFactory::getGeoColumns(
          *wkt->get_constval().stringval, ti, coords, bounds, ring_sizes, poly_rings)) {
    throw QueryNotSupported("Could not read geometry from text");
  }
  ti.set_subtype(kGEOMETRY);
  ti.set_input_srid(srid);
  ti.set_output_srid(srid);
  // Compress geo literals by default
  if (srid == 4326) {
    ti.set_compression(kENCODING_GEOINT);
    ti.set_comp_param(32);
  }

  std::vector<std::shared_ptr<Analyzer::Expr>> args;

  std::vector<uint8_t> compressed_coords = Geospatial::compress_coords(coords, ti);
  std::list<std::shared_ptr<Analyzer::Expr>> compressed_coords_exprs;
  for (auto cc : compressed_coords) {
    Datum d;
    d.tinyintval = cc;
    auto e = makeExpr<Analyzer::Constant>(kTINYINT, false, d);
    compressed_coords_exprs.push_back(e);
  }
  SQLTypeInfo arr_ti = SQLTypeInfo(kARRAY, true);
  arr_ti.set_subtype(kTINYINT);
  arr_ti.set_size(compressed_coords.size() * sizeof(int8_t));
  arr_ti.set_compression(ti.get_compression());
  arr_ti.set_comp_param((ti.get_compression() == kENCODING_GEOINT) ? 32 : 64);
  args.push_back(makeExpr<Analyzer::Constant>(arr_ti, false, compressed_coords_exprs));

  auto lit_type = ti.get_type();
  if (lit_type == kPOLYGON || lit_type == kMULTIPOLYGON) {
    // ring sizes
    std::list<std::shared_ptr<Analyzer::Expr>> ring_size_exprs;
    for (auto c : ring_sizes) {
      Datum d;
      d.intval = c;
      auto e = makeExpr<Analyzer::Constant>(kINT, false, d);
      ring_size_exprs.push_back(e);
    }
    SQLTypeInfo arr_ti = SQLTypeInfo(kARRAY, true);
    arr_ti.set_subtype(kINT);
    arr_ti.set_size(ring_sizes.size() * sizeof(int32_t));
    args.push_back(makeExpr<Analyzer::Constant>(arr_ti, false, ring_size_exprs));

    // poly rings
    if (lit_type == kMULTIPOLYGON) {
      std::list<std::shared_ptr<Analyzer::Expr>> poly_rings_exprs;
      for (auto c : poly_rings) {
        Datum d;
        d.intval = c;
        auto e = makeExpr<Analyzer::Constant>(kINT, false, d);
        poly_rings_exprs.push_back(e);
      }
      SQLTypeInfo arr_ti = SQLTypeInfo(kARRAY, true);
      arr_ti.set_subtype(kINT);
      arr_ti.set_size(poly_rings.size() * sizeof(int32_t));
      args.push_back(makeExpr<Analyzer::Constant>(arr_ti, false, poly_rings_exprs));
    }
  }

  if (with_bounds && ti.has_bounds()) {
    // bounds
    std::list<std::shared_ptr<Analyzer::Expr>> bounds_exprs;
    for (auto b : bounds) {
      Datum d;
      d.doubleval = b;
      auto e = makeExpr<Analyzer::Constant>(kDOUBLE, false, d);
      bounds_exprs.push_back(e);
    }
    SQLTypeInfo arr_ti = SQLTypeInfo(kARRAY, true);
    arr_ti.set_subtype(kDOUBLE);
    arr_ti.set_size(bounds.size() * sizeof(double));
    args.push_back(makeExpr<Analyzer::Constant>(arr_ti, false, bounds_exprs));
  }

  return args;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateGeoOverlapsOper ( const RexOperator *  rex_operator ) const

private

Definition at line 1782 of file RelAlgTranslatorGeo.cpp.

References CHECK, CHECK_EQ, CHECK_GT, SQLTypeInfo::get_type(), RexOperator::getOperand(), kBOOLEAN, kONE, kOVERLAPS, kPOINT, RexOperator::size(), and translateGeoColumn().

Referenced by translateOverlapsOper().

                                           {
  CHECK_EQ(rex_operator->size(), 2u);

  auto translate_input =
      [&](const RexScalar* operand) -> std::shared_ptr<Analyzer::Expr> {
    const auto input = dynamic_cast<const RexInput*>(operand);
    CHECK(input);

    SQLTypeInfo ti;
    const auto exprs = translateGeoColumn(input, ti, true, false, false);
    CHECK_GT(exprs.size(), 0u);
    if (ti.get_type() == kPOINT) {
      return exprs.front();
    } else {
      return exprs.back();
    }
  };

  SQLQualifier sql_qual{kONE};
  SQLOps sql_op{kOVERLAPS};
  return makeExpr<Analyzer::BinOper>(SQLTypeInfo(kBOOLEAN, false),
                                     false,
                                     sql_op,
                                     sql_qual,
                                     translate_input(rex_operator->getOperand(1)),
                                     translate_input(rex_operator->getOperand(0)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateGeoProjection ( const RexFunctionOperator *  rex_function, SQLTypeInfo &  ti, const bool  with_bounds  ) const

private

Definition at line 862 of file RelAlgTranslatorGeo.cpp.

References CHECK, RelRexToStringConfig::defaults(), func_resolve, RexFunctionOperator::getName(), RexOperator::getOperand(), Geospatial::GeoBase::kPROJECTION, RexFunctionOperator::toString(), and translateGeoFunctionArg().

Referenced by translateFunction().

                                  {
  // note that this is a bit of a misnomer, as ST_SetSRID embedded in a transform will
  // eventually use geo expressions -- just not here
  const bool use_geo_projections = !(rex_function->getName() == "ST_GeomFromText" ||
                                     rex_function->getName() == "ST_GeogFromText" ||
                                     rex_function->getName() == "ST_SetSRID");
  auto geoargs = translateGeoFunctionArg(rex_function,
                                         ti,
                                         /*with_bounds=*/false,
                                         /*with_render_group=*/false,
                                         /*expand_geo_col=*/true,
                                         /*is_projection=*/true,
                                         /*use_geo_expressions=*/use_geo_projections);
  CHECK(!geoargs.empty());
  if (std::dynamic_pointer_cast<const Analyzer::GeoExpr>(geoargs.front()) &&
      !geoargs.front()->get_type_info().is_array()) {
    // GeoExpression
    return geoargs.front();
  }
  bool allow_gdal_transform = false;
  if (rex_function->getName() == "ST_Transform") {
    const auto rex_scalar0 = dynamic_cast<const RexScalar*>(rex_function->getOperand(0));
    const auto rex_function0 = dynamic_cast<const RexFunctionOperator*>(rex_scalar0);
    if (rex_function0 && func_resolve(rex_function0->getName(),
                                      "ST_Intersection"sv,
                                      "ST_Difference"sv,
                                      "ST_Union"sv,
                                      "ST_Buffer"sv)) {
      // Allow projection of gdal-transformed geos outputs
      allow_gdal_transform = true;
    }
  }
  if (use_geo_projections && !allow_gdal_transform) {
    throw std::runtime_error("Geospatial projection for function " +
                             rex_function->toString(RelRexToStringConfig::defaults()) +
                             " not yet supported in this context");
  }
  return makeExpr<Analyzer::GeoUOper>(
      Geospatial::GeoBase::GeoOp::kPROJECTION, ti, ti, geoargs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateHPTLiteral ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1975 of file RelAlgTranslator.cpp.

References CHECK_EQ, RexOperator::getOperand(), RexOperator::getType(), RexOperator::size(), to_string(), and translateScalarRex().

Referenced by translateFunction().

                                                   {
  /* since calcite uses Avatica package called DateTimeUtils to parse timestamp strings.
     Therefore any string having fractional seconds more 3 places after the decimal
     (milliseconds) will get truncated to 3 decimal places, therefore we lose precision
     (us|ns). Issue: [BE-2461] Here we are hijacking literal cast to Timestamp(6|9) from
     calcite and translating them to generate our own casts.
  */
  CHECK_EQ(size_t(1), rex_function->size());
  const auto operand = translateScalarRex(rex_function->getOperand(0));
  const auto& operand_ti = operand->get_type_info();
  const auto& target_ti = rex_function->getType();
  if (!operand_ti.is_string()) {
    throw std::runtime_error(
        "High precision timestamp cast argument must be a string. Input type is: " +
        operand_ti.get_type_name());
  } else if (!target_ti.is_high_precision_timestamp()) {
    throw std::runtime_error(
        "Cast target type should be high precision timestamp. Input type is: " +
        target_ti.get_type_name());
  } else if (target_ti.get_dimension() != 6 && target_ti.get_dimension() != 9) {
    throw std::runtime_error(
        "Cast target type should be TIMESTAMP(6|9). Input type is: TIMESTAMP(" +
        std::to_string(target_ti.get_dimension()) + ")");
  } else {
    return operand->add_cast(target_ti);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateInOper ( const RexOperator *  rex_operator ) const

private

Definition at line 592 of file RelAlgTranslator.cpp.

References CHECK, CHECK_EQ, anonymous_namespace{RelAlgTranslator.cpp}::datum_from_scalar_tv(), g_enable_watchdog, anonymous_namespace{RelAlgTranslator.cpp}::get_in_values_expr(), getInIntegerSetExpr(), RexOperator::getOperand(), just_explain_, kCAST, kENCODING_DICT, kENCODING_NONE, run_benchmark_import::result, RexOperator::size(), and translateScalarRex().

Referenced by translateOper().

                                           {
  if (just_explain_) {
    throw std::runtime_error("EXPLAIN is not supported with sub-queries");
  }
  CHECK(rex_operator->size() == 2);
  const auto lhs = translateScalarRex(rex_operator->getOperand(0));
  const auto rhs = rex_operator->getOperand(1);
  const auto rex_subquery = dynamic_cast<const RexSubQuery*>(rhs);
  CHECK(rex_subquery);
  auto ti = lhs->get_type_info();
  auto result = rex_subquery->getExecutionResult();
  CHECK(result);
  auto& row_set = result->getRows();
  CHECK_EQ(size_t(1), row_set->colCount());
  const auto& rhs_ti = row_set->getColType(0);
  if (rhs_ti.get_type() != ti.get_type()) {
    throw std::runtime_error(
        "The two sides of the IN operator must have the same type; found " +
        ti.get_type_name() + " and " + rhs_ti.get_type_name());
  }
  row_set->moveToBegin();
  if (row_set->entryCount() > 10000) {
    std::shared_ptr<Analyzer::Expr> expr;
    if ((ti.is_integer() || (ti.is_string() && ti.get_compression() == kENCODING_DICT)) &&
        !row_set->getQueryMemDesc().didOutputColumnar()) {
      expr = getInIntegerSetExpr(lhs, *row_set);
      // Handle the highly unlikely case when the InIntegerSet ended up being tiny.
      // Just let it fall through the usual InValues path at the end of this method,
      // its codegen knows to use inline comparisons for few values.
      if (expr && std::static_pointer_cast<Analyzer::InIntegerSet>(expr)
                          ->get_value_list()
                          .size() <= 100) {
        expr = nullptr;
      }
    } else {
      expr = get_in_values_expr(lhs, *row_set);
    }
    if (expr) {
      return expr;
    }
  }
  std::list<std::shared_ptr<Analyzer::Expr>> value_exprs;
  while (true) {
    auto row = row_set->getNextRow(true, false);
    if (row.empty()) {
      break;
    }
    if (g_enable_watchdog && value_exprs.size() >= 10000) {
      throw std::runtime_error(
          "Unable to handle 'expr IN (subquery)', subquery returned 10000+ rows.");
    }
    auto scalar_tv = boost::get<ScalarTargetValue>(&row[0]);
    Datum d{0};
    bool is_null_const{false};
    std::tie(d, is_null_const) = datum_from_scalar_tv(scalar_tv, ti);
    if (ti.is_string() && ti.get_compression() != kENCODING_NONE) {
      auto ti_none_encoded = ti;
      ti_none_encoded.set_compression(kENCODING_NONE);
      auto none_encoded_string = makeExpr<Analyzer::Constant>(ti, is_null_const, d);
      auto dict_encoded_string =
          std::make_shared<Analyzer::UOper>(ti, false, kCAST, none_encoded_string);
      value_exprs.push_back(dict_encoded_string);
    } else {
      value_exprs.push_back(makeExpr<Analyzer::Constant>(ti, is_null_const, d));
    }
  }
  return makeExpr<Analyzer::InValues>(lhs, value_exprs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateInput ( const RexInput *  rex_input ) const

private

Definition at line 394 of file RelAlgTranslator.cpp.

References cat_, CHECK, CHECK_EQ, CHECK_GE, CHECK_LE, CHECK_LT, RelRexToStringConfig::defaults(), RexAbstractInput::getIndex(), Catalog_Namespace::Catalog::getMetadataForColumnBySpi(), RelAlgNode::getOutputMetainfo(), RexInput::getSourceNode(), input_to_nest_level_, join_types_, kTEXT, and LEFT.

Referenced by translateGeoFunctionArg(), and translateScalarRex().

                                     {
  const auto source = rex_input->getSourceNode();
  const auto it_rte_idx = input_to_nest_level_.find(source);
  CHECK(it_rte_idx != input_to_nest_level_.end())
      << "Not found in input_to_nest_level_, source="
      << source->toString(RelRexToStringConfig::defaults());
  const int rte_idx = it_rte_idx->second;
  const auto scan_source = dynamic_cast<const RelScan*>(source);
  const auto& in_metainfo = source->getOutputMetainfo();
  if (scan_source) {
    // We're at leaf (scan) level and not supposed to have input metadata,
    // the name and type information come directly from the catalog.
    CHECK(in_metainfo.empty());
    const auto table_desc = scan_source->getTableDescriptor();
    const auto cd =
        cat_.getMetadataForColumnBySpi(table_desc->tableId, rex_input->getIndex() + 1);
    CHECK(cd);
    auto col_ti = cd->columnType;
    if (col_ti.is_string()) {
      col_ti.set_type(kTEXT);
    }
    if (cd->isVirtualCol) {
      // TODO(alex): remove at some point, we only need this fixup for backwards
      // compatibility with old imported data
      CHECK_EQ("rowid", cd->columnName);
      col_ti.set_size(8);
    }
    CHECK_LE(static_cast<size_t>(rte_idx), join_types_.size());
    if (rte_idx > 0 && join_types_[rte_idx - 1] == JoinType::LEFT) {
      col_ti.set_notnull(false);
    }
    return std::make_shared<Analyzer::ColumnVar>(
        col_ti, table_desc->tableId, cd->columnId, rte_idx);
  }
  CHECK(!in_metainfo.empty()) << "for "
                              << source->toString(RelRexToStringConfig::defaults());
  CHECK_GE(rte_idx, 0);
  const size_t col_id = rex_input->getIndex();
  CHECK_LT(col_id, in_metainfo.size());
  auto col_ti = in_metainfo[col_id].get_type_info();

  if (join_types_.size() > 0) {
    CHECK_LE(static_cast<size_t>(rte_idx), join_types_.size());
    if (rte_idx > 0 && join_types_[rte_idx - 1] == JoinType::LEFT) {
      col_ti.set_notnull(false);
    }
  }

  return std::make_shared<Analyzer::ColumnVar>(col_ti, -source->getId(), col_id, rte_idx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateItem ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1414 of file RelAlgTranslator.cpp.

References CHECK_EQ, RexOperator::getOperand(), kARRAY_AT, kONE, RexOperator::size(), and translateScalarRex().

Referenced by translateFunction().

                                                   {
  CHECK_EQ(size_t(2), rex_function->size());
  const auto base = translateScalarRex(rex_function->getOperand(0));
  const auto index = translateScalarRex(rex_function->getOperand(1));
  return makeExpr<Analyzer::BinOper>(
      base->get_type_info().get_elem_type(), false, kARRAY_AT, kONE, base, index);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateKeyForString ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1289 of file RelAlgTranslator.cpp.

References run_benchmark_import::args, CHECK_EQ, RexFunctionOperator::getName(), and translateFunctionArgs().

Referenced by translateFunction().

                                                   {
  const auto& args = translateFunctionArgs(rex_function);
  CHECK_EQ(size_t(1), args.size());
  const auto expr = dynamic_cast<Analyzer::Expr*>(args[0].get());
  if (nullptr == expr || !expr->get_type_info().is_string() ||
      expr->get_type_info().is_varlen()) {
    throw std::runtime_error(rex_function->getName() +
                             " expects a dictionary encoded text column.");
  }
  return makeExpr<Analyzer::KeyForStringExpr>(args[0]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateLength ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1281 of file RelAlgTranslator.cpp.

References CHECK_EQ, RexFunctionOperator::getName(), RexOperator::getOperand(), RexOperator::size(), and translateScalarRex().

Referenced by translateFunction().

                                                   {
  CHECK_EQ(size_t(1), rex_function->size());
  const auto str_arg = translateScalarRex(rex_function->getOperand(0));
  return makeExpr<Analyzer::CharLengthExpr>(str_arg->decompress(),
                                            rex_function->getName() == "CHAR_LENGTH"sv);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateLike ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1030 of file RelAlgTranslator.cpp.

References CHECK, Parser::LikeExpr::get(), RexFunctionOperator::getName(), RexOperator::getOperand(), RexOperator::size(), and translateScalarRex().

Referenced by translateFunction().

                                                   {
  CHECK(rex_function->size() == 2 || rex_function->size() == 3);
  const auto arg = translateScalarRex(rex_function->getOperand(0));
  const auto like = translateScalarRex(rex_function->getOperand(1));
  if (!std::dynamic_pointer_cast<const Analyzer::Constant>(like)) {
    throw std::runtime_error("The matching pattern must be a literal.");
  }
  const auto escape = (rex_function->size() == 3)
                          ? translateScalarRex(rex_function->getOperand(2))
                          : nullptr;
  const bool is_ilike = rex_function->getName() == "PG_ILIKE"sv;
  return Parser::LikeExpr::get(arg, like, escape, is_ilike, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateLikely ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1059 of file RelAlgTranslator.cpp.

References CHECK, RexOperator::getOperand(), RexOperator::size(), and translateScalarRex().

Referenced by translateFunction().

                                                   {
  CHECK(rex_function->size() == 1);
  const auto arg = translateScalarRex(rex_function->getOperand(0));
  return makeExpr<Analyzer::LikelihoodExpr>(arg, 0.9375);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateLiteral ( const RexLiteral *  rex_literal )

static

Definition at line 281 of file RelAlgTranslator.cpp.

References Parser::StringLiteral::analyzeValue(), Parser::IntLiteral::analyzeValue(), Parser::FixedPtLiteral::analyzeValue(), run_benchmark_import::args, Datum::bigintval, Datum::boolval, anonymous_namespace{RelAlgTranslator.cpp}::build_type_info(), Datum::doubleval, logger::FATAL, kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNULLT, kTEXT, kTIME, kTIMESTAMP, LOG, and make_fp_constant().

Referenced by ResultSetLogicalValuesBuilder::build(), translateGeoFunctionArg(), translateGeoLiteral(), and translateScalarRex().

                                   {
  auto lit_ti = build_type_info(
      rex_literal->getType(), rex_literal->getScale(), rex_literal->getPrecision());
  auto target_ti = build_type_info(rex_literal->getTargetType(),
                                   rex_literal->getTargetScale(),
                                   rex_literal->getTargetPrecision());
  switch (rex_literal->getType()) {
    case kINT:
    case kBIGINT: {
      Datum d;
      d.bigintval = rex_literal->getVal<int64_t>();
      return makeExpr<Analyzer::Constant>(rex_literal->getType(), false, d);
    }
    case kDECIMAL: {
      const auto val = rex_literal->getVal<int64_t>();
      const int precision = rex_literal->getPrecision();
      const int scale = rex_literal->getScale();
      if (target_ti.is_fp() && !scale) {
        return make_fp_constant(val, target_ti);
      }
      auto lit_expr = scale ? Parser::FixedPtLiteral::analyzeValue(val, scale, precision)
                            : Parser::IntLiteral::analyzeValue(val);
      return lit_ti != target_ti ? lit_expr->add_cast(target_ti) : lit_expr;
    }
    case kTEXT: {
      return Parser::StringLiteral::analyzeValue(rex_literal->getVal<std::string>(),
                                                 false);
    }
    case kBOOLEAN: {
      Datum d;
      d.boolval = rex_literal->getVal<bool>();
      return makeExpr<Analyzer::Constant>(kBOOLEAN, false, d);
    }
    case kDOUBLE: {
      Datum d;
      d.doubleval = rex_literal->getVal<double>();
      auto lit_expr = makeExpr<Analyzer::Constant>(kDOUBLE, false, d);
      return lit_ti != target_ti ? lit_expr->add_cast(target_ti) : lit_expr;
    }
    case kINTERVAL_DAY_TIME:
    case kINTERVAL_YEAR_MONTH: {
      Datum d;
      d.bigintval = rex_literal->getVal<int64_t>();
      return makeExpr<Analyzer::Constant>(rex_literal->getType(), false, d);
    }
    case kTIME:
    case kTIMESTAMP: {
      Datum d;
      d.bigintval =
          rex_literal->getType() == kTIMESTAMP && rex_literal->getPrecision() > 0
              ? rex_literal->getVal<int64_t>()
              : rex_literal->getVal<int64_t>() / 1000;
      return makeExpr<Analyzer::Constant>(
          SQLTypeInfo(rex_literal->getType(), rex_literal->getPrecision(), 0, false),
          false,
          d);
    }
    case kDATE: {
      Datum d;
      d.bigintval = rex_literal->getVal<int64_t>() * 24 * 3600;
      return makeExpr<Analyzer::Constant>(rex_literal->getType(), false, d);
    }
    case kNULLT: {
      if (target_ti.is_array()) {
        Analyzer::ExpressionPtrVector args;
        // defaulting to valid sub-type for convenience
        target_ti.set_subtype(kBOOLEAN);
        return makeExpr<Analyzer::ArrayExpr>(target_ti, args, true);
      }
      return makeExpr<Analyzer::Constant>(rex_literal->getTargetType(), true, Datum{0});
    }
    default: {
      LOG(FATAL) << "Unexpected literal type " << lit_ti.get_type_name();
    }
  }
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateOffsetInFragment ( ) const

private

Definition at line 1495 of file RelAlgTranslator.cpp.

Referenced by translateFunction().

                                                                              {
  return makeExpr<Analyzer::OffsetInFragment>();
}

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateOper ( const RexOperator *  rex_operator ) const

private

Definition at line 912 of file RelAlgTranslator.cpp.

References CHECK, CHECK_GT, executor_, anonymous_namespace{RelAlgTranslator.cpp}::get_quantified_rhs(), RexOperator::getOperand(), RexOperator::getOperator(), IS_COMPARISON, kIN, kMINUS, kONE, kOVERLAPS, kPLUS, Parser::OperExpr::normalize(), RexOperator::size(), translateDatePlusMinus(), translateGeoComparison(), translateInOper(), translateOverlapsOper(), translateScalarRex(), and translateUoper().

Referenced by translateScalarRex().

                                           {
  CHECK_GT(rex_operator->size(), size_t(0));
  if (rex_operator->size() == 1) {
    return translateUoper(rex_operator);
  }
  const auto sql_op = rex_operator->getOperator();
  if (sql_op == kIN) {
    return translateInOper(rex_operator);
  }
  if (sql_op == kMINUS || sql_op == kPLUS) {
    auto date_plus_minus = translateDatePlusMinus(rex_operator);
    if (date_plus_minus) {
      return date_plus_minus;
    }
  }
  if (sql_op == kOVERLAPS) {
    return translateOverlapsOper(rex_operator);
  } else if (IS_COMPARISON(sql_op)) {
    auto geo_comp = translateGeoComparison(rex_operator);
    if (geo_comp) {
      return geo_comp;
    }
  }
  auto lhs = translateScalarRex(rex_operator->getOperand(0));
  for (size_t i = 1; i < rex_operator->size(); ++i) {
    std::shared_ptr<Analyzer::Expr> rhs;
    SQLQualifier sql_qual{kONE};
    const auto rhs_op = rex_operator->getOperand(i);
    std::tie(rhs, sql_qual) = get_quantified_rhs(rhs_op, *this);
    if (!rhs) {
      rhs = translateScalarRex(rhs_op);
    }
    CHECK(rhs);

    // Pass in executor to get string proxy info if cast needed between
    // string columns
    lhs = Parser::OperExpr::normalize(sql_op, sql_qual, lhs, rhs, executor_);
  }
  return lhs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateOverlapsOper ( const RexOperator *  rex_operator ) const

private

Definition at line 954 of file RelAlgTranslator.cpp.

References CHECK, RexOperator::getOperand(), RexOperator::getOperator(), kOVERLAPS, translateGeoOverlapsOper(), and translateScalarRex().

Referenced by translateOper().

                                           {
  const auto sql_op = rex_operator->getOperator();
  CHECK(sql_op == kOVERLAPS);

  const auto lhs = translateScalarRex(rex_operator->getOperand(0));
  const auto lhs_ti = lhs->get_type_info();
  if (lhs_ti.is_geometry()) {
    return translateGeoOverlapsOper(rex_operator);
  } else {
    throw std::runtime_error(
        "Overlaps equivalence is currently only supported for geospatial types");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateRegexp ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1045 of file RelAlgTranslator.cpp.

References CHECK, Parser::RegexpExpr::get(), RexOperator::getOperand(), RexOperator::size(), and translateScalarRex().

Referenced by translateFunction().

                                                   {
  CHECK(rex_function->size() == 2 || rex_function->size() == 3);
  const auto arg = translateScalarRex(rex_function->getOperand(0));
  const auto pattern = translateScalarRex(rex_function->getOperand(1));
  if (!std::dynamic_pointer_cast<const Analyzer::Constant>(pattern)) {
    throw std::runtime_error("The matching pattern must be a literal.");
  }
  const auto escape = (rex_function->size() == 3)
                          ? translateScalarRex(rex_function->getOperand(2))
                          : nullptr;
  return Parser::RegexpExpr::get(arg, pattern, escape, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateSampleRatio ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1302 of file RelAlgTranslator.cpp.

References CHECK_EQ, RexOperator::getOperand(), kDOUBLE, RexOperator::size(), and translateScalarRex().

Referenced by translateFunction().

                                                   {
  CHECK_EQ(size_t(1), rex_function->size());
  auto arg = translateScalarRex(rex_function->getOperand(0));
  const auto& arg_ti = arg->get_type_info();
  if (arg_ti.get_type() != kDOUBLE) {
    const auto& double_ti = SQLTypeInfo(kDOUBLE, arg_ti.get_notnull());
    arg = arg->add_cast(double_ti);
  }
  return makeExpr<Analyzer::SampleRatioExpr>(arg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateScalarRex

(

const RexScalar *

rex

)

const

Definition at line 180 of file RelAlgTranslator.cpp.

References CHECK, translateCase(), translateFunction(), translateInput(), translateLiteral(), translateOper(), translateScalarSubquery(), and translateWindowFunction().

Referenced by anonymous_namespace{RelAlgExecutor.cpp}::get_inputs_meta(), anonymous_namespace{RelAlgTranslator.cpp}::get_quantified_rhs(), RelAlgExecutor::makeJoinQuals(), anonymous_namespace{RelAlgExecutor.cpp}::translate_quals(), anonymous_namespace{RelAlgExecutor.cpp}::translate_scalar_sources(), anonymous_namespace{RelAlgExecutor.cpp}::translate_scalar_sources_for_update(), anonymous_namespace{RelAlgExecutor.cpp}::translate_targets(), translateAbs(), translateBinaryGeoConstructor(), translateBinaryGeoFunction(), translateCardinality(), translateCase(), translateDateadd(), translateDatediff(), translateDatepart(), translateDatePlusMinus(), translateDatetime(), translateExtract(), translateFunction(), translateFunctionArgs(), translateFunctionWithGeoArg(), translateGeoComparison(), translateGeoFunctionArg(), translateHPTLiteral(), translateInOper(), translateItem(), translateLength(), translateLike(), translateLikely(), translateOper(), translateOverlapsOper(), translateRegexp(), translateSampleRatio(), translateSign(), translateTernaryGeoFunction(), translateUnlikely(), translateUoper(), translateWidthBucket(), and translateWindowFunction().

                                {
  const auto rex_input = dynamic_cast<const RexInput*>(rex);
  if (rex_input) {
    return translateInput(rex_input);
  }
  const auto rex_literal = dynamic_cast<const RexLiteral*>(rex);
  if (rex_literal) {
    return translateLiteral(rex_literal);
  }
  const auto rex_window_function = dynamic_cast<const RexWindowFunctionOperator*>(rex);
  if (rex_window_function) {
    return translateWindowFunction(rex_window_function);
  }
  const auto rex_function = dynamic_cast<const RexFunctionOperator*>(rex);
  if (rex_function) {
    return translateFunction(rex_function);
  }
  const auto rex_operator = dynamic_cast<const RexOperator*>(rex);
  if (rex_operator) {
    return translateOper(rex_operator);
  }
  const auto rex_case = dynamic_cast<const RexCase*>(rex);
  if (rex_case) {
    return translateCase(rex_case);
  }
  const auto rex_subquery = dynamic_cast<const RexSubQuery*>(rex);
  if (rex_subquery) {
    return translateScalarSubquery(rex_subquery);
  }
  CHECK(false);
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateScalarSubquery ( const RexSubQuery *  rex_subquery ) const

private

Definition at line 360 of file RelAlgTranslator.cpp.

References CHECK, CHECK_EQ, anonymous_namespace{RelAlgTranslator.cpp}::datum_from_scalar_tv(), just_explain_, and run_benchmark_import::result.

Referenced by translateScalarRex().

                                           {
  if (just_explain_) {
    throw std::runtime_error("EXPLAIN is not supported with sub-queries");
  }
  CHECK(rex_subquery);
  auto result = rex_subquery->getExecutionResult();
  auto row_set = result->getRows();
  const size_t row_count = row_set->rowCount();
  if (row_count > size_t(1)) {
    throw std::runtime_error("Scalar sub-query returned multiple rows");
  }
  if (row_count == size_t(0)) {
    if (row_set->isValidationOnlyRes()) {
      Datum d{0};
      return makeExpr<Analyzer::Constant>(rex_subquery->getType(), false, d);
    }
    throw std::runtime_error("Scalar sub-query returned no results");
  }
  CHECK_EQ(row_count, size_t(1));
  row_set->moveToBegin();
  auto first_row = row_set->getNextRow(false, false);
  CHECK_EQ(first_row.size(), size_t(1));
  auto scalar_tv = boost::get<ScalarTargetValue>(&first_row[0]);
  auto ti = rex_subquery->getType();
  if (ti.is_string()) {
    throw std::runtime_error("Scalar sub-queries which return strings not supported");
  }
  Datum d{0};
  bool is_null_const{false};
  std::tie(d, is_null_const) = datum_from_scalar_tv(scalar_tv, ti);
  return makeExpr<Analyzer::Constant>(ti, is_null_const, d);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateSign ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1473 of file RelAlgTranslator.cpp.

References CHECK, CHECK_EQ, RexOperator::getOperand(), kBOOLEAN, kEQ, kGT, kLT, kONE, anonymous_namespace{RelAlgTranslator.cpp}::makeNumericConstant(), RexOperator::size(), and translateScalarRex().

Referenced by translateFunction().

                                                   {
  std::list<std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>
      expr_list;
  CHECK_EQ(size_t(1), rex_function->size());
  const auto operand = translateScalarRex(rex_function->getOperand(0));
  const auto& operand_ti = operand->get_type_info();
  CHECK(operand_ti.is_number());
  const auto zero = makeNumericConstant(operand_ti, 0);
  const auto lt_zero = makeExpr<Analyzer::BinOper>(kBOOLEAN, kLT, kONE, operand, zero);
  expr_list.emplace_back(lt_zero, makeNumericConstant(operand_ti, -1));
  const auto eq_zero = makeExpr<Analyzer::BinOper>(kBOOLEAN, kEQ, kONE, operand, zero);
  expr_list.emplace_back(eq_zero, makeNumericConstant(operand_ti, 0));
  const auto gt_zero = makeExpr<Analyzer::BinOper>(kBOOLEAN, kGT, kONE, operand, zero);
  expr_list.emplace_back(gt_zero, makeNumericConstant(operand_ti, 1));
  return makeExpr<Analyzer::CaseExpr>(
      operand_ti,
      false,
      expr_list,
      makeExpr<Analyzer::Constant>(operand_ti, true, Datum{0}));
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateStringOper ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1323 of file RelAlgTranslator.cpp.

References run_benchmark_import::args, CONCAT, g_enable_string_functions, RexFunctionOperator::getName(), INITCAP, kCAST, kENCODING_DICT, kTEXT, LOWER, LPAD, LTRIM, name_to_string_op_kind(), OVERLAY, REGEXP_REPLACE, REGEXP_SUBSTR, REPEAT, REPLACE, REVERSE, RPAD, RTRIM, SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), SQLTypeInfo::set_fixed_size(), SQLTypeInfo::set_type(), SPLIT_PART, SUBSTRING, TRANSIENT_DICT_ID, translateFunctionArgs(), TRIM, and UPPER.

Referenced by translateFunction().

                                                   {
  const auto func_name = rex_function->getName();
  if (!g_enable_string_functions) {
    std::ostringstream oss;
    oss << "Function " << func_name << " not supported.";
    throw std::runtime_error(oss.str());
  }
  const auto string_op_kind = ::name_to_string_op_kind(func_name);
  auto args = translateFunctionArgs(rex_function);
  // Used by watchdog later to gate queries based on
  if (!args.empty() && !dynamic_cast<const Analyzer::Constant*>(args[0].get())) {
    const auto& arg0_ti = args[0]->get_type_info();
    if (arg0_ti.is_none_encoded_string()) {
      SQLTypeInfo casted_target_ti = arg0_ti;
      casted_target_ti.set_type(kTEXT);
      casted_target_ti.set_compression(kENCODING_DICT);
      casted_target_ti.set_comp_param(TRANSIENT_DICT_ID);
      casted_target_ti.set_fixed_size();
      args[0] = makeExpr<Analyzer::UOper>(
          casted_target_ti, args[0]->get_contains_agg(), kCAST, args[0]);
    }
  }

  switch (string_op_kind) {
    case SqlStringOpKind::LOWER:
      return makeExpr<Analyzer::LowerStringOper>(args);
    case SqlStringOpKind::UPPER:
      return makeExpr<Analyzer::UpperStringOper>(args);
    case SqlStringOpKind::INITCAP:
      return makeExpr<Analyzer::InitCapStringOper>(args);
    case SqlStringOpKind::REVERSE:
      return makeExpr<Analyzer::ReverseStringOper>(args);
    case SqlStringOpKind::REPEAT:
      return makeExpr<Analyzer::RepeatStringOper>(args);
    case SqlStringOpKind::CONCAT:
      return makeExpr<Analyzer::ConcatStringOper>(args);
    case SqlStringOpKind::LPAD:
    case SqlStringOpKind::RPAD: {
      return makeExpr<Analyzer::PadStringOper>(string_op_kind, args);
    }
    case SqlStringOpKind::TRIM:
    case SqlStringOpKind::LTRIM:
    case SqlStringOpKind::RTRIM: {
      return makeExpr<Analyzer::TrimStringOper>(string_op_kind, args);
    }
    case SqlStringOpKind::SUBSTRING:
      return makeExpr<Analyzer::SubstringStringOper>(args);
    case SqlStringOpKind::OVERLAY:
      return makeExpr<Analyzer::OverlayStringOper>(args);
    case SqlStringOpKind::REPLACE:
      return makeExpr<Analyzer::ReplaceStringOper>(args);
    case SqlStringOpKind::SPLIT_PART:
      return makeExpr<Analyzer::SplitPartStringOper>(args);
    case SqlStringOpKind::REGEXP_REPLACE:
      return makeExpr<Analyzer::RegexpReplaceStringOper>(args);
    case SqlStringOpKind::REGEXP_SUBSTR:
      return makeExpr<Analyzer::RegexpSubstrStringOper>(args);
    default: {
      throw std::runtime_error("Unsupported string function.");
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateTernaryGeoFunction ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1547 of file RelAlgTranslatorGeo.cpp.

References CHECK_EQ, Geospatial::get_compression_scheme(), SQLTypeInfo::get_input_srid(), SQLTypeInfo::get_output_srid(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), RexFunctionOperator::getName(), RexOperator::getOperand(), RexOperator::getType(), Datum::intval, kBOOLEAN, kDOUBLE, kGEOGRAPHY, kINT, kLE, kLINESTRING, kMULTIPOLYGON, kONE, kPOINT, kPOLYGON, run_benchmark_import::result, RexOperator::size(), spatial_type::suffix(), translateBinaryGeoFunction(), translateGeoFunctionArg(), and translateScalarRex().

Referenced by translateFunction().

                                                   {
  CHECK_EQ(size_t(3), rex_function->size());

  auto distance_expr = translateScalarRex(rex_function->getOperand(2));
  const auto& distance_ti = SQLTypeInfo(kDOUBLE, false);
  if (distance_expr->get_type_info().get_type() != kDOUBLE) {
    distance_expr = distance_expr->add_cast(distance_ti);
  }

  auto function_name = rex_function->getName();
  if (function_name == "ST_DWithin"sv) {
    auto return_type = rex_function->getType();
    bool swap_args = false;
    bool with_bounds = true;
    SQLTypeInfo arg0_ti;
    SQLTypeInfo arg1_ti;

    auto geoargs0 = translateGeoFunctionArg(
        rex_function->getOperand(0), arg0_ti, with_bounds, false, false);
    auto geoargs1 = translateGeoFunctionArg(
        rex_function->getOperand(1), arg1_ti, with_bounds, false, false);
    if (arg0_ti.get_subtype() != arg1_ti.get_subtype()) {
      throw QueryNotSupported(rex_function->getName() +
                              " cannot accept mixed GEOMETRY/GEOGRAPHY arguments");
    }
    auto is_geodesic = false;
    if (arg0_ti.get_subtype() == kGEOGRAPHY) {
      if (arg0_ti.get_type() == kPOINT && arg1_ti.get_type() == kPOINT) {
        is_geodesic = true;
      } else {
        throw QueryNotSupported(
            rex_function->getName() +
            " in geodesic form can only accept POINT GEOGRAPHY arguments");
      }
    }
    // Check SRID match if at least one is set/valid
    if ((arg0_ti.get_output_srid() > 0 || arg1_ti.get_output_srid() > 0) &&
        arg0_ti.get_output_srid() != arg1_ti.get_output_srid()) {
      throw QueryNotSupported(rex_function->getName() + " cannot accept different SRIDs");
    }

    if ((arg1_ti.get_type() == kPOINT && arg0_ti.get_type() != kPOINT) ||
        (arg1_ti.get_type() == kLINESTRING && arg0_ti.get_type() == kPOLYGON) ||
        (arg1_ti.get_type() == kPOLYGON && arg0_ti.get_type() == kMULTIPOLYGON)) {
      // Swap arguments and use single implementation per arg pair
      swap_args = true;
    }

    // First input's compression mode and SRID args to enable on-the-fly
    // decompression/transforms
    Datum input_compression0;
    input_compression0.intval = Geospatial::get_compression_scheme(arg0_ti);
    Datum input_srid0;
    input_srid0.intval = arg0_ti.get_input_srid();

    // Second input's compression mode and SRID args to enable on-the-fly
    // decompression/transforms
    Datum input_compression1;
    input_compression1.intval = Geospatial::get_compression_scheme(arg1_ti);
    Datum input_srid1;
    input_srid1.intval = arg1_ti.get_input_srid();

    // Output SRID arg to enable on-the-fly transforms
    Datum output_srid;
    output_srid.intval = arg0_ti.get_output_srid();

    std::string specialized_geofunc{function_name};
    std::vector<std::shared_ptr<Analyzer::Expr>> geoargs;
    if (swap_args) {
      specialized_geofunc += suffix(arg1_ti.get_type()) + suffix(arg0_ti.get_type());
      geoargs.insert(geoargs.end(), geoargs1.begin(), geoargs1.end());
      geoargs.insert(geoargs.end(), geoargs0.begin(), geoargs0.end());
      geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression1));
      geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_srid1));
      geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression0));
      geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_srid0));
    } else {
      specialized_geofunc += suffix(arg0_ti.get_type()) + suffix(arg1_ti.get_type());
      if (is_geodesic) {
        specialized_geofunc += "_Geodesic"s;
      }
      geoargs.insert(geoargs.end(), geoargs0.begin(), geoargs0.end());
      geoargs.insert(geoargs.end(), geoargs1.begin(), geoargs1.end());
      geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression0));
      geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_srid0));
      geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression1));
      geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_srid1));
    }
    geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, output_srid));
    // Also add the within distance
    geoargs.push_back(distance_expr);

    auto result =
        makeExpr<Analyzer::FunctionOper>(return_type, specialized_geofunc, geoargs);
    return result;
  }

  // Otherwise translate function as binary geo to get distance,
  // with optional short-circuiting threshold held in the third operand
  const auto geo_distance = translateBinaryGeoFunction(rex_function);
  // and generate the comparison
  return makeExpr<Analyzer::BinOper>(kBOOLEAN, kLE, kONE, geo_distance, distance_expr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateUnaryGeoFunction ( const RexFunctionOperator *  rex_function ) const

private

Definition at line 1038 of file RelAlgTranslatorGeo.cpp.

References CHECK, CHECK_EQ, func_resolve, Geospatial::get_compression_scheme(), SQLTypeInfo::get_input_srid(), SQLTypeInfo::get_output_srid(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), RexFunctionOperator::getName(), RexOperator::getOperand(), RexOperator::getType(), SQLTypeInfo::has_bounds(), Datum::intval, IS_GEO_POLY, kGEOGRAPHY, kINT, kLINESTRING, kMULTIPOLYGON, kPOINT, kPOLYGON, SQLTypeInfo::set_notnull(), RexOperator::size(), spatial_type::suffix(), and translateGeoFunctionArg().

Referenced by translateFunction().

                                                   {
  CHECK_EQ(size_t(1), rex_function->size());

  std::string specialized_geofunc{rex_function->getName()};

  // Geo function calls which do not need the coords col but do need cols associated
  // with physical coords (e.g. ring_sizes / poly_rings)