#include <RelAlgTranslator.h>

Collaboration diagram for RelAlgTranslator:

Public Member Functions
	RelAlgTranslator (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 >	translate (const RexScalar *rex) const

bool	generated_geos_ops ()

template<typename T >
std::shared_ptr< Analyzer::Expr >	translateRexScalar (RexScalar const *) const

template<>
std::shared_ptr< Analyzer::Expr >	translateRexScalar (RexScalar const *rex) const

template<>
std::shared_ptr< Analyzer::Expr >	translateRexScalar (RexScalar const *rex) const

template<>
std::shared_ptr< Analyzer::Expr >	translateRexScalar (RexScalar const *rex) const

template<>
std::shared_ptr< Analyzer::Expr >	translateRexScalar (RexScalar const *rex) const

template<>
std::shared_ptr< Analyzer::Expr >	translateRexScalar (RexScalar const *rex) const

template<>
std::shared_ptr< Analyzer::Expr >	translateRexScalar (RexScalar const *rex) const

template<>
std::shared_ptr< Analyzer::Expr >	translateRexScalar (RexScalar const *rex) const

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 >	translateScalarRex (const RexScalar *rex) const

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 >	translateBoundingBoxIntersectOper (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 >	translateMLPredict (const RexFunctionOperator *) const

std::shared_ptr< Analyzer::Expr >	translatePCAProject (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

std::shared_ptr< Analyzer::Expr >	translateIntervalExprForWindowFraming (std::shared_ptr< Analyzer::Expr > order_key, bool for_preceding_bound, const Analyzer::BinOper *frame_bound_expr) 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 >	translateUnaryGeoConstructor (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 >	translateGeoBoundingBoxIntersectOper (const RexOperator *) const

std::vector< std::shared_ptr < Analyzer::Expr > >	translateGeoFunctionArg (const RexScalar *rex_scalar, SQLTypeInfo &arg_ti, const bool with_bounds, 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 expand_geo_col) const

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

std::pair< std::shared_ptr < Analyzer::Expr > , SQLQualifier >	getQuantifiedRhs (const RexScalar *) const

Private Attributes
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_

robin_hood::unordered_map < RexScalar const *, std::shared_ptr < Analyzer::Expr > >	cache_

Detailed Description

Definition at line 49 of file RelAlgTranslator.h.

Constructor & Destructor Documentation

RelAlgTranslator::RelAlgTranslator	(	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 51 of file RelAlgTranslator.h.

       : 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 74 of file RelAlgTranslator.h.

References generated_geos_ops_.

74 { return generated_geos_ops_; }

RelAlgTranslator::generated_geos_ops_

bool generated_geos_ops_

Definition: RelAlgTranslator.h:240

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

private

Definition at line 923 of file RelAlgTranslator.cpp.

References threading_serial::async(), result_set::can_use_parallel_algorithms(), 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::SysCatalog::getCatalog(), inline_int_null_val(), Catalog_Namespace::SysCatalog::instance(), 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());
       auto col_expr = dynamic_cast<const Analyzer::ColumnVar*>(arg.get());
       CHECK(col_expr);
       const auto& dest_dict_key = arg_type.getStringDictKey();
       const auto& source_dict_key = col_type.getStringDictKey();
       const auto dd = executor_->getStringDictionaryProxy(
           arg_type.getStringDictKey(), val_set.getRowSetMemOwner(), true);
       const auto sd = executor_->getStringDictionaryProxy(
           col_type.getStringDictKey(), val_set.getRowSetMemOwner(), true);
       CHECK(sd);
       const auto needle_null_val = inline_int_null_val(arg_type);
       const auto catalog = Catalog_Namespace::SysCatalog::instance().getCatalog(
           col_expr->getColumnKey().db_id);
       CHECK(catalog);
       fetcher_threads.push_back(std::async(
           std::launch::async,
           [&val_set,
            &total_in_vals_count,
            sd,
            dd,
            &source_dict_key,
            &dest_dict_key,
            needle_null_val,
            catalog](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},
                   catalog->getStringDictionaryHosts(),
                   {source_dict_key.db_id, source_dict_key.dict_id},
                   {dest_dict_key.db_id, dest_dict_key.dict_id},
                   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::pair< std::shared_ptr< Analyzer::Expr >, SQLQualifier > RelAlgTranslator::getQuantifiedRhs ( const RexScalar * rex_scalar ) const

private

Definition at line 58 of file RelAlgTranslator.cpp.

References CHECK_EQ, RexFunctionOperator::getName(), kALL, kANY, kCAST, kONE, and translateScalarRex().

Referenced by translateOper().

                                                                     {
   std::shared_ptr<Analyzer::Expr> rhs;
   SQLQualifier sql_qual{kONE};
   const auto rex_operator = dynamic_cast<const RexOperator*>(rex_scalar);
   if (!rex_operator) {
     return std::make_pair(rhs, sql_qual);
   }
   const auto rex_function = dynamic_cast<const RexFunctionOperator*>(rex_operator);
   const auto qual_str = rex_function ? rex_function->getName() : "";
   if (qual_str == "PG_ANY"sv || qual_str == "PG_ALL"sv) {
     CHECK_EQ(size_t(1), rex_function->size());
     rhs = translateScalarRex(rex_function->getOperand(0));
     sql_qual = (qual_str == "PG_ANY"sv) ? kANY : kALL;
   }
   if (!rhs && rex_operator->getOperator() == kCAST) {
     CHECK_EQ(size_t(1), rex_operator->size());
     std::tie(rhs, sql_qual) = getQuantifiedRhs(rex_operator->getOperand(0));
   }
   return std::make_pair(rhs, sql_qual);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translate ( const RexScalar * rex ) const

Definition at line 259 of file RelAlgTranslator.cpp.

References cache_, and translateScalarRex().

Referenced by anonymous_namespace{RelAlgExecutor.cpp}::get_inputs_meta(), RelAlgExecutor::makeJoinQuals(), anonymous_namespace{RelAlgExecutor.cpp}::translate_quals(), anonymous_namespace{RelAlgExecutor.cpp}::translate_scalar_sources(), anonymous_namespace{RelAlgExecutor.cpp}::translate_scalar_sources_for_update(), and anonymous_namespace{RelAlgExecutor.cpp}::translate_targets().

                                                                                   {
   ScopeGuard clear_cache{[this] { cache_.clear(); }};
   return translateScalarRex(rex);
 }

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 1608 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 278 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(), anonymous_namespace{RelAlgTranslator.cpp}::is_distinct_supported(), RexAgg::isDistinct(), kAPPROX_COUNT_DISTINCT, kAPPROX_QUANTILE, kBOOLEAN, kCOUNT_IF, kDOUBLE, kINT, kMODE, kSUM_IF, RexAgg::size(), ThriftSerializers::takes_arg(), and toString().

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::Expr> 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];
     switch (agg_kind) {
       case kAPPROX_COUNT_DISTINCT:
         if (rex->size() == 2) {
           auto const const_arg1 = std::dynamic_pointer_cast<Analyzer::Constant>(
               scalar_sources[rex->getOperand(1)]);
           if (!const_arg1 || const_arg1->get_type_info().get_type() != kINT ||
               const_arg1->get_constval().intval < 1 ||
               const_arg1->get_constval().intval > 100) {
             throw std::runtime_error(
                 "APPROX_COUNT_DISTINCT's second parameter must be a SMALLINT literal "
                 "between 1 and 100");
           }
           arg1 = scalar_sources[rex->getOperand(1)];
         }
         break;
       case 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);
         }
         break;
       case kMODE:
         if (g_cluster) {
           throw std::runtime_error(
               "MODE is not supported in distributed mode at this time.");
         }
         break;
       case kCOUNT_IF:
         if (arg_expr->get_type_info().is_geometry()) {
           throw std::runtime_error(
               "COUNT_IF does not currently support geospatial types.");
         }
         break;
       case kSUM_IF:
         arg1 = scalar_sources[rex->getOperand(1)];
         if (arg1->get_type_info().get_type() != kBOOLEAN) {
           throw std::runtime_error("Conditional argument must be a boolean expression.");
         }
         break;
       default:
         break;
     }
     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.");
     }
     if (is_distinct && !is_distinct_supported(agg_kind)) {
       throw std::runtime_error(toString(agg_kind) +
                                " does not currently support the DISTINCT qualifier.");
     }
   }
   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 1650 of file RelAlgTranslator.cpp.

References CHECK, get_nullable_logical_type_info(), SQLTypeInfo::get_subtype(), RexOperator::getType(), kARRAY, kBOOLEAN, kENCODING_DICT, kNULLT, kTEXT, shared::StringDictKey::kTransientDictKey, 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) {
                          const auto element_logical_type =
                              get_nullable_logical_type_info(expr->get_type_info());
                          if (first_element_logical_type != element_logical_type) {
                            if (first_element_logical_type.is_none_encoded_string() &&
                                element_logical_type.is_none_encoded_string()) {
                              return false;
                            }
                            return true;
                          }
                          return false;
                        });
       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()) {
         sql_type.set_subtype(kTEXT);
         sql_type.set_compression(kENCODING_DICT);
         if (first_element_logical_type.is_none_encoded_string()) {
           sql_type.set_comp_param(TRANSIENT_DICT_ID);
           sql_type.setStringDictKey(shared::StringDictKey::kTransientDictKey);
         } else {
           CHECK(first_element_logical_type.is_dict_encoded_string());
           sql_type.set_comp_param(first_element_logical_type.get_comp_param());
           sql_type.setStringDictKey(first_element_logical_type.getStringDictKey());
         }
       } else if (first_element_logical_type.is_dict_encoded_string()) {
         sql_type.set_subtype(kTEXT);
         sql_type.set_compression(kENCODING_DICT);
         sql_type.set_comp_param(first_element_logical_type.get_comp_param());
         sql_type.setStringDictKey(first_element_logical_type.getStringDictKey());
       } 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 948 of file RelAlgTranslatorGeo.cpp.

References func_resolve, SQLTypeInfo::get_input_srid(), SQLTypeInfo::get_output_srid(), RexFunctionOperator::getName(), RexOperator::getOperand(), Geospatial::GeoBase::kBUFFER, Geospatial::GeoBase::kCONCAVEHULL, 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;
   } else if (rex_function->getName() == "ST_ConcaveHull"sv) {
     op = Geospatial::GeoBase::GeoOp::kCONCAVEHULL;
   }
 
   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,
                    "ST_ConcaveHull"sv)) {
     // First arg: geometry
     geoargs0 = translateGeoFunctionArg(rex_function->getOperand(0),
                                        arg0_ti,
                                        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,
                                        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, "ST_ConcaveHull"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 1345 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, kMULTILINESTRING, 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_IntersectsBox"sv) {
     // Bounding box intersection 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);
         CHECK_GT(exprs.size(), size_t(0));
         if (ti.get_type() == kPOINT) {
           throw std::runtime_error(
               "ST_IntersectsBox is not supported for point arguments.");
         } else {
           return exprs.back();
         }
       } else {
         throw std::runtime_error(
             "Only inputs are supported as arguments to ST_IntersectsBox 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
                                              /*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,
                                           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,
                                           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");
       }
     }
   }
   if (arg0_ti.get_type() == kMULTILINESTRING || arg1_ti.get_type() == kMULTILINESTRING) {
     throw QueryNotSupported(rex_function->getName() +
                             " currently doesn't support this argument combination");
   }
 
   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 1059 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, true, true);
   SQLTypeInfo arg1_ti;
   auto geoargs1 =
       translateGeoFunctionArg(rex_function->getOperand(1), arg1_ti, 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:

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

private

Definition at line 1068 of file RelAlgTranslator.cpp.

References CHECK, RexOperator::getOperand(), RexOperator::getOperator(), kBBOX_INTERSECT, translateGeoBoundingBoxIntersectOper(), and translateScalarRex().

Referenced by translateOper().

                                            {
   const auto sql_op = rex_operator->getOperator();
   CHECK(sql_op == kBBOX_INTERSECT);
 
   const auto lhs = translateScalarRex(rex_operator->getOperand(0));
   const auto lhs_ti = lhs->get_type_info();
   if (lhs_ti.is_geometry()) {
     return translateGeoBoundingBoxIntersectOper(rex_operator);
   } else {
     throw std::runtime_error(
         "Bounding Box Intersection equivalence is currently only supported for "
         "geospatial types");
   }
 }

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 1538 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 1084 of file RelAlgTranslator.cpp.

References RexCase::branchCount(), executor_, RexCase::getElse(), RexCase::getThen(), RexCase::getWhen(), Parser::CaseExpr::normalize(), and 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:

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

private

Definition at line 1574 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 1581 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 1588 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 1464 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 1287 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 1402 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 1414 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 1320 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 1592 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 1228 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 1722 of file RelAlgTranslator.cpp.

References run_benchmark_import::args, bind_function(), CHECK, CHECK_EQ, CHECK_LE, CHECK_LT, ext_arg_type_to_type_info(), func_resolve, RexFunctionOperator::getName(), RexOperator::getOperand(), RexOperator::getType(), Int64, SQLTypeInfo::is_decimal(), kDIVIDE, kONE, kSMALLINT, kTEXT, LOG, Parser::OperExpr::normalize(), PBool, PDouble, PFloat, PInt16, PInt32, PInt64, PInt8, 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(), translateMLPredict(), translateOffsetInFragment(), translatePCAProject(), translateRegexp(), translateSampleRatio(), translateScalarRex(), translateSign(), translateStringOper(), translateTernaryGeoFunction(), translateUnaryGeoConstructor(), translateUnaryGeoFunction(), translateUnaryGeoPredicate(), translateUnlikely(), translateWidthBucket(), and logger::WARNING.

                                                    {
   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 (rex_function->getName() == "ML_PREDICT"sv) {
     return translateMLPredict(rex_function);
   }
   if (rex_function->getName() == "PCA_PROJECT"sv) {
     return translatePCAProject(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,
                    "JSON_VALUE"sv,
                    "BASE64_ENCODE"sv,
                    "BASE64_DECODE"sv,
                    "TRY_CAST"sv,
                    "POSITION"sv,
                    "JAROWINKLER_SIMILARITY"sv,
                    "LEVENSHTEIN_DISTANCE"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_NumGeometries"sv,
                    "ST_NPoints"sv,
                    "ST_Length"sv,
                    "ST_Perimeter"sv,
                    "ST_Area"sv,
                    "ST_SRID"sv,
                    "HeavyDB_Geo_PolyBoundsPtr"sv)) {
     CHECK_EQ(rex_function->size(), size_t(1));
     return translateUnaryGeoFunction(rex_function);
   }
   if (func_resolve(rex_function->getName(), "ST_ConvexHull"sv)) {
     CHECK_EQ(rex_function->size(), size_t(1));
     SQLTypeInfo ti;
     return translateUnaryGeoConstructor(rex_function, ti, false);
   }
   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_IntersectsBox"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,
                    "ST_ConcaveHull"sv)) {
     CHECK_EQ(rex_function->size(), size_t(2));
     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.getInputArgs();
     CHECK_LE(arg_expr_list.size(), ext_func_args.size());
     for (size_t i = 0, di = 0; i < arg_expr_list.size(); i++) {
       CHECK_LT(i + di, ext_func_args.size());
       auto ext_func_arg = ext_func_args[i + di];
       if (ext_func_arg == ExtArgumentType::PInt8 ||
           ext_func_arg == ExtArgumentType::PInt16 ||
           ext_func_arg == ExtArgumentType::PInt32 ||
           ext_func_arg == ExtArgumentType::PInt64 ||
           ext_func_arg == ExtArgumentType::PFloat ||
           ext_func_arg == ExtArgumentType::PDouble ||
           ext_func_arg == ExtArgumentType::PBool) {
         di++;
         // pointer argument follows length argument:
         CHECK(ext_func_args[i + di] == ExtArgumentType::Int64);
       }
       // 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_arg);
         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:

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

private

Definition at line 2728 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 1785 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, 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, 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, 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::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateGeoBoundingBoxIntersectOper ( const RexOperator * rex_operator ) const

private

Definition at line 1894 of file RelAlgTranslatorGeo.cpp.

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

Referenced by translateBoundingBoxIntersectOper().

                                            {
   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);
     CHECK_GT(exprs.size(), 0u);
     if (ti.get_type() == kPOINT) {
       return exprs.front();
     } else {
       return exprs.back();
     }
   };
 
   SQLQualifier sql_qual{kONE};
   SQLOps sql_op{kBBOX_INTERSECT};
   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::vector< std::shared_ptr< Analyzer::Expr > > RelAlgTranslator::translateGeoColumn	(	const RexInput *	rex_input,
		SQLTypeInfo &	ti,
		const bool	with_bounds,
		const bool	expand_geo_col
	)		const

private

Definition at line 28 of file RelAlgTranslatorGeo.cpp.

References run_benchmark_import::args, CHECK, CHECK_GE, CHECK_LT, SQLTypeInfo::get_physical_coord_cols(), SQLTypeInfo::get_type(), RexAbstractInput::getIndex(), RexInput::getSourceNode(), SQLTypeInfo::has_bounds(), input_to_nest_level_, IS_GEO, and SPIMAP_GEO_PHYSICAL_INPUT.

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

                                      {
   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 db_id{0};
   int32_t table_id{0};
   int column_id{-1};
   const Catalog_Namespace::Catalog* catalog{nullptr};
   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;
 
     catalog = &scan_source->getCatalog();
     db_id = catalog->getDatabaseId();
     const auto gcd =
         catalog->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) {
       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++) {
       CHECK(catalog);
       const auto pcd = catalog->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, shared::ColumnKey{db_id, table_id, pcd->columnId}, rte_idx));
     }
   } else {
     args.push_back(std::make_shared<Analyzer::ColumnVar>(
         ti, shared::ColumnKey{db_id, table_id, column_id}, rte_idx));
   }
   if (with_bounds && ti.has_bounds()) {
     CHECK(catalog);
     const auto bounds_cd = catalog->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, shared::ColumnKey{db_id, table_id, bounds_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 1764 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	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 273 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(), IS_STRING, 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(), translateUnaryGeoConstructor(), and translateUnaryGeoPredicate().

Referenced by translateBinaryGeoConstructor(), translateBinaryGeoFunction(), translateBinaryGeoPredicate(), translateFunctionWithGeoArg(), translateGeoProjection(), translateTernaryGeoFunction(), translateUnaryGeoConstructor(), 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)};
     }
     return translateGeoColumn(rex_input, arg_ti, with_bounds, 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,
                                         "ST_ConcaveHull"sv,
                                         "ST_ConvexHull"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,
                                           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,
                                                  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,
                                           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,
                                                      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, 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,
                                           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,
                                           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 folded_coord1 = fold_expr(cast_coord1.get());
       auto folded_coord2 = fold_expr(cast_coord2.get());
       auto const_coord1 = std::dynamic_pointer_cast<Analyzer::Constant>(folded_coord1);
       auto const_coord2 = std::dynamic_pointer_cast<Analyzer::Constant>(folded_coord2);
       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>>{folded_coord1, folded_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 = {folded_coord1, folded_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,
                                              /*expand_geo_col=*/true,
                                              /*is_projection=*/false,
                                              /*use_geo_expressions=*/true);
       CHECK_EQ(geoargs.size(), size_t(1));
       if (geo_ti.get_output_srid() > 0) {
         // Pick up the arg's srid
         arg_ti.set_input_srid(geo_ti.get_output_srid());
         arg_ti.set_output_srid(geo_ti.get_output_srid());
       }
       if (try_to_compress) {
         // Point compression is requested by a higher level [4326] operation
         if (geo_ti.get_output_srid() == 0) {
           // srid-less geo is considered and is forced to be 4326
           arg_ti.set_input_srid(4326);
           arg_ti.set_output_srid(4326);
         } else {
           CHECK_EQ(arg_ti.get_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())) {
         // Centroid argument is transformed before use,
         // pass the transform to the geo operator
         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_ConvexHull"sv)) {
       CHECK_EQ(size_t(1), rex_function->size());
       // What geo type will the constructor return? Could be anything.
       return {translateUnaryGeoConstructor(rex_function, arg_ti, with_bounds)};
     } else if (func_resolve(rex_function->getName(),
                             "ST_Intersection"sv,
                             "ST_Difference"sv,
                             "ST_Union"sv,
                             "ST_Buffer"sv,
                             "ST_ConcaveHull"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);
       auto const translated_literal_type = translated_literal->get_type_info().get_type();
       if (!IS_STRING(translated_literal_type) && !IS_GEO(translated_literal_type)) {
         // This stops crashes in the createGeoType call below due to datum.stringval
         // being uninitialized when the datum isn't even a string, let alone a geo string
         // There needs to be specific handling for ST_NumGeometries in the code above
         // but I don't know what category it would fall over (it's not GEOS, and it
         // returns an INT, not a BOOL or other geo)
         // simon.eves 8/15/22
         throw QueryNotSupported("Geospatial function requires geo 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);
       const bool validate_with_geos_if_available = false;
       auto geospatial_base = Geospatial::GeoTypesFactory::createGeoType(
           *datum.stringval, validate_with_geos_if_available);
       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 117 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, kMULTILINESTRING, 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();
   const bool validate_with_geos_if_available = false;
   if (!Geospatial::GeoTypesFactory::getGeoColumns(*wkt->get_constval().stringval,
                                                   ti,
                                                   coords,
                                                   bounds,
                                                   ring_sizes,
                                                   poly_rings,
                                                   validate_with_geos_if_available)) {
     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 == kMULTILINESTRING || lit_type == kPOLYGON || lit_type == kMULTIPOLYGON) {
     // [linest]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::translateGeoProjection	(	const RexFunctionOperator *	rex_function,
		SQLTypeInfo &	ti,
		const bool	with_bounds
	)		const

private

Definition at line 898 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,
                                          /*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()) {
     if (rex_function->getName() == "ST_Transform" &&
         std::dynamic_pointer_cast<const Analyzer::GeoConstant>(geoargs.front())) {
       return makeExpr<Analyzer::GeoUOper>(
           Geospatial::GeoBase::GeoOp::kPROJECTION, ti, ti, geoargs);
     }
     // 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,
                                       "ST_ConcaveHull"sv,
                                       "ST_ConvexHull"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 2780 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 703 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 500 of file RelAlgTranslator.cpp.

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

Referenced by translateGeoFunctionArg().

                                      {
   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& catalog = scan_source->getCatalog();
     const auto cd =
         catalog.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,
         shared::ColumnKey{catalog.getDatabaseId(), table_desc->tableId, cd->columnId},
         rte_idx);
   }
   CHECK(!in_metainfo.empty()) << "for "
                               << source->toString(RelRexToStringConfig::defaults());
   CHECK_GE(rte_idx, 0);
   const int32_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, shared::ColumnKey{0, int32_t(-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::translateIntervalExprForWindowFraming	(	std::shared_ptr< Analyzer::Expr >	order_key,
		bool	for_preceding_bound,
		const Analyzer::BinOper *	frame_bound_expr
	)		const

private

Definition at line 2483 of file RelAlgTranslator.cpp.

References Datum::bigintval, CHECK_NE, daINVALID, anonymous_namespace{RelAlgTranslator.cpp}::determineTimeUnit(), anonymous_namespace{RelAlgTranslator.cpp}::determineTimeValMultiplierForTimeType(), Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_right_operand(), Analyzer::Expr::get_type_info(), kBIGINT, kDATE, kDAY, kDECIMAL, kDOUBLE, kHOUR, kINT, kMINUTE, kMONTH, kNUMERIC, kSECOND, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, kYEAR, to_dateadd_field(), and UNREACHABLE.

Referenced by translateWindowFunction().

                                                    {
   // translate time interval expression and prepare appropriate frame bound expression:
   // a) manually compute time unit datum: time type
   // b) use dateadd expression: date and timestamp
   const auto order_key_ti = order_key->get_type_info();
   const auto frame_bound_ti = frame_bound_expr->get_type_info();
   const auto time_val_expr =
       dynamic_cast<const Analyzer::Constant*>(frame_bound_expr->get_left_operand());
   const auto time_unit_val_expr =
       dynamic_cast<const Analyzer::Constant*>(frame_bound_expr->get_right_operand());
   ExtractField time_unit =
       determineTimeUnit(frame_bound_ti.get_type(), time_unit_val_expr);
   bool invalid_time_unit_type = false;
   bool invalid_frame_bound_expr_type = false;
   Datum d;
   auto prepare_time_value_datum = [&d,
                                    &invalid_frame_bound_expr_type,
                                    &time_val_expr,
                                    &for_preceding_bound](bool is_timestamp_second) {
     // currently, Calcite only accepts interval with second, so to represent
     // smaller time units like  millisecond, we have to use decimal point like
     // INTERVAL 0.003 SECOND (for millisecond)
     // thus, depending on what time unit we want to represent, Calcite analyzes
     // the time value to one of following two types: integer and decimal (and
     // numeric) types
     switch (time_val_expr->get_type_info().get_type()) {
       case kTINYINT: {
         d.bigintval = time_val_expr->get_constval().tinyintval;
         break;
       }
       case kSMALLINT: {
         d.bigintval = time_val_expr->get_constval().smallintval;
         break;
       }
       case kINT: {
         d.bigintval = time_val_expr->get_constval().intval;
         break;
       }
       case kBIGINT: {
         d.bigintval = time_val_expr->get_constval().bigintval;
         break;
       }
       case kDECIMAL:
       case kNUMERIC: {
         if (!is_timestamp_second) {
           // date and time type only use integer type as their time value
           invalid_frame_bound_expr_type = true;
           break;
         }
         d.bigintval = time_val_expr->get_constval().bigintval;
         break;
       }
       case kDOUBLE: {
         if (!is_timestamp_second) {
           // date and time type only use integer type as their time value
           invalid_frame_bound_expr_type = true;
           break;
         }
         d.bigintval = time_val_expr->get_constval().doubleval *
                       pow(10, time_val_expr->get_type_info().get_scale());
         break;
       }
       default: {
         invalid_frame_bound_expr_type = true;
         break;
       }
     }
     if (for_preceding_bound) {
       d.bigintval *= -1;
     }
   };
 
   switch (order_key_ti.get_type()) {
     case kTIME: {
       if (time_val_expr->get_type_info().is_integer()) {
         if (time_unit == kSECOND || time_unit == kMINUTE || time_unit == kHOUR) {
           const auto time_multiplier = determineTimeValMultiplierForTimeType(
               frame_bound_ti.get_type(), time_unit_val_expr);
           switch (time_val_expr->get_type_info().get_type()) {
             case kTINYINT: {
               d.bigintval = time_val_expr->get_constval().tinyintval * time_multiplier;
               break;
             }
             case kSMALLINT: {
               d.bigintval = time_val_expr->get_constval().smallintval * time_multiplier;
               break;
             }
             case kINT: {
               d.bigintval = time_val_expr->get_constval().intval * time_multiplier;
               break;
             }
             case kBIGINT: {
               d.bigintval = time_val_expr->get_constval().bigintval * time_multiplier;
               break;
             }
             default: {
               UNREACHABLE();
               break;
             }
           }
         } else {
           invalid_frame_bound_expr_type = true;
         }
       } else {
         invalid_time_unit_type = true;
       }
       if (invalid_frame_bound_expr_type) {
         throw std::runtime_error(
             "Invalid time unit is used to define window frame bound expression for " +
             order_key_ti.get_type_name() + " type");
       } else if (invalid_time_unit_type) {
         throw std::runtime_error(
             "Window frame bound expression has an invalid type for " +
             order_key_ti.get_type_name() + " type");
       }
       return std::make_shared<Analyzer::Constant>(kBIGINT, false, d);
     }
     case kDATE: {
       DateaddField daField = DateaddField::daINVALID;
       if (time_val_expr->get_type_info().is_integer()) {
         switch (time_unit) {
           case kDAY: {
             daField = to_dateadd_field("day");
             break;
           }
           case kMONTH: {
             daField = to_dateadd_field("month");
             break;
           }
           case kYEAR: {
             daField = to_dateadd_field("year");
             break;
           }
           default: {
             invalid_frame_bound_expr_type = true;
             break;
           }
         }
       } else {
         invalid_time_unit_type = true;
       }
       if (invalid_frame_bound_expr_type) {
         throw std::runtime_error(
             "Invalid time unit is used to define window frame bound expression for " +
             order_key_ti.get_type_name() + " type");
       } else if (invalid_time_unit_type) {
         throw std::runtime_error(
             "Window frame bound expression has an invalid type for " +
             order_key_ti.get_type_name() + " type");
       }
       CHECK_NE(daField, DateaddField::daINVALID);
       prepare_time_value_datum(false);
       const auto cast_number_units = makeExpr<Analyzer::Constant>(kBIGINT, false, d);
       const int dim = order_key_ti.get_dimension();
       return makeExpr<Analyzer::DateaddExpr>(
           SQLTypeInfo(kTIMESTAMP, dim, 0, false), daField, cast_number_units, order_key);
     }
     case kTIMESTAMP: {
       DateaddField daField = DateaddField::daINVALID;
       switch (time_unit) {
         case kSECOND: {
           switch (time_val_expr->get_type_info().get_scale()) {
             case 0: {
               daField = to_dateadd_field("second");
               break;
             }
             case 3: {
               daField = to_dateadd_field("millisecond");
               break;
             }
             case 6: {
               daField = to_dateadd_field("microsecond");
               break;
             }
             case 9: {
               daField = to_dateadd_field("nanosecond");
               break;
             }
             default:
               UNREACHABLE();
               break;
           }
           prepare_time_value_datum(true);
           break;
         }
         case kMINUTE: {
           daField = to_dateadd_field("minute");
           prepare_time_value_datum(false);
           break;
         }
         case kHOUR: {
           daField = to_dateadd_field("hour");
           prepare_time_value_datum(false);
           break;
         }
         case kDAY: {
           daField = to_dateadd_field("day");
           prepare_time_value_datum(false);
           break;
         }
         case kMONTH: {
           daField = to_dateadd_field("month");
           prepare_time_value_datum(false);
           break;
         }
         case kYEAR: {
           daField = to_dateadd_field("year");
           prepare_time_value_datum(false);
           break;
         }
         default: {
           invalid_time_unit_type = true;
           break;
         }
       }
       if (!invalid_time_unit_type) {
         CHECK_NE(daField, DateaddField::daINVALID);
         const auto cast_number_units = makeExpr<Analyzer::Constant>(kBIGINT, false, d);
         const int dim = order_key_ti.get_dimension();
         return makeExpr<Analyzer::DateaddExpr>(SQLTypeInfo(kTIMESTAMP, dim, 0, false),
                                                daField,
                                                cast_number_units,
                                                order_key);
       }
       return nullptr;
     }
     default: {
       UNREACHABLE();
       break;
     }
   }
   if (invalid_frame_bound_expr_type) {
     throw std::runtime_error(
         "Invalid time unit is used to define window frame bound expression for " +
         order_key_ti.get_type_name() + " type");
   } else if (invalid_time_unit_type) {
     throw std::runtime_error("Window frame bound expression has an invalid type for " +
                              order_key_ti.get_type_name() + " type");
   }
   return nullptr;
 }

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 1565 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 1433 of file RelAlgTranslator.cpp.

References run_benchmark_import::args, CHECK_EQ, RexFunctionOperator::getName(), kUNNEST, 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.");
   }
   auto unnest_arg = dynamic_cast<Analyzer::UOper*>(expr);
   if (unnest_arg && unnest_arg->get_optype() == SQLOps::kUNNEST) {
     throw std::runtime_error(
         rex_function->getName() +
         " does not support unnest operator as its input expression.");
   }
   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 1425 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 1174 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 1203 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 363 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, kGEOMETRY, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNULLT, kTEXT, kTIME, kTIMESTAMP, LOG, and make_fp_constant().

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

                                    {
   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>(SQLTypeInfo(rex_literal->getType(),
                                                    rex_literal->getPrecision(),
                                                    rex_literal->getScale(),
                                                    false),
                                        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);
       }
       if (target_ti.get_type() == kGEOMETRY) {
         // Specific geo type will be set in a normalization step if needed.
         return makeExpr<Analyzer::Constant>(kNULLT, true, Datum{0});
       }
       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::translateMLPredict ( const RexFunctionOperator * rex_function ) const

private

Definition at line 1100 of file RelAlgTranslator.cpp.

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

Referenced by translateFunction().

                                                    {
   const auto num_operands = rex_function->size();
   CHECK_GE(num_operands, 2UL);
   auto model_value = translateScalarRex(rex_function->getOperand(0));
   std::vector<std::shared_ptr<Analyzer::Expr>> regressor_values;
   for (size_t regressor_idx = 1; regressor_idx < num_operands; ++regressor_idx) {
     regressor_values.emplace_back(
         translateScalarRex(rex_function->getOperand(regressor_idx)));
   }
   return makeExpr<Analyzer::MLPredictExpr>(model_value, regressor_values);
 }

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 1646 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 1026 of file RelAlgTranslator.cpp.

References CHECK, CHECK_GT, executor_, RexOperator::getOperand(), RexOperator::getOperator(), getQuantifiedRhs(), IS_COMPARISON, kBBOX_INTERSECT, kIN, kMINUS, kONE, kPLUS, Parser::OperExpr::normalize(), RexOperator::size(), translateBoundingBoxIntersectOper(), translateDatePlusMinus(), translateGeoComparison(), translateInOper(), translateScalarRex(), and translateUoper().

                                            {
   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 == kBBOX_INTERSECT) {
     return translateBoundingBoxIntersectOper(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) = getQuantifiedRhs(rhs_op);
     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:

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

private

Definition at line 1113 of file RelAlgTranslator.cpp.

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

Referenced by translateFunction().

                                                    {
   const auto num_operands = rex_function->size();
   CHECK_GE(num_operands, 3UL);
   auto model_value = translateScalarRex(rex_function->getOperand(0));
   std::vector<std::shared_ptr<Analyzer::Expr>> feature_values;
   for (size_t feature_idx = 1; feature_idx < num_operands - 1; ++feature_idx) {
     feature_values.emplace_back(
         translateScalarRex(rex_function->getOperand(feature_idx)));
   }
   auto pc_dimension_value =
       translateScalarRex(rex_function->getOperand(num_operands - 1));
   return makeExpr<Analyzer::PCAProjectExpr>(
       model_value, feature_values, pc_dimension_value);
 }

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 1189 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:

template<>

std::shared_ptr<Analyzer::Expr> RelAlgTranslator::translateRexScalar ( RexScalar const * rex ) const

Definition at line 205 of file RelAlgTranslator.cpp.

                                 {
   return translateLiteral(static_cast<RexLiteral const*>(rex));
 }

template<>

std::shared_ptr<Analyzer::Expr> RelAlgTranslator::translateRexScalar ( RexScalar const * rex ) const

Definition at line 216 of file RelAlgTranslator.cpp.

                                 {
   return translateFunction(static_cast<RexFunctionOperator const*>(rex));
 }

template<>

std::shared_ptr<Analyzer::Expr> RelAlgTranslator::translateRexScalar ( RexScalar const * rex ) const

Definition at line 231 of file RelAlgTranslator.cpp.

                                 {
   return translateScalarSubquery(static_cast<RexSubQuery const*>(rex));
 }

template<>

std::shared_ptr<Analyzer::Expr> RelAlgTranslator::translateRexScalar ( RexScalar const * rex ) const

Definition at line 211 of file RelAlgTranslator.cpp.

                                 {
   return translateWindowFunction(static_cast<RexWindowFunctionOperator const*>(rex));
 }

template<>

std::shared_ptr<Analyzer::Expr> RelAlgTranslator::translateRexScalar ( RexScalar const * rex ) const

Definition at line 221 of file RelAlgTranslator.cpp.

                                 {
   return translateOper(static_cast<RexOperator const*>(rex));
 }

template<>

std::shared_ptr<Analyzer::Expr> RelAlgTranslator::translateRexScalar ( RexScalar const * rex ) const

Definition at line 226 of file RelAlgTranslator.cpp.

                                 {
   return translateCase(static_cast<RexCase const*>(rex));
 }

template<>

std::shared_ptr<Analyzer::Expr> RelAlgTranslator::translateRexScalar ( RexScalar const * rex ) const

Definition at line 200 of file RelAlgTranslator.cpp.

                                 {
   return translateInput(static_cast<RexInput const*>(rex));
 }

template<typename T >

std::shared_ptr<Analyzer::Expr> RelAlgTranslator::translateRexScalar ( RexScalar const * ) const

inline

Definition at line 77 of file RelAlgTranslator.h.

                                                                          {
     throw std::runtime_error("Specialization of translateRexScalar() required.");
   }

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

private

Definition at line 1452 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

private

Definition at line 236 of file RelAlgTranslator.cpp.

References cache_, CHECK, and anonymous_namespace{RelAlgTranslator.cpp}::makeHandlers().

Referenced by getQuantifiedRhs(), translate(), translateAbs(), translateBinaryGeoConstructor(), translateBinaryGeoFunction(), translateBoundingBoxIntersectOper(), translateCardinality(), translateCase(), translateDateadd(), translateDatediff(), translateDatepart(), translateDatePlusMinus(), translateDatetime(), translateExtract(), translateFunction(), translateFunctionArgs(), translateFunctionWithGeoArg(), translateGeoComparison(), translateGeoFunctionArg(), translateHPTLiteral(), translateInOper(), translateItem(), translateLength(), translateLike(), translateLikely(), translateMLPredict(), translateOper(), translatePCAProject(), translateRegexp(), translateSampleRatio(), translateSign(), translateTernaryGeoFunction(), translateUnlikely(), translateUoper(), translateWidthBucket(), and translateWindowFunction().

                                 {
   auto cache_itr = cache_.find(rex);
   if (cache_itr == cache_.end()) {
     // Order types from most likely to least as they are compared seriatim.
     static auto const handlers = makeHandlers<RexInput,
                                               RexLiteral,
                                               RexOperator,
                                               RexCase,
                                               RexFunctionOperator,
                                               RexWindowFunctionOperator,
                                               RexSubQuery>();
     static_assert(std::is_trivially_destructible_v<decltype(handlers)>);
     auto it = std::find_if(handlers.cbegin(), handlers.cend(), ByTypeIndex{typeid(*rex)});
     CHECK(it != handlers.cend()) << "Unhandled type: " << typeid(*rex).name();
     // Call handler based on typeid(*rex) and cache the std::shared_ptr<Analyzer::Expr>.
     auto cached = cache_.emplace(rex, (this->*it->second)(rex));
     CHECK(cached.second) << "Failed to emplace rex of type " << typeid(*rex).name();
     cache_itr = cached.first;
   }
   return cache_itr->second;
 }

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 452 of file RelAlgTranslator.cpp.

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

                                            {
   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");
   }
   auto ti = rex_subquery->getType();
   if (g_cluster && ti.is_string()) {
     throw std::runtime_error(
         "Scalar sub-queries which return strings not supported in distributed mode");
   }
   if (row_count == size_t(0)) {
     if (row_set->isValidationOnlyRes()) {
       Datum d{0};
       if (ti.is_string()) {
         // keep the valid ptr to avoid crash during the query validation
         // this ptr will be removed when destructing corresponding constant variable
         d.stringval = new std::string();
       }
       if (ti.is_dict_encoded_string()) {
         // we set a valid ptr for string literal in above which is not dictionary-encoded
         ti.set_compression(EncodingType::kENCODING_NONE);
       }
       return makeExpr<Analyzer::Constant>(ti, false, d);
     }
     throw std::runtime_error("Scalar sub-query returned no results");
   }
   CHECK_EQ(row_count, size_t(1));
   row_set->moveToBegin();
   auto const first_row = row_set->getNextRow(ti.is_dict_encoded_string(), false);
   CHECK_EQ(first_row.size(), size_t(1));
   Datum d{0};
   bool is_null_const{false};
   auto scalar_tv = boost::get<ScalarTargetValue>(&first_row[0]);
   std::tie(d, is_null_const) = datum_from_scalar_tv(scalar_tv, ti);
   if (ti.is_dict_encoded_string()) {
     // we already translate the string, so let's make its type as a string literal
     ti.set_compression(EncodingType::kENCODING_NONE);
   }
   return makeExpr<Analyzer::Constant>(ti, is_null_const, d);
 }

Here is the call graph for this function:

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

private

Definition at line 1624 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 1473 of file RelAlgTranslator.cpp.

References run_benchmark_import::args, BASE64_DECODE, BASE64_ENCODE, CONCAT, g_enable_string_functions, RexFunctionOperator::getName(), RexOperator::getType(), INITCAP, JAROWINKLER_SIMILARITY, JSON_VALUE, LEVENSHTEIN_DISTANCE, LOWER, LPAD, LTRIM, name_to_string_op_kind(), OVERLAY, POSITION, REGEXP_REPLACE, REGEXP_SUBSTR, REPEAT, REPLACE, REVERSE, RPAD, RTRIM, SPLIT_PART, SUBSTRING, translateFunctionArgs(), TRIM, TRY_STRING_CAST, 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);
 
   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);
     case SqlStringOpKind::JSON_VALUE:
       return makeExpr<Analyzer::JsonValueStringOper>(args);
     case SqlStringOpKind::BASE64_ENCODE:
       return makeExpr<Analyzer::Base64EncodeStringOper>(args);
     case SqlStringOpKind::BASE64_DECODE:
       return makeExpr<Analyzer::Base64DecodeStringOper>(args);
     case SqlStringOpKind::TRY_STRING_CAST:
       return makeExpr<Analyzer::TryStringCastOper>(rex_function->getType(), args);
     case SqlStringOpKind::POSITION:
       return makeExpr<Analyzer::PositionStringOper>(args);
     case SqlStringOpKind::JAROWINKLER_SIMILARITY:
       return makeExpr<Analyzer::JarowinklerSimilarityStringOper>(args);
     case SqlStringOpKind::LEVENSHTEIN_DISTANCE:
       return makeExpr<Analyzer::LevenshteinDistanceStringOper>(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 1659 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);
     auto geoargs1 =
         translateGeoFunctionArg(rex_function->getOperand(1), arg1_ti, with_bounds, 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::translateUnaryGeoConstructor	(	const RexFunctionOperator *	rex_function,
		SQLTypeInfo &	ti,
		const bool	with_bounds
	)		const

private

Definition at line 1081 of file RelAlgTranslatorGeo.cpp.

References func_resolve, SQLTypeInfo::get_input_srid(), SQLTypeInfo::get_output_srid(), RexFunctionOperator::getName(), RexOperator::getOperand(), Geospatial::GeoBase::kCONVEXHULL, kENCODING_NONE, kGEOMETRY, kMULTIPOLYGON, SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), SQLTypeInfo::set_input_srid(), SQLTypeInfo::set_output_srid(), SQLTypeInfo::set_subtype(), SQLTypeInfo::set_type(), and translateGeoFunctionArg().

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::kCONVEXHULL;
 
   Analyzer::ExpressionPtrVector geoargs0{};
   SQLTypeInfo arg0_ti;
   if (func_resolve(rex_function->getName(), "ST_ConvexHull"sv)) {
     // First arg: geometry
     geoargs0 = translateGeoFunctionArg(rex_function->getOperand(0),
                                        arg0_ti,
                                        false,
                                        true,
                                        true,
                                        false,
                                        false,
                                        /* allow_gdal_transforms = */ true);
   }
 
   // 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::GeoUOper>(op, arg_ti, arg0_ti, geoargs0);
 }

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 1132 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, IS_GEO_POLY, kARRAY, kGEOGRAPHY, kINT, kLINESTRING, kMULTILINESTRING, kPOINT, kTINYINT, 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)
   if (rex_function->getName() == "ST_NRings"sv) {
     SQLTypeInfo arg_ti;
     auto geoargs = translateGeoFunctionArg(rex_function->getOperand(0),
                                            arg_ti,
                                            /*with_bounds=*/false,
                                            /*expand_geo_col=*/true,
                                            /*is_projection=*/false,
                                            /*use_geo_expressions=*/true);
     if (!IS_GEO_POLY(arg_ti.get_type())) {
       throw QueryNotSupported(rex_function->getName() +
                               " expects a POLYGON or MULTIPOLYGON");
     }
     CHECK_EQ(geoargs.size(), size_t(1));
     arg_ti = rex_function->getType();  // TODO: remove
     return makeExpr<Analyzer::GeoOperator>(
         rex_function->getType(),
         rex_function->getName(),
         std::vector<std::shared_ptr<Analyzer::Expr>>{geoargs.front()});
   } else if (rex_function->getName() == "ST_NumGeometries"sv) {
     SQLTypeInfo arg_ti;
     auto geoargs = translateGeoFunctionArg(rex_function->getOperand(0),
                                            arg_ti,
                                            /*with_bounds=*/false,
                                            /*expand_geo_col=*/true,
                                            /*is_projection=*/false,
                                            /*use_geo_expressions=*/true);
     if (!IS_GEO(arg_ti.get_type())) {
       throw QueryNotSupported(rex_function->getName() + " expects a geo parameter");
     }
     CHECK_EQ(geoargs.size(), size_t(1));
     arg_ti = rex_function->getType();  // TODO: remove
     return makeExpr<Analyzer::GeoOperator>(
         rex_function->getType(),
         rex_function->getName(),
         std::vector<std::shared_ptr<Analyzer::Expr>>{geoargs.front()});
   } else if (rex_function->getName() == "ST_NPoints"sv) {
     SQLTypeInfo arg_ti;
     auto geoargs = translateGeoFunctionArg(rex_function->getOperand(0),
                                            arg_ti,
                                            /*with_bounds=*/false,
                                            /*expand_geo_col=*/true,
                                            /*is_projection=*/false,
                                            /*use_geo_expressions=*/true);
     CHECK_EQ(geoargs.size(), size_t(1));
     return makeExpr<Analyzer::GeoOperator>(
         rex_function->getType(),
         rex_function->getName(),
         std::vector<std::shared_ptr<Analyzer::Expr>>{geoargs.front()});
   } else if (func_resolve(rex_function->getName(), "ST_Perimeter"sv, "ST_Area"sv)) {
     SQLTypeInfo arg_ti;
     int legacy_transform_srid = 0;  // discard
     auto geoargs = translateGeoFunctionArg(rex_function->getOperand(0),
                                            arg_ti,
                                            /*with_bounds=*/false,
                                            /*expand_geo_col=*/true,
                                            /*is_projection=*/false,
                                            /*use_geo_expressions=*/true);
     CHECK_EQ(geoargs.size(), size_t(1));
     if (arg_ti.get_input_srid() != arg_ti.get_output_srid() &&
         arg_ti.get_output_srid() > 0 &&
         std::dynamic_pointer_cast<Analyzer::ColumnVar>(geoargs.front())) {
       // legacy transform
       legacy_transform_srid = arg_ti.get_output_srid();
       // Reset the transform, transform will be given to the operator as an override
       arg_ti = geoargs.front()->get_type_info();
     }
     if (!IS_GEO_POLY(arg_ti.get_type())) {
       throw QueryNotSupported(rex_function->getName() +
                               " expects a POLYGON or MULTIPOLYGON");
     }
     return makeExpr<Analyzer::GeoOperator>(
         rex_function->getType(),
         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);
   }
 
   // Accessor for poly bounds for in-situ poly render queries
   if (func_resolve(rex_function->getName(), "HeavyDB_Geo_PolyBoundsPtr"sv)) {
     SQLTypeInfo arg_ti;
     // get geo column plus bounds only (not expanded)
     auto geoargs =
         translateGeoFunctionArg(rex_function->getOperand(0), arg_ti, true, false, false);
     // this function only works on polys
     if (!IS_GEO_POLY(arg_ti.get_type())) {
       throw QueryNotSupported(rex_function->getName() +
                               " expects a POLYGON or MULTIPOLYGON");
     }
     // only need the bounds argument (last), discard the rest
     geoargs.erase(geoargs.begin(), geoargs.end() - 1);
     // done
     return makeExpr<Analyzer::FunctionOper>(
         rex_function->getType(), specialized_geofunc, geoargs);
   }
 
   // start to move geo expressions above the generic translation call, as geo expression
   // error handling can differ
   if (func_resolve(rex_function->getName(), "ST_X"sv, "ST_Y"sv)) {
     SQLTypeInfo arg_ti;
     auto new_geoargs = translateGeoFunctionArg(rex_function->getOperand(0),
                                                arg_ti,
                                                /*with_bounds=*/false,
                                                /*expand_geo_col=*/true,
                                                /*is_projection=*/true,
                                                /*use_geo_expressions=*/true);
     CHECK_EQ(new_geoargs.size(), size_t(1));
     CHECK(new_geoargs.front());
     const auto& arg_expr_ti = new_geoargs.front()->get_type_info();
     if (arg_expr_ti.get_type() != kPOINT) {
       throw QueryNotSupported(rex_function->getName() + " expects a POINT");
     }
     auto function_ti = rex_function->getType();
     if (std::dynamic_pointer_cast<Analyzer::GeoOperator>(new_geoargs.front())) {
       function_ti.set_notnull(false);
     }
     if (std::dynamic_pointer_cast<Analyzer::GeoConstant>(new_geoargs.front())) {
       // TODO(adb): fixup null handling
       function_ti.set_notnull(true);
     }
     return makeExpr<Analyzer::GeoOperator>(
         function_ti,
         rex_function->getName(),
         std::vector<std::shared_ptr<Analyzer::Expr>>{new_geoargs.front()});
   }
 
   // All functions below use geo col as reference and expand it as necessary
   SQLTypeInfo arg_ti;
   bool with_bounds = true;
   auto geoargs =
       translateGeoFunctionArg(rex_function->getOperand(0), arg_ti, with_bounds, false);
 
   if (rex_function->getName() == "ST_SRID"sv) {
     Datum output_srid;
     output_srid.intval = arg_ti.get_output_srid();
     return makeExpr<Analyzer::Constant>(kINT, false, output_srid);
   }
 
   if (func_resolve(
           rex_function->getName(), "ST_XMin"sv, "ST_YMin"sv, "ST_XMax"sv, "ST_YMax"sv)) {
     // If type has bounds - use them, otherwise look at coords
     if (arg_ti.has_bounds()) {
       // Only need the bounds argument, discard the rest
       geoargs.erase(geoargs.begin(), geoargs.end() - 1);
 
       // Supply srids too - transformed geo would have a transformed bounding box
       Datum input_srid;
       input_srid.intval = arg_ti.get_input_srid();
       geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_srid));
       Datum output_srid;
       output_srid.intval = arg_ti.get_output_srid();
       geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, output_srid));
 
       specialized_geofunc += "_Bounds"s;
       return makeExpr<Analyzer::FunctionOper>(
           rex_function->getType(), specialized_geofunc, geoargs);
     }
   }
 
   // Unless overriden, function is assumed to be interested in the first geoarg only,
   // which may be a geo object (e.g. geo column), or a coord array (e.g. geo literal)
   auto discard_after_arg = 1;
 
   if (rex_function->getName() == "ST_Length"sv) {
     if (arg_ti.get_type() != kLINESTRING && arg_ti.get_type() != kMULTILINESTRING) {
       throw QueryNotSupported(rex_function->getName() +
                               " expects LINESTRING or MULTILINESTRING");
     }
     if (arg_ti.get_type() == kMULTILINESTRING) {
       auto ti0 = geoargs[0]->get_type_info();
       if (ti0.get_type() == kARRAY && ti0.get_subtype() == kTINYINT) {
         // Received expanded geo: widen the reach to grab linestring size array as well
         discard_after_arg = 2;
       }
     }
     specialized_geofunc += suffix(arg_ti.get_type());
     if (arg_ti.get_subtype() == kGEOGRAPHY && arg_ti.get_output_srid() == 4326) {
       if (arg_ti.get_type() == kMULTILINESTRING) {
         throw QueryNotSupported(rex_function->getName() +
                                 " Geodesic is not supported for MULTILINESTRING");
       }
       specialized_geofunc += "_Geodesic"s;
     }
   }
 
   geoargs.erase(geoargs.begin() + discard_after_arg, geoargs.end());
 
   // Add input compression mode and SRID args to enable on-the-fly
   // decompression/transforms
   Datum input_compression;
   input_compression.intval = Geospatial::get_compression_scheme(arg_ti);
   geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression));
   Datum input_srid;
   input_srid.intval = arg_ti.get_input_srid();
   geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_srid));
 
   // Add output SRID arg to enable on-the-fly transforms
   Datum output_srid;
   output_srid.intval = arg_ti.get_output_srid();
   geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, output_srid));
 
   return makeExpr<Analyzer::FunctionOper>(
       rex_function->getType(), specialized_geofunc, geoargs);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

Definition at line 1041 of file RelAlgTranslatorGeo.cpp.

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

Referenced by translateFunction(), and translateGeoFunctionArg().

                                   {
 #ifndef ENABLE_GEOS
   throw QueryNotSupported(rex_function->getName() +
                           " geo predicate requires enabled GEOS support");
 #endif
   SQLTypeInfo arg_ti;
   auto geoargs =
       translateGeoFunctionArg(rex_function->getOperand(0), arg_ti, false, true, true);
   ti = SQLTypeInfo(kBOOLEAN, false);
   auto op = (rex_function->getName() == "ST_IsEmpty"sv)
                 ? Geospatial::GeoBase::GeoOp::kISEMPTY
                 : Geospatial::GeoBase::GeoOp::kISVALID;
   return makeExpr<Analyzer::GeoUOper>(op, ti, arg_ti, geoargs);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

Definition at line 1210 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.0625);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

Definition at line 556 of file RelAlgTranslator.cpp.

References CHECK, CHECK_EQ, CHECK_NE, g_cluster, RexOperator::getOperand(), RexOperator::getOperator(), RexOperator::getType(), is_null(), kBOOLEAN, kCAST, kDATE, kENCODE_TEXT, kENCODING_DICT, kISNOTNULL, kISNULL, kMINUS, kNOT, kNULLT, kTEXT, shared::StringDictKey::kTransientDictKey, kUMINUS, kUNNEST, SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), SQLTypeInfo::set_fixed_size(), SQLTypeInfo::set_type(), SQLTypeInfo::setStringDictKey(), RexOperator::size(), TRANSIENT_DICT_ID, and translateScalarRex().

Referenced by translateOper().

                                            {
   CHECK_EQ(size_t(1), rex_operator->size());
   const auto operand_expr = translateScalarRex(rex_operator->getOperand(0));
   const auto sql_op = rex_operator->getOperator();
   switch (sql_op) {
     case kCAST: {
       const auto& target_ti = rex_operator->getType();
       CHECK_NE(kNULLT, target_ti.get_type());
       const auto& operand_ti = operand_expr->get_type_info();
       if (operand_ti.is_string() && target_ti.is_string()) {
         return operand_expr;
       }
       if (target_ti.is_time() ||
           operand_ti
               .is_string()) {  // TODO(alex): check and unify with the rest of the cases
         // Do not propogate encoding on small dates
         return target_ti.is_date_in_days()
                    ? operand_expr->add_cast(SQLTypeInfo(kDATE, false))
                    : operand_expr->add_cast(target_ti);
       }
       if (!operand_ti.is_string() && target_ti.is_string()) {
         return operand_expr->add_cast(target_ti);
       }
       return std::make_shared<Analyzer::UOper>(target_ti, false, sql_op, operand_expr);
     }
     case kENCODE_TEXT: {
       const auto& target_ti = rex_operator->getType();
       CHECK_NE(kNULLT, target_ti.get_type());
       const auto& operand_ti = operand_expr->get_type_info();
       CHECK(operand_ti.is_string());
       if (operand_ti.is_dict_encoded_string()) {
         // No cast needed
         return operand_expr;
       }
       if (operand_expr->get_num_column_vars(true) == 0UL) {
         return operand_expr;
       }
       if (g_cluster) {
         throw std::runtime_error(
             "ENCODE_TEXT is not currently supported in distributed mode at this time.");
       }
       SQLTypeInfo casted_target_ti = operand_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.setStringDictKey(shared::StringDictKey::kTransientDictKey);
       casted_target_ti.set_fixed_size();
       return makeExpr<Analyzer::UOper>(
           casted_target_ti, operand_expr->get_contains_agg(), kCAST, operand_expr);
     }
     case kNOT:
     case kISNULL: {
       return std::make_shared<Analyzer::UOper>(kBOOLEAN, sql_op, operand_expr);
     }
     case kISNOTNULL: {
       auto is_null = std::make_shared<Analyzer::UOper>(kBOOLEAN, kISNULL, operand_expr);
       return std::make_shared<Analyzer::UOper>(kBOOLEAN, kNOT, is_null);
     }
     case kMINUS: {
       const auto& ti = operand_expr->get_type_info();
       return std::make_shared<Analyzer::UOper>(ti, false, kUMINUS, operand_expr);
     }
     case kUNNEST: {
       const auto& ti = operand_expr->get_type_info();
       CHECK(ti.is_array());
       return makeExpr<Analyzer::UOper>(ti.get_elem_type(), false, kUNNEST, operand_expr);
     }
     default:
       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::translateWidthBucket ( const RexFunctionOperator * rex_function ) const

private

Definition at line 1129 of file RelAlgTranslator.cpp.

References CHECK, RexOperator::getOperand(), kDOUBLE, kNULLT, gpu_enabled::lower_bound(), RexOperator::size(), translateScalarRex(), and gpu_enabled::upper_bound().

Referenced by translateFunction().

                                                    {
   CHECK(rex_function->size() == 4);
   auto target_value = translateScalarRex(rex_function->getOperand(0));
   auto lower_bound = translateScalarRex(rex_function->getOperand(1));
   auto upper_bound = translateScalarRex(rex_function->getOperand(2));
   auto partition_count = translateScalarRex(rex_function->getOperand(3));
   if (!partition_count->get_type_info().is_integer()) {
     throw std::runtime_error(
         "PARTITION_COUNT expression of width_bucket function expects an integer type.");
   }
   auto check_numeric_type =
       [](const std::string& col_name, const Analyzer::Expr* expr, bool allow_null_type) {
         if (expr->get_type_info().get_type() == kNULLT) {
           if (!allow_null_type) {
             throw std::runtime_error(
                 col_name + " expression of width_bucket function expects non-null type.");
           }
           return;
         }
         if (!expr->get_type_info().is_number()) {
           throw std::runtime_error(
               col_name + " expression of width_bucket function expects a numeric type.");
         }
       };
   // target value may have null value
   check_numeric_type("TARGET_VALUE", target_value.get(), true);
   check_numeric_type("LOWER_BOUND", lower_bound.get(), false);
   check_numeric_type("UPPER_BOUND", upper_bound.get(), false);
 
   auto cast_to_double_if_necessary = [](std::shared_ptr<Analyzer::Expr> arg) {
     const auto& arg_ti = arg->get_type_info();
     if (arg_ti.get_type() != kDOUBLE) {
       const auto& double_ti = SQLTypeInfo(kDOUBLE, arg_ti.get_notnull());
       return arg->add_cast(double_ti);
     }
     return arg;
   };
   target_value = cast_to_double_if_necessary(target_value);
   lower_bound = cast_to_double_if_necessary(lower_bound);
   upper_bound = cast_to_double_if_necessary(upper_bound);
   return makeExpr<Analyzer::WidthBucketExpr>(
       target_value, lower_bound, upper_bound, partition_count);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > RelAlgTranslator::translateWindowFunction ( const RexWindowFunctionOperator * rex_window_function ) const

private

Definition at line 2101 of file RelAlgTranslator.cpp.

References anonymous_namespace{QueryMemoryDescriptor.cpp}::any_of(), run_benchmark_import::args, BACKWARD_FILL, CHECK, CHECK_GE, Analyzer::ColumnVar::collect_column_var(), Analyzer::ColumnVar::colvar_comp(), CONDITIONAL_CHANGE_EVENT, COUNT, CURRENT_ROW, EXPR_FOLLOWING, EXPR_PRECEDING, FIRST_VALUE_IN_FRAME, FORWARD_FILL, g_bigint_count, Analyzer::Expr::get_type_info(), RexWindowFunctionOperator::getCollation(), RexWindowFunctionOperator::getFrameEndBound(), RexWindowFunctionOperator::getFrameStartBound(), RexWindowFunctionOperator::getKind(), RexOperator::getOperand(), RexWindowFunctionOperator::getOrderKeys(), RexWindowFunctionOperator::getPartitionKeys(), RexOperator::getType(), logger::INFO, Datum::intval, SQLTypeInfo::is_timeinterval(), Analyzer::WindowFunction::isFramingAvailableWindowFunc(), RexWindowFunctionOperator::isRows(), kBIGINT, kDECIMAL, kDOUBLE, kENCODING_DICT, kINT, kMULTIPLY, kNUMERIC, kSMALLINT, kTINYINT, LAG_IN_FRAME, LAST_VALUE_IN_FRAME, LEAD_IN_FRAME, LOG, Analyzer::WindowFunction::NONE, NTH_VALUE, NTH_VALUE_IN_FRAME, Analyzer::WindowFunction::RANGE, Analyzer::WindowFunction::ROW, RexOperator::size(), toString(), anonymous_namespace{RelAlgTranslator.cpp}::translate_collation(), translateIntervalExprForWindowFraming(), translateScalarRex(), UNBOUNDED_FOLLOWING, UNBOUNDED_PRECEDING, UNKNOWN, VLOG, and window_function_is_value().

                                                                 {
   std::vector<std::shared_ptr<Analyzer::Expr>> args;
   for (size_t i = 0; i < rex_window_function->size(); ++i) {
     args.push_back(translateScalarRex(rex_window_function->getOperand(i)));
   }
   std::vector<std::shared_ptr<Analyzer::Expr>> partition_keys;
   for (const auto& partition_key : rex_window_function->getPartitionKeys()) {
     partition_keys.push_back(translateScalarRex(partition_key.get()));
   }
   std::vector<std::shared_ptr<Analyzer::Expr>> order_keys;
   for (const auto& order_key : rex_window_function->getOrderKeys()) {
     order_keys.push_back(translateScalarRex(order_key.get()));
   }
   std::vector<Analyzer::OrderEntry> collation =
       translate_collation(rex_window_function->getCollation());
 
   auto ti = rex_window_function->getType();
   auto window_func_kind = rex_window_function->getKind();
   if (window_function_is_value(window_func_kind)) {
     CHECK_GE(args.size(), 1u);
     ti = args.front()->get_type_info();
   }
   auto determine_frame_bound_type =
       [](const RexWindowFunctionOperator::RexWindowBound& bound) {
         if (bound.unbounded) {
           CHECK(!bound.bound_expr && !bound.is_current_row);
           if (bound.following) {
             return SqlWindowFrameBoundType::UNBOUNDED_FOLLOWING;
           } else if (bound.preceding) {
             return SqlWindowFrameBoundType::UNBOUNDED_PRECEDING;
           }
         } else {
           if (bound.is_current_row) {
             CHECK(!bound.unbounded && !bound.bound_expr);
             return SqlWindowFrameBoundType::CURRENT_ROW;
           } else {
             CHECK(!bound.unbounded && bound.bound_expr);
             if (bound.following) {
               return SqlWindowFrameBoundType::EXPR_FOLLOWING;
             } else if (bound.preceding) {
               return SqlWindowFrameBoundType::EXPR_PRECEDING;
             }
           }
         }
         return SqlWindowFrameBoundType::UNKNOWN;
       };
   auto is_negative_framing_bound =
       [](const SQLTypes t, const Datum& d, bool is_time_unit = false) {
         switch (t) {
           case kTINYINT:
             return d.tinyintval < 0;
           case kSMALLINT:
             return d.smallintval < 0;
           case kINT:
             return d.intval < 0;
           case kDOUBLE: {
             // the only case that double type is used is for handling time interval
             // i.e., represent tiny time units like nanosecond and microsecond as the
             // equivalent time value with SECOND time unit
             CHECK(is_time_unit);
             return d.doubleval < 0;
           }
           case kDECIMAL:
           case kNUMERIC:
           case kBIGINT:
             return d.bigintval < 0;
           default: {
             throw std::runtime_error(
                 "We currently only support integer-type literal expression as a window "
                 "frame bound expression");
           }
         }
       };
 
   bool negative_constant = false;
   bool detect_invalid_frame_start_bound_expr = false;
   bool detect_invalid_frame_end_bound_expr = false;
   auto& frame_start_bound = rex_window_function->getFrameStartBound();
   auto& frame_end_bound = rex_window_function->getFrameEndBound();
   bool has_end_bound_frame_expr = false;
   std::shared_ptr<Analyzer::Expr> frame_start_bound_expr;
   SqlWindowFrameBoundType frame_start_bound_type =
       determine_frame_bound_type(frame_start_bound);
   std::shared_ptr<Analyzer::Expr> frame_end_bound_expr;
   SqlWindowFrameBoundType frame_end_bound_type =
       determine_frame_bound_type(frame_end_bound);
   bool has_framing_clause =
       Analyzer::WindowFunction::isFramingAvailableWindowFunc(window_func_kind);
   auto frame_mode = rex_window_function->isRows()
                         ? Analyzer::WindowFunction::FrameBoundType::ROW
                         : Analyzer::WindowFunction::FrameBoundType::RANGE;
   if (order_keys.empty()) {
     if (frame_start_bound_type == SqlWindowFrameBoundType::UNBOUNDED_PRECEDING &&
         frame_end_bound_type == SqlWindowFrameBoundType::UNBOUNDED_FOLLOWING) {
       // Calcite sets UNBOUNDED PRECEDING ~ UNBOUNDED_FOLLOWING as its default frame bound
       // if the window context has no order by clause regardless of the existence of
       // user-given window frame bound but at this point we have no way to recognize the
       // absence of the frame definition of this window context
       has_framing_clause = false;
     }
   } else {
     auto translate_frame_bound_expr = [&](const RexScalar* bound_expr) {
       std::shared_ptr<Analyzer::Expr> translated_expr;
       const auto rex_oper = dynamic_cast<const RexOperator*>(bound_expr);
       if (rex_oper && rex_oper->getType().is_timeinterval()) {
         translated_expr = translateScalarRex(rex_oper);
         const auto bin_oper =
             dynamic_cast<const Analyzer::BinOper*>(translated_expr.get());
         auto time_literal_expr =
             dynamic_cast<const Analyzer::Constant*>(bin_oper->get_left_operand());
         CHECK(time_literal_expr);
         negative_constant =
             is_negative_framing_bound(time_literal_expr->get_type_info().get_type(),
                                       time_literal_expr->get_constval(),
                                       true);
         return std::make_pair(false, translated_expr);
       }
       if (dynamic_cast<const RexLiteral*>(bound_expr)) {
         translated_expr = translateScalarRex(bound_expr);
         if (auto literal_expr =
                 dynamic_cast<const Analyzer::Constant*>(translated_expr.get())) {
           negative_constant = is_negative_framing_bound(
               literal_expr->get_type_info().get_type(), literal_expr->get_constval());
           return std::make_pair(false, translated_expr);
         }
       }
       return std::make_pair(true, translated_expr);
     };
 
     if (frame_start_bound.bound_expr) {
       std::tie(detect_invalid_frame_start_bound_expr, frame_start_bound_expr) =
           translate_frame_bound_expr(frame_start_bound.bound_expr.get());
     }
 
     if (frame_end_bound.bound_expr) {
       std::tie(detect_invalid_frame_end_bound_expr, frame_end_bound_expr) =
           translate_frame_bound_expr(frame_end_bound.bound_expr.get());
     }
 
     // currently we only support literal expression as frame bound expression
     if (detect_invalid_frame_start_bound_expr || detect_invalid_frame_end_bound_expr) {
       throw std::runtime_error(
           "We currently only support literal expression as a window frame bound "
           "expression");
     }
 
     // note that Calcite already has frame-bound constraint checking logic, but we
     // also check various invalid cases for safety
     if (negative_constant) {
       throw std::runtime_error(
           "A constant expression for window framing should have nonnegative value.");
     }
 
     auto handle_time_interval_expr_if_necessary = [&](const Analyzer::Expr* bound_expr,
                                                       SqlWindowFrameBoundType bound_type,
                                                       bool for_start_bound) {
       if (bound_expr && bound_expr->get_type_info().is_timeinterval()) {
         const auto bound_bin_oper = dynamic_cast<const Analyzer::BinOper*>(bound_expr);
         CHECK(bound_bin_oper->get_optype() == kMULTIPLY);
         auto translated_expr = translateIntervalExprForWindowFraming(
             order_keys.front(),
             bound_type == SqlWindowFrameBoundType::EXPR_PRECEDING,
             bound_bin_oper);
         if (for_start_bound) {
           frame_start_bound_expr = translated_expr;
         } else {
           frame_end_bound_expr = translated_expr;
         }
       }
     };
     handle_time_interval_expr_if_necessary(
         frame_start_bound_expr.get(), frame_start_bound_type, true);
     handle_time_interval_expr_if_necessary(
         frame_end_bound_expr.get(), frame_end_bound_type, false);
   }
 
   if (frame_start_bound.following) {
     if (frame_end_bound.is_current_row) {
       throw std::runtime_error(
           "Window framing starting from following row cannot end with current row.");
     } else if (has_end_bound_frame_expr && frame_end_bound.preceding) {
       throw std::runtime_error(
           "Window framing starting from following row cannot have preceding rows.");
     }
   }
   if (frame_start_bound.is_current_row && frame_end_bound.preceding &&
       !frame_end_bound.unbounded && has_end_bound_frame_expr) {
     throw std::runtime_error(
         "Window framing starting from current row cannot have preceding rows.");
   }
   if (has_framing_clause) {
     if (frame_mode == Analyzer::WindowFunction::FrameBoundType::RANGE) {
       if (order_keys.size() != 1) {
         throw std::runtime_error(
             "Window framing with range mode requires a single order-by column");
       }
       if (!frame_start_bound_expr &&
           frame_start_bound_type == SqlWindowFrameBoundType::UNBOUNDED_PRECEDING &&
           !frame_end_bound_expr &&
           frame_end_bound_type == SqlWindowFrameBoundType::CURRENT_ROW) {
         has_framing_clause = false;
         VLOG(1) << "Ignore range framing mode with a frame bound between "
                    "UNBOUNDED_PRECEDING and CURRENT_ROW";
       }
       std::set<const Analyzer::ColumnVar*,
                bool (*)(const Analyzer::ColumnVar*, const Analyzer::ColumnVar*)>
           colvar_set(Analyzer::ColumnVar::colvar_comp);
       order_keys.front()->collect_column_var(colvar_set, false);
       for (auto cv : colvar_set) {
         if (!(cv->get_type_info().is_integer() || cv->get_type_info().is_fp() ||
               cv->get_type_info().is_time())) {
           has_framing_clause = false;
           VLOG(1) << "Range framing mode with non-number type ordering column is not "
                      "supported yet, skip window framing";
         }
       }
     }
   }
   auto const func_name = ::toString(window_func_kind);
   auto const num_args = args.size();
   bool need_order_by_clause = false;
   bool need_frame_def = false;
   switch (window_func_kind) {
     case SqlWindowFunctionKind::LEAD_IN_FRAME:
     case SqlWindowFunctionKind::LAG_IN_FRAME: {
       need_order_by_clause = true;
       need_frame_def = true;
       if (num_args != 2) {
         throw std::runtime_error(func_name + " has an invalid number of input arguments");
       }
       Datum d;
       d.intval = 1;
       args.push_back(makeExpr<Analyzer::Constant>(kINT, false, d));
       const auto target_expr_cv =
           dynamic_cast<const Analyzer::ColumnVar*>(args.front().get());
       if (!target_expr_cv) {
         throw std::runtime_error("Currently, " + func_name +
                                  " only allows a column reference as its first argument");
       }
       const auto target_ti = target_expr_cv->get_type_info();
       if (target_ti.is_dict_encoded_string()) {
         // Calcite does not represent a window function having dictionary encoded text
         // type as its output properly, so we need to set its output type manually
         ti.set_compression(kENCODING_DICT);
         ti.set_comp_param(target_expr_cv->get_type_info().get_comp_param());
         ti.setStringDictKey(target_expr_cv->get_type_info().getStringDictKey());
         ti.set_fixed_size();
       }
       const auto target_offset_cv =
           dynamic_cast<const Analyzer::Constant*>(args[1].get());
       if (!target_expr_cv ||
           is_negative_framing_bound(target_offset_cv->get_type_info().get_type(),
                                     target_offset_cv->get_constval())) {
         throw std::runtime_error(
             "Currently, " + func_name +
             " only allows non-negative constant as its second argument");
       }
       break;
     }
     case SqlWindowFunctionKind::FIRST_VALUE_IN_FRAME:
     case SqlWindowFunctionKind::LAST_VALUE_IN_FRAME:
       if (num_args != 1) {
         throw std::runtime_error(func_name + " has an invalid number of input arguments");
       }
       need_order_by_clause = true;
       need_frame_def = true;
       break;
     case SqlWindowFunctionKind::FORWARD_FILL:
     case SqlWindowFunctionKind::BACKWARD_FILL: {
       if (has_framing_clause) {
         throw std::runtime_error(func_name + " does not support window framing clause");
       }
       auto const input_expr_ti = args.front()->get_type_info();
       if (input_expr_ti.is_string()) {
         throw std::runtime_error(func_name + " not supported on " +
                                  input_expr_ti.get_type_name() + " type yet");
       }
       need_order_by_clause = true;
       std::string const arg_str{args.front()->toString()};
       bool needs_inject_input_arg_ordering =
           !std::any_of(order_keys.cbegin(),
                        order_keys.cend(),
                        [&arg_str](std::shared_ptr<Analyzer::Expr> const& expr) {
                          return boost::equals(arg_str, expr->toString());
                        });
       if (needs_inject_input_arg_ordering) {
         VLOG(1) << "Inject " << args.front()->toString() << " as ordering column of the "
                 << func_name << " function";
         order_keys.push_back(args.front());
         // forward_fill can fill null values if it is ordered with NULLS LAST
         // in contrast, we make NULLS FIRST ordering for the backward_fill function
         collation.emplace_back(collation.size() + 1,
                                false,
                                window_func_kind != SqlWindowFunctionKind::FORWARD_FILL);
       }
       break;
     }
     case SqlWindowFunctionKind::NTH_VALUE:
     case SqlWindowFunctionKind::NTH_VALUE_IN_FRAME: {
       // todo (yoonmin) : args.size() will be three if we support default value
       if (num_args != 2) {
         throw std::runtime_error(func_name + " has an invalid number of input arguments");
       }
       // NTH_VALUE(_IN_FRAME) may return null value even if the argument is non-null
       // column
       ti.set_notnull(false);
       if (window_func_kind == SqlWindowFunctionKind::NTH_VALUE_IN_FRAME) {
         need_order_by_clause = true;
         need_frame_def = true;
       }
       if (!args[1]) {
         throw std::runtime_error(func_name +
                                  " must have a positional argument expression.");
       }
       bool has_valid_arg = false;
       if (args[1]->get_type_info().is_integer()) {
         if (auto* n_value_ptr = dynamic_cast<Analyzer::Constant*>(args[1].get())) {
           if (0 < n_value_ptr->get_constval().intval) {
             // i.e., having N larger than the partition size
             // set the proper N to match the zero-start index pos
             auto d = n_value_ptr->get_constval();
             d.intval -= 1;
             n_value_ptr->set_constval(d);
             has_valid_arg = true;
           }
         }
       }
       if (!has_valid_arg) {
         throw std::runtime_error("The positional argument of the " + func_name +
                                  " must be a positive integer constant.");
       }
       break;
     }
     case SqlWindowFunctionKind::CONDITIONAL_CHANGE_EVENT:
       if (order_keys.empty()) {
         throw std::runtime_error(
             ::toString(window_func_kind) +
             " requires an ORDER BY sub-clause within the window clause");
       }
       if (has_framing_clause) {
         LOG(INFO)
             << ::toString(window_func_kind)
             << " must use a pre-defined window frame range (e.g., ROWS BETWEEN "
                "UNBOUNDED PRECEDING AND CURRENT ROW). "
                "Thus, we skip the user-defined window frame for this window function";
       }
       has_framing_clause = true;
       frame_mode = Analyzer::WindowFunction::FrameBoundType::ROW;
       frame_start_bound_type = SqlWindowFrameBoundType::UNBOUNDED_PRECEDING;
       frame_end_bound_type = SqlWindowFrameBoundType::CURRENT_ROW;
       break;
     default:;
   }
   if (need_order_by_clause && order_keys.empty()) {
     throw std::runtime_error(func_name + " requires an ORDER BY clause");
   }
   if (need_frame_def && !has_framing_clause) {
     throw std::runtime_error(func_name + " requires window frame definition");
   }
   if (!has_framing_clause) {
     frame_start_bound_type = SqlWindowFrameBoundType::UNKNOWN;
     frame_end_bound_type = SqlWindowFrameBoundType::UNKNOWN;
     frame_start_bound_expr = nullptr;
     frame_end_bound_expr = nullptr;
   }
   if (window_func_kind == SqlWindowFunctionKind::COUNT && has_framing_clause &&
       args.empty()) {
     args.push_back(makeExpr<Analyzer::Constant>(g_bigint_count ? kBIGINT : kINT, true));
   }
   return makeExpr<Analyzer::WindowFunction>(
       ti,
       rex_window_function->getKind(),
       args,
       partition_keys,
       order_keys,
       has_framing_clause ? frame_mode : Analyzer::WindowFunction::FrameBoundType::NONE,
       makeExpr<Analyzer::WindowFrame>(frame_start_bound_type, frame_start_bound_expr),
       makeExpr<Analyzer::WindowFrame>(frame_end_bound_type, frame_end_bound_expr),
       collation);
 }

Here is the call graph for this function:

Member Data Documentation

robin_hood::unordered_map<RexScalar const*, std::shared_ptr<Analyzer::Expr> > RelAlgTranslator::cache_

mutableprivate

Definition at line 245 of file RelAlgTranslator.h.

Referenced by translate(), and translateScalarRex().

const Executor* RelAlgTranslator::executor_

private

Definition at line 236 of file RelAlgTranslator.h.

Referenced by getInIntegerSetExpr(), translateCase(), and translateOper().

bool RelAlgTranslator::generated_geos_ops_

mutableprivate

Definition at line 240 of file RelAlgTranslator.h.

Referenced by generated_geos_ops().

const std::unordered_map<const RelAlgNode*, int> RelAlgTranslator::input_to_nest_level_

private

Definition at line 237 of file RelAlgTranslator.h.

Referenced by translateGeoColumn(), and translateInput().

const std::vector<JoinType> RelAlgTranslator::join_types_

private

Definition at line 238 of file RelAlgTranslator.h.

Referenced by translateInput().

const bool RelAlgTranslator::just_explain_

private

Definition at line 241 of file RelAlgTranslator.h.

Referenced by translateInOper(), and translateScalarSubquery().

time_t RelAlgTranslator::now_

private

Definition at line 239 of file RelAlgTranslator.h.

Referenced by translateCurrentDate(), translateCurrentTime(), and translateCurrentTimestamp().

std::shared_ptr<const query_state::QueryState> RelAlgTranslator::query_state_

private

Definition at line 235 of file RelAlgTranslator.h.

Referenced by translateCurrentUser().

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

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/RelAlgTranslator.h
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/RelAlgTranslator.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/RelAlgTranslatorGeo.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation