#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 >	translateOverlapsOper (const RexOperator *) const

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

std::shared_ptr< Analyzer::Expr >	translateWidthBucket (const RexFunctionOperator *) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::shared_ptr< Analyzer::Expr >	translateCardinality (const RexFunctionOperator *) const

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

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

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

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

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

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

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

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

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

std::shared_ptr< Analyzer::Expr >	translateArrayFunction (const RexFunctionOperator *) const

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

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

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 >	translateGeoOverlapsOper (const RexOperator *) const

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

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

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

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

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

private

Definition at line 900 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,
           [this,
            &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 1552 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 277 of file RelAlgTranslator.cpp.

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

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

                                                                   {
   SQLAgg agg_kind = rex->getKind();
   const bool is_distinct = rex->isDistinct();
   const bool takes_arg{rex->size() > 0};
   std::shared_ptr<Analyzer::Expr> arg_expr;
   std::shared_ptr<Analyzer::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 should be 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 (rex->isDistinct()) {
           throw std::runtime_error(
               "Currently, COUNT_IF function does not support DISTINCT qualifier.");
         }
         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.");
     }
   }
   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 1594 of file RelAlgTranslator.cpp.

References CHECK, get_nullable_logical_type_info(), SQLTypeInfo::get_subtype(), RexOperator::getType(), kARRAY, kBOOLEAN, kENCODING_DICT, kNULLT, kTEXT, to_string(), TRANSIENT_DICT_DB_ID, 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({TRANSIENT_DICT_DB_ID, TRANSIENT_DICT_ID});
         } 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 963 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,
                                        false,
                                        true,
                                        true,
                                        false,
                                        false,
                                        /* allow_gdal_transforms = */ true);
   }
   if (func_resolve(rex_function->getName(),
                    "ST_Intersection"sv,
                    "ST_Difference"sv,
                    "ST_Union"sv)) {
     // Second arg: geometry
     geoargs1 = translateGeoFunctionArg(rex_function->getOperand(1),
                                        arg1_ti,
                                        false,
                                        false,
                                        true,
                                        true,
                                        false,
                                        false,
                                        /* allow_gdal_transforms = */ true);
     if (arg0_ti.get_output_srid() != arg1_ti.get_output_srid()) {
       throw QueryNotSupported(rex_function->getName() +
                               " geo constructor requires arguments with matching srids");
     }
   } else if (func_resolve(rex_function->getName(), "ST_Buffer"sv, "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 1462 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_Overlaps"sv) {
     // Overlaps join is the only implementation supported for now, only translate bounds
     CHECK_EQ(size_t(2), rex_function->size());
     auto extract_geo_bounds_from_input =
         [this, &rex_function](const size_t index) -> std::shared_ptr<Analyzer::Expr> {
       const auto rex_input =
           dynamic_cast<const RexInput*>(rex_function->getOperand(index));
       if (rex_input) {
         SQLTypeInfo ti;
         const auto exprs = translateGeoColumn(rex_input, ti, true, false, false);
         CHECK_GT(exprs.size(), size_t(0));
         if (ti.get_type() == kPOINT) {
           throw std::runtime_error("ST_Overlaps is not supported for point arguments.");
         } else {
           return exprs.back();
         }
       } else {
         throw std::runtime_error(
             "Only inputs are supported as arguments to ST_Overlaps for now.");
       }
     };
     std::vector<std::shared_ptr<Analyzer::Expr>> geo_args;
     geo_args.push_back(extract_geo_bounds_from_input(0));
     geo_args.push_back(extract_geo_bounds_from_input(1));
 
     return makeExpr<Analyzer::FunctionOper>(return_type, function_name, geo_args);
   }
 
   if (function_name == "ST_Distance"sv || function_name == "ST_MaxDistance"sv) {
     CHECK_EQ(size_t(2), rex_function->size());
     std::vector<std::shared_ptr<Analyzer::Expr>> args;
     int legacy_transform_srid = 0;
     for (size_t i = 0; i < rex_function->size(); i++) {
       SQLTypeInfo arg0_ti;  // discard
       auto geoargs = translateGeoFunctionArg(rex_function->getOperand(i),
                                              arg0_ti,
                                              /*with_bounds=*/false,  // TODO
                                              /*with_render_group=*/false,
                                              /*expand_geo_col=*/false,
                                              /*is_projection = */ false,
                                              /*use_geo_expressions=*/true);
       if (arg0_ti.get_input_srid() != arg0_ti.get_output_srid() &&
           arg0_ti.get_output_srid() > 0 &&
           std::dynamic_pointer_cast<Analyzer::ColumnVar>(geoargs.front())) {
         // legacy transform
         CHECK(legacy_transform_srid == 0 ||
               legacy_transform_srid == arg0_ti.get_output_srid());
         legacy_transform_srid = arg0_ti.get_output_srid();
       }
       args.insert(args.end(), geoargs.begin(), geoargs.end());
     }
     return makeExpr<Analyzer::GeoOperator>(
         SQLTypeInfo(kDOUBLE, /*not_null=*/false),
         function_name,
         args,
         legacy_transform_srid > 0 ? std::make_optional<int>(legacy_transform_srid)
                                   : std::nullopt);
   }
 
   bool swap_args = false;
   bool with_bounds = false;
   bool negate_result = false;
   Analyzer::ExpressionPtr threshold_expr = nullptr;
   Analyzer::ExpressionPtr compare_expr = nullptr;
   if (function_name == "ST_DWithin"sv) {
     CHECK_EQ(size_t(3), rex_function->size());
     function_name = "ST_Distance";
     return_type = SQLTypeInfo(kDOUBLE, false);
     // Inject ST_DWithin's short-circuiting threshold into ST_MaxDistance
     threshold_expr = translateScalarRex(rex_function->getOperand(2));
   } else if (function_name == "ST_Equals"sv) {
     // Translate ST_Equals(g1,g2) to ST_Distance(g1,g2)<=0.0
     CHECK_EQ(size_t(2), rex_function->size());
     function_name = "ST_Distance";
     return_type = SQLTypeInfo(kDOUBLE, false);
     threshold_expr = nullptr;
     Datum d;
     d.doubleval = 0.0;
     compare_expr = makeExpr<Analyzer::Constant>(kDOUBLE, false, d);
   } else if (function_name == "ST_DFullyWithin"sv) {
     CHECK_EQ(size_t(3), rex_function->size());
     function_name = "ST_MaxDistance";
     return_type = SQLTypeInfo(kDOUBLE, false);
     // TODO: inject ST_DFullyWithin's short-circuiting threshold into ST_MaxDistance
     threshold_expr = nullptr;
   } else if (function_name == "ST_Distance"sv) {
     // TODO: pick up an outside short-circuiting threshold and inject into ST_Distance
     threshold_expr = nullptr;
   } else if (function_name == "ST_MaxDistance"sv) {
     // TODO: pick up an outside short-circuiting threshold and inject into
     // ST_MaxDistance
     threshold_expr = nullptr;
   } else {
     CHECK_EQ(size_t(2), rex_function->size());
   }
   if (function_name == "ST_Within"sv) {
     function_name = "ST_Contains";
     swap_args = true;
   } else if (function_name == "ST_Disjoint"sv) {
     function_name = "ST_Intersects";
     negate_result = true;
   }
   if (func_resolve(
           function_name, "ST_Contains"sv, "ST_Intersects"sv, "ST_Approx_Overlaps"sv)) {
     with_bounds = true;
   }
 
   std::vector<std::shared_ptr<Analyzer::Expr>> geoargs;
   SQLTypeInfo arg0_ti;
   SQLTypeInfo arg1_ti;
 
   // Proactively try to compress the first arg of ST_Intersects to preempt arg swap
   bool try_to_compress_arg0 = g_enable_geo_ops_on_uncompressed_coords &&
                               func_resolve(function_name, "ST_Intersects"sv);
 
   auto geoargs0 = translateGeoFunctionArg(rex_function->getOperand(swap_args ? 1 : 0),
                                           arg0_ti,
                                           with_bounds,
                                           false,
                                           false,
                                           false,
                                           false,
                                           try_to_compress_arg0);
   geoargs.insert(geoargs.end(), geoargs0.begin(), geoargs0.end());
 
   // If first arg is compressed, try to compress the second one to be able to
   // switch to faster implementations working directly on uncompressed coords
   bool try_to_compress_arg1 =
       (g_enable_geo_ops_on_uncompressed_coords &&
        func_resolve(function_name, "ST_Contains"sv, "ST_Intersects"sv) &&
        arg0_ti.get_compression() == kENCODING_GEOINT &&
        arg0_ti.get_output_srid() == 4326);
 
   auto geoargs1 = translateGeoFunctionArg(rex_function->getOperand(swap_args ? 0 : 1),
                                           arg1_ti,
                                           with_bounds,
                                           false,
                                           false,
                                           false,
                                           false,
                                           try_to_compress_arg1);
   geoargs.insert(geoargs.end(), geoargs1.begin(), geoargs1.end());
 
   if (arg0_ti.get_subtype() != kNULLT && arg0_ti.get_subtype() != arg1_ti.get_subtype()) {
     throw QueryNotSupported(rex_function->getName() +
                             " accepts either two GEOGRAPHY or two GEOMETRY arguments");
   }
   // Check SRID match if at least one is set/valid
   if ((arg0_ti.get_output_srid() > 0 || arg1_ti.get_output_srid() > 0) &&
       arg0_ti.get_output_srid() != arg1_ti.get_output_srid()) {
     throw QueryNotSupported(rex_function->getName() + " cannot accept different SRIDs");
   }
   if (compare_expr) {
     // We could fold the check to false here if argument geo types are different, e.g.
     // POLYGON vs POINT. However, tiny POLYGON could be "spatially" equal to a POINT.
     if (arg0_ti.get_type() != kPOINT || arg1_ti.get_type() != kPOINT) {
       // ST_Equals is translated to a simple distance check for POINTs,
       // otherwise geometries are passed to GEOS's Equals
       return nullptr;
     }
     // Look at POINT compression modes.
     if (arg0_ti.get_compression() != arg1_ti.get_compression()) {
       if ((arg0_ti.get_compression() == kENCODING_GEOINT &&
            arg0_ti.get_comp_param() == 32 &&
            arg1_ti.get_compression() == kENCODING_NONE) ||
           (arg0_ti.get_compression() == kENCODING_NONE &&
            arg1_ti.get_compression() == kENCODING_GEOINT &&
            arg0_ti.get_comp_param() == 32)) {
         // Spatial equality comparison of a compressed point vs uncompressed point.
         // Introduce tolerance into distance calculation and comparison, translate
         // ST_Equals(g1,g2) to ST_Distance(g1,g2,thereshold=tolerance)<=tolerance
         Datum tolerance;
         // Tolerance representing 0.44" to cover shifts due to GEOINT(32) compression
         tolerance.doubleval = TOLERANCE_GEOINT32;
         threshold_expr = makeExpr<Analyzer::Constant>(kDOUBLE, false, tolerance);
         compare_expr = threshold_expr;
       } else {
         throw QueryNotSupported(
             rex_function->getName() +
             " unable to calculate compression tolerance for arguments");
       }
     }
   }
   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 1076 of file RelAlgTranslatorGeo.cpp.

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

Referenced by translateFunction(), and translateGeoFunctionArg().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

Definition at line 1482 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 1061 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 1518 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 1525 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 1532 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 1412 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 1235 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 1350 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 1362 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 1268 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 1536 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 1176 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 1666 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(), translateOffsetInFragment(), 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 (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)) {
     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,
                    "HeavyDB_Geo_PolyRenderGroup"sv,
                    "HeavyDB_Geo_PolyCoordsArray"sv,
                    "HeavyDB_Geo_PolyRingSizesArray"sv,
                    "HeavyDB_Geo_PolyPolyRingsArray"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_Overlaps"sv,
                    "ST_Approx_Overlaps"sv,
                    "ST_Within"sv)) {
     CHECK_EQ(rex_function->size(), size_t(2));
     return translateBinaryGeoFunction(rex_function);
   }
   if (func_resolve(rex_function->getName(), "ST_DWithin"sv, "ST_DFullyWithin"sv)) {
     CHECK_EQ(rex_function->size(), size_t(3));
     return translateTernaryGeoFunction(rex_function);
   }
   if (rex_function->getName() == "OFFSET_IN_FRAGMENT"sv) {
     CHECK_EQ(size_t(0), rex_function->size());
     return translateOffsetInFragment();
   }
   if (rex_function->getName() == "ARRAY"sv) {
     // Var args; currently no check.  Possible fix-me -- can array have 0 elements?
     return translateArrayFunction(rex_function);
   }
   if (func_resolve(rex_function->getName(),
                    "ST_GeomFromText"sv,
                    "ST_GeogFromText"sv,
                    "ST_Centroid"sv,
                    "ST_SetSRID"sv,
                    "ST_Point"sv,  // TODO: where should this and below live?
                    "ST_PointN"sv,
                    "ST_StartPoint"sv,
                    "ST_EndPoint"sv,
                    "ST_Transform"sv)) {
     SQLTypeInfo ti;
     return translateGeoProjection(rex_function, ti, false);
   }
   if (func_resolve(rex_function->getName(),
                    "ST_Intersection"sv,
                    "ST_Difference"sv,
                    "ST_Union"sv,
                    "ST_Buffer"sv,
                    "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 2628 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 1903 of file RelAlgTranslatorGeo.cpp.

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

Referenced by translateFunction().

                                                    {
   std::string specialized_geofunc{rex_function->getName()};
   if (func_resolve(rex_function->getName(),
                    "convert_meters_to_pixel_width"sv,
                    "convert_meters_to_pixel_height"sv)) {
     CHECK_EQ(rex_function->size(), 6u);
     SQLTypeInfo arg_ti;
     std::vector<std::shared_ptr<Analyzer::Expr>> args;
     args.push_back(translateScalarRex(rex_function->getOperand(0)));
     auto geoargs =
         translateGeoFunctionArg(rex_function->getOperand(1), arg_ti, false, true, false);
     // only works on points
     if (arg_ti.get_type() != kPOINT) {
       throw QueryNotSupported(rex_function->getName() +
                               " expects a point for the second argument");
     }
 
     args.insert(args.end(), geoargs.begin(), geoargs.begin() + 1);
 
     // Add compression information
     Datum input_compression;
     input_compression.intval = Geospatial::get_compression_scheme(arg_ti);
     args.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression));
     if (arg_ti.get_input_srid() != 4326) {
       throw QueryNotSupported(
           rex_function->getName() +
           " currently only supports points of with SRID WGS84/EPSG:4326");
     }
     Datum input_srid;
     input_srid.intval = arg_ti.get_input_srid();
     args.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_srid));
     Datum output_srid;
     // Forcing web-mercator projection for now
     // TODO(croot): check that the input-to-output conversion routines exist?
     output_srid.intval =
         arg_ti.get_output_srid() != 900913 ? 900913 : arg_ti.get_output_srid();
     args.push_back(makeExpr<Analyzer::Constant>(kINT, false, output_srid));
 
     args.push_back(translateScalarRex(rex_function->getOperand(2)));
     args.push_back(translateScalarRex(rex_function->getOperand(3)));
     args.push_back(translateScalarRex(rex_function->getOperand(4)));
     args.push_back(translateScalarRex(rex_function->getOperand(5)));
     return makeExpr<Analyzer::FunctionOper>(
         rex_function->getType(), specialized_geofunc, args);
   } else if (rex_function->getName() == "is_point_in_view"sv) {
     CHECK_EQ(rex_function->size(), 5u);
     SQLTypeInfo arg_ti;
     std::vector<std::shared_ptr<Analyzer::Expr>> args;
     auto geoargs =
         translateGeoFunctionArg(rex_function->getOperand(0), arg_ti, false, true, false);
     // only works on points
     if (arg_ti.get_type() != kPOINT) {
       throw QueryNotSupported(rex_function->getName() +
                               " expects a point for the second argument");
     }
 
     args.insert(args.end(), geoargs.begin(), geoargs.begin() + 1);
 
     // Add compression information
     Datum input_compression;
     input_compression.intval = Geospatial::get_compression_scheme(arg_ti);
     args.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression));
     if (arg_ti.get_input_srid() != 4326) {
       throw QueryNotSupported(
           rex_function->getName() +
           " currently only supports points of with SRID WGS84/EPSG:4326");
     }
     args.push_back(translateScalarRex(rex_function->getOperand(1)));
     args.push_back(translateScalarRex(rex_function->getOperand(2)));
     args.push_back(translateScalarRex(rex_function->getOperand(3)));
     args.push_back(translateScalarRex(rex_function->getOperand(4)));
     return makeExpr<Analyzer::FunctionOper>(
         rex_function->getType(), specialized_geofunc, args);
   } else if (rex_function->getName() == "is_point_size_in_view"sv) {
     CHECK_EQ(rex_function->size(), 6u);
     SQLTypeInfo arg_ti;
     std::vector<std::shared_ptr<Analyzer::Expr>> args;
     auto geoargs =
         translateGeoFunctionArg(rex_function->getOperand(0), arg_ti, false, true, false);
     // only works on points
     if (arg_ti.get_type() != kPOINT) {
       throw QueryNotSupported(rex_function->getName() +
                               " expects a point for the second argument");
     }
 
     args.insert(args.end(), geoargs.begin(), geoargs.begin() + 1);
 
     // Add compression information
     Datum input_compression;
     input_compression.intval = Geospatial::get_compression_scheme(arg_ti);
     args.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression));
     if (arg_ti.get_input_srid() != 4326) {
       throw QueryNotSupported(
           rex_function->getName() +
           " currently only supports points of with SRID WGS84/EPSG:4326");
     }
     args.push_back(translateScalarRex(rex_function->getOperand(1)));
     args.push_back(translateScalarRex(rex_function->getOperand(2)));
     args.push_back(translateScalarRex(rex_function->getOperand(3)));
     args.push_back(translateScalarRex(rex_function->getOperand(4)));
     args.push_back(translateScalarRex(rex_function->getOperand(5)));
     return makeExpr<Analyzer::FunctionOper>(
         rex_function->getType(), specialized_geofunc, args);
   }
   CHECK(false);
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

Definition at line 28 of file RelAlgTranslatorGeo.cpp.

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

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

                                      {
   std::vector<std::shared_ptr<Analyzer::Expr>> args;
   const auto source = rex_input->getSourceNode();
   const auto it_rte_idx = input_to_nest_level_.find(source);
   CHECK(it_rte_idx != input_to_nest_level_.end());
   const int rte_idx = it_rte_idx->second;
   const auto& in_metainfo = source->getOutputMetainfo();
 
   int32_t 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 || with_render_group) {
       throw QueryNotSupported(
           "Geospatial columns not yet supported in intermediate results.");
     }
 
     CHECK(!in_metainfo.empty());
     CHECK_GE(rte_idx, 0);
     column_id = rex_input->getIndex();
     CHECK_LT(static_cast<size_t>(column_id), in_metainfo.size());
     ti = in_metainfo[column_id].get_type_info();
     if (expand_geo_col && ti.is_geometry()) {
       throw QueryNotSupported(
           "Geospatial columns not yet supported in this temporary table context.");
     }
   }
 
   if (!IS_GEO(ti.get_type())) {
     throw QueryNotSupported(
         "Geospatial expression and operator require geospatial column as their input "
         "argument(s)");
   }
 
   // Return geo column reference. The geo column may be expanded if required for extension
   // function arguments. Otherwise, the geo column reference will be translated into
   // physical columns as required. Bounds column will be added if present and requested.
   if (expand_geo_col) {
     for (auto i = 0; i < ti.get_physical_coord_cols(); i++) {
       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));
   }
   if (with_render_group && ti.has_render_group()) {
     CHECK(catalog);
     const auto render_group_cd = catalog->getMetadataForColumnBySpi(
         table_id,
         SPIMAP_GEO_PHYSICAL_INPUT(rex_input->getIndex(),
                                   ti.get_physical_coord_cols() + 2));
     auto render_group_ti = render_group_cd->columnType;
     args.push_back(std::make_shared<Analyzer::ColumnVar>(
         render_group_ti,
         shared::ColumnKey{db_id, table_id, render_group_cd->columnId},
         rte_idx));
   }
   return args;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

Definition at line 1882 of file RelAlgTranslatorGeo.cpp.

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

Referenced by translateOper().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

Definition at line 280 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, with_render_group)};
     }
     return translateGeoColumn(
         rex_input, arg_ti, with_bounds, with_render_group, expand_geo_col);
   }
   const auto rex_function = dynamic_cast<const RexFunctionOperator*>(rex_scalar);
   if (rex_function) {
     if (rex_function->getName() == "ST_Transform"sv) {
       CHECK_EQ(size_t(2), rex_function->size());
       const auto rex_scalar0 =
           dynamic_cast<const RexScalar*>(rex_function->getOperand(0));
       if (!rex_scalar0) {
         throw QueryNotSupported(rex_function->getName() + ": unexpected first argument");
       }
 
       const auto rex_literal =
           dynamic_cast<const RexLiteral*>(rex_function->getOperand(1));
       if (!rex_literal) {
         throw QueryNotSupported(rex_function->getName() +
                                 ": second argument is expected to be a literal");
       }
       const auto e = translateLiteral(rex_literal);
       auto ce = std::dynamic_pointer_cast<Analyzer::Constant>(e);
       if (!ce || !e->get_type_info().is_integer()) {
         throw QueryNotSupported(rex_function->getName() + ": expecting integer SRID");
       }
       int32_t srid = 0;
       if (e->get_type_info().get_type() == kSMALLINT) {
         srid = static_cast<int32_t>(ce->get_constval().smallintval);
       } else if (e->get_type_info().get_type() == kTINYINT) {
         srid = static_cast<int32_t>(ce->get_constval().tinyintval);
       } else if (e->get_type_info().get_type() == kINT) {
         srid = static_cast<int32_t>(ce->get_constval().intval);
       } else {
         throw QueryNotSupported(rex_function->getName() + ": expecting integer SRID");
       }
       bool allow_result_gdal_transform = false;
       const auto rex_function0 = dynamic_cast<const RexFunctionOperator*>(rex_scalar0);
       if (rex_function0 && func_resolve(rex_function0->getName(),
                                         "ST_Intersection"sv,
                                         "ST_Difference"sv,
                                         "ST_Union"sv,
                                         "ST_Buffer"sv,
                                         "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,
                                           with_render_group,
                                           expand_geo_col,
                                           is_projection,
                                           arg0_use_geo_expressions);
 
       if (use_geo_expressions) {
         CHECK_EQ(arg0.size(), size_t(1));
         auto arg0_ti = arg0.front()->get_type_info();  // make a copy so we can override
         arg0_ti.set_output_srid(srid);
         if (arg0_ti.get_type() == kPOINT) {
           // the output type is going to be fully transformed, so set the input srid to
           // the output srid
           const auto input_srid = arg0_ti.get_input_srid();
           arg0_ti.set_input_srid(srid);
           // geo transforms projections leave the result decompressed in a register
           arg0_ti.set_compression(kENCODING_NONE);
           arg0_ti.set_comp_param(0);
           // reset recursive arg_ti, as the output type of transform will be properly
           // transformed to the desired SRID
           arg_ti.set_output_srid(srid);
           arg_ti.set_input_srid(srid);
           return {makeExpr<Analyzer::GeoTransformOperator>(
               arg0_ti, rex_function->getName(), arg0, input_srid, srid)};
         } else {
           if (auto geo_constant =
                   std::dynamic_pointer_cast<Analyzer::GeoConstant>(arg0.front())) {
             // fold transform
             auto cast_geo_constant = geo_constant->add_cast(arg0_ti);
             // update return type info
             arg_ti = cast_geo_constant->get_type_info();
             return {cast_geo_constant};
           } else if (auto col_var =
                          std::dynamic_pointer_cast<Analyzer::ColumnVar>(arg0.front())) {
             const auto& col_ti = col_var->get_type_info();
             CHECK(col_ti.is_geometry());
             if (col_ti.get_type() != kPOINT) {
               arg_ti.set_input_srid(col_ti.get_input_srid());
               // fall through to transform code below
             }
           } else {
             if (!allow_gdal_transforms && !allow_result_gdal_transform) {
               throw std::runtime_error(
                   "Transform on non-POINT geospatial types not yet supported in this "
                   "context.");
             }
           }
         }
       }
 
       if (arg_ti.get_input_srid() > 0) {
         if (!allow_gdal_transforms && !allow_result_gdal_transform) {
           if (arg_ti.get_input_srid() != 4326) {
             throw QueryNotSupported(rex_function->getName() +
                                     ": unsupported input SRID " +
                                     std::to_string(arg_ti.get_input_srid()));
           }
         }
         // Established that the input SRID is valid
         if (allow_result_gdal_transform) {
           // If gdal transform has been allowed, then it has been sunk into geos runtime.
           // The returning geometry has already been transformed, de-register transform.
           if (arg_ti.get_input_srid() != srid) {
             arg_ti.set_input_srid(srid);
           }
         }
         arg_ti.set_output_srid(srid);
       } else {
         throw QueryNotSupported(rex_function->getName() +
                                 ": unexpected input SRID, unable to transform");
       }
       return arg0;
     } else if (func_resolve(
                    rex_function->getName(), "ST_GeomFromText"sv, "ST_GeogFromText"sv)) {
       CHECK(rex_function->size() == size_t(1) || rex_function->size() == size_t(2));
       if (use_geo_expressions) {
         int32_t srid = 0;
         if (rex_function->size() == 2) {
           // user supplied srid
           const auto rex_literal =
               dynamic_cast<const RexLiteral*>(rex_function->getOperand(1));
           if (!rex_literal) {
             throw QueryNotSupported(rex_function->getName() +
                                     ": second argument is expected to be a literal");
           }
           const auto e = translateLiteral(rex_literal);
           auto ce = std::dynamic_pointer_cast<Analyzer::Constant>(e);
           if (!ce || !e->get_type_info().is_integer()) {
             throw QueryNotSupported(rex_function->getName() + ": expecting integer SRID");
           }
           if (e->get_type_info().get_type() == kSMALLINT) {
             srid = static_cast<int32_t>(ce->get_constval().smallintval);
           } else if (e->get_type_info().get_type() == kTINYINT) {
             srid = static_cast<int32_t>(ce->get_constval().tinyintval);
           } else if (e->get_type_info().get_type() == kINT) {
             srid = static_cast<int32_t>(ce->get_constval().intval);
           } else {
             throw QueryNotSupported(rex_function->getName() + " expecting integer SRID");
           }
           if (srid != 0 && srid != 4326 && srid != 900913) {
             throw QueryNotSupported(rex_function->getName() + ": unsupported SRID " +
                                     std::to_string(srid));
           }
         }
         arg_ti.set_input_srid(srid);  // Input SRID
         // leave the output srid unset in case a transform was above us
 
         if (rex_function->getName() == "ST_GeogFromText"sv) {
           arg_ti.set_subtype(kGEOGRAPHY);
         } else {
           arg_ti.set_subtype(kGEOMETRY);
         }
 
         auto func_args = translateGeoFunctionArg(rex_function->getOperand(0),
                                                  arg_ti,
                                                  with_bounds,
                                                  with_render_group,
                                                  expand_geo_col,
                                                  is_projection,
                                                  use_geo_expressions);
         CHECK_GE(func_args.size(), size_t(1));
         return func_args;
       }
 
       // First - register srid, then send it to geo literal translation
       int32_t srid = 0;
       if (rex_function->size() == 2) {
         const auto rex_literal =
             dynamic_cast<const RexLiteral*>(rex_function->getOperand(1));
         if (!rex_literal) {
           throw QueryNotSupported(rex_function->getName() +
                                   ": second argument is expected to be a literal");
         }
         const auto e = translateLiteral(rex_literal);
         auto ce = std::dynamic_pointer_cast<Analyzer::Constant>(e);
         if (!ce || !e->get_type_info().is_integer()) {
           throw QueryNotSupported(rex_function->getName() + ": expecting integer SRID");
         }
         if (e->get_type_info().get_type() == kSMALLINT) {
           srid = static_cast<int32_t>(ce->get_constval().smallintval);
         } else if (e->get_type_info().get_type() == kTINYINT) {
           srid = static_cast<int32_t>(ce->get_constval().tinyintval);
         } else if (e->get_type_info().get_type() == kINT) {
           srid = static_cast<int32_t>(ce->get_constval().intval);
         } else {
           throw QueryNotSupported(rex_function->getName() + " expecting integer SRID");
         }
         if (srid != 0 && srid != 4326 && srid != 900913) {
           throw QueryNotSupported(rex_function->getName() + ": unsupported SRID " +
                                   std::to_string(srid));
         }
       }
       arg_ti.set_input_srid(srid);   // Input SRID
       arg_ti.set_output_srid(srid);  // Output SRID is the same - no transform
 
       const auto rex_literal =
           dynamic_cast<const RexLiteral*>(rex_function->getOperand(0));
       if (!rex_literal) {
         throw QueryNotSupported(rex_function->getName() +
                                 " expects a string literal as first argument");
       }
       auto arg0 = translateGeoLiteral(rex_literal, arg_ti, with_bounds);
       arg_ti.set_subtype((rex_function->getName() == "ST_GeogFromText"sv) ? kGEOGRAPHY
                                                                           : kGEOMETRY);
       return arg0;
     } else if (rex_function->getName() == "ST_PointN"sv) {
       // uses geo expressions
       const auto rex_scalar0 =
           dynamic_cast<const RexScalar*>(rex_function->getOperand(0));
       if (!rex_scalar0) {
         throw QueryNotSupported(rex_function->getName() +
                                 ": expects scalar as first argument");
       }
       auto arg0 = translateGeoFunctionArg(rex_scalar0,
                                           arg_ti,
                                           with_bounds,
                                           with_render_group,
                                           expand_geo_col,
                                           /*is_projection=*/false,
                                           /*use_geo_expressions=*/true);
       CHECK_EQ(arg0.size(), size_t(1));
       CHECK(arg0.front());
       if (arg0.front()->get_type_info().get_type() != kLINESTRING) {
         throw QueryNotSupported(rex_function->getName() +
                                 " expects LINESTRING as first argument");
       }
       const auto rex_literal =
           dynamic_cast<const RexLiteral*>(rex_function->getOperand(1));
       if (!rex_literal) {
         throw QueryNotSupported(rex_function->getName() +
                                 ": second argument is expected to be a literal");
       }
       const auto e = translateLiteral(rex_literal);
       auto ce = std::dynamic_pointer_cast<Analyzer::Constant>(e);
       if (!ce || !e->get_type_info().is_integer()) {
         throw QueryNotSupported(rex_function->getName() +
                                 ": expecting integer index as second argument");
       }
       int32_t index = 0;
       if (e->get_type_info().get_type() == kSMALLINT) {
         index = static_cast<int32_t>(ce->get_constval().smallintval);
       } else if (e->get_type_info().get_type() == kTINYINT) {
         index = static_cast<int32_t>(ce->get_constval().tinyintval);
       } else if (e->get_type_info().get_type() == kINT) {
         index = static_cast<int32_t>(ce->get_constval().intval);
       } else {
         throw QueryNotSupported(rex_function->getName() + " expecting integer index");
       }
       if (index == 0) {
         // maybe we will just return NULL here?
         throw QueryNotSupported(rex_function->getName() + ": invalid index");
       }
       arg0.push_back(e);
       auto oper_ti =
           arg0.front()->get_type_info();  // make a copy so we can reset nullness and type
       oper_ti.set_type(kPOINT);
       oper_ti.set_notnull(false);
 
       arg_ti = oper_ti;  // TODO: remove
 
       return {makeExpr<Analyzer::GeoOperator>(oper_ti, rex_function->getName(), arg0)};
 
     } else if (rex_function->getName() == "ST_StartPoint"sv ||
                rex_function->getName() == "ST_EndPoint"sv) {
       std::vector<std::shared_ptr<Analyzer::Expr>> args;
       CHECK_EQ(size_t(1), rex_function->size());
       const auto arg_exprs = translateGeoFunctionArg(rex_function->getOperand(0),
                                                      arg_ti,
                                                      with_bounds,
                                                      with_render_group,
                                                      expand_geo_col,
                                                      is_projection,
                                                      /*use_geo_expressions=*/true);
       CHECK_EQ(arg_exprs.size(), size_t(1));
       CHECK(arg_exprs.front());
       const auto arg_expr_ti = arg_exprs.front()->get_type_info();
       if (arg_expr_ti.get_type() != kLINESTRING) {
         throw QueryNotSupported(rex_function->getName() +
                                 " expected LINESTRING argument. Received " +
                                 arg_expr_ti.toString());
       }
       args.push_back(arg_exprs.front());
 
       auto oper_ti = args.back()->get_type_info();  // make a copy so we can override type
       oper_ti.set_type(kPOINT);
 
       arg_ti = oper_ti;  // TODO: remove
 
       return {makeExpr<Analyzer::GeoOperator>(oper_ti, rex_function->getName(), args)};
     } else if (rex_function->getName() == "ST_SRID"sv) {
       CHECK_EQ(size_t(1), rex_function->size());
       const auto rex_scalar0 =
           dynamic_cast<const RexScalar*>(rex_function->getOperand(0));
       if (!rex_scalar0) {
         throw QueryNotSupported(rex_function->getName() +
                                 ": expects scalar as first argument");
       }
       auto arg0 = translateGeoFunctionArg(
           rex_scalar0, arg_ti, with_bounds, with_render_group, expand_geo_col);
       if (!IS_GEO(arg_ti.get_type())) {
         throw QueryNotSupported(rex_function->getName() + " expects geometry argument");
       }
       return arg0;
     } else if (rex_function->getName() == "ST_SetSRID"sv) {
       CHECK_EQ(size_t(2), rex_function->size());
       const auto rex_literal =
           dynamic_cast<const RexLiteral*>(rex_function->getOperand(1));
       if (!rex_literal) {
         throw QueryNotSupported(rex_function->getName() +
                                 ": second argument is expected to be a literal");
       }
       const auto e = translateLiteral(rex_literal);
       auto ce = std::dynamic_pointer_cast<Analyzer::Constant>(e);
       if (!ce || !e->get_type_info().is_integer()) {
         throw QueryNotSupported(rex_function->getName() + ": expecting integer SRID");
       }
       int32_t srid = 0;
       if (e->get_type_info().get_type() == kSMALLINT) {
         srid = static_cast<int32_t>(ce->get_constval().smallintval);
       } else if (e->get_type_info().get_type() == kTINYINT) {
         srid = static_cast<int32_t>(ce->get_constval().tinyintval);
       } else if (e->get_type_info().get_type() == kINT) {
         srid = static_cast<int32_t>(ce->get_constval().intval);
       } else {
         throw QueryNotSupported(rex_function->getName() + ": expecting integer SRID");
       }
 
       const auto rex_scalar0 =
           dynamic_cast<const RexScalar*>(rex_function->getOperand(0));
       if (!rex_scalar0) {
         throw QueryNotSupported(rex_function->getName() +
                                 ": expects scalar as first argument");
       }
 
       // Only convey the request to compress if dealing with 4326 geo
       auto arg0 = translateGeoFunctionArg(rex_scalar0,
                                           arg_ti,
                                           with_bounds,
                                           with_render_group,
                                           expand_geo_col,
                                           is_projection,
                                           use_geo_expressions,
                                           (try_to_compress && (srid == 4326)));
 
       CHECK(!arg0.empty() && arg0.front());
       if (!IS_GEO(arg_ti.get_type()) && !use_geo_expressions) {
         throw QueryNotSupported(rex_function->getName() + " expects geometry argument");
       }
       arg_ti.set_input_srid(srid);   // Input SRID
       arg_ti.set_output_srid(srid);  // Output SRID is the same - no transform
       if (auto geo_expr = std::dynamic_pointer_cast<Analyzer::GeoExpr>(arg0.front())) {
         CHECK_EQ(arg0.size(), size_t(1));
         auto ti = geo_expr->get_type_info();
         ti.set_input_srid(srid);
         ti.set_output_srid(srid);
         return {geo_expr->add_cast(ti)};
       }
       return arg0;
     } else if (rex_function->getName() == "CastToGeography"sv) {
       CHECK_EQ(size_t(1), rex_function->size());
       const auto rex_scalar0 =
           dynamic_cast<const RexScalar*>(rex_function->getOperand(0));
       if (!rex_scalar0) {
         throw QueryNotSupported(rex_function->getName() +
                                 ": expects scalar as first argument");
       }
       auto arg0 = translateGeoFunctionArg(rex_scalar0,
                                           arg_ti,
                                           with_bounds,
                                           with_render_group,
                                           expand_geo_col,
                                           /*is_projection=*/false,
                                           use_geo_expressions);
       CHECK(!arg0.empty());
       if (auto geo_expr = std::dynamic_pointer_cast<Analyzer::GeoExpr>(arg0.front())) {
         auto arg_ti = geo_expr->get_type_info();  // make a copy
         arg_ti.set_subtype(kGEOGRAPHY);
         return {geo_expr->add_cast(arg_ti)};
       }
       if (use_geo_expressions) {
         arg_ti = arg0.front()->get_type_info();
         arg_ti.set_subtype(kGEOGRAPHY);
         arg0.front()->set_type_info(arg_ti);
       }
       if (!IS_GEO(arg_ti.get_type())) {
         throw QueryNotSupported(rex_function->getName() + " expects geometry argument");
       }
       if (arg_ti.get_output_srid() != 4326) {
         throw QueryNotSupported(rex_function->getName() +
                                 " expects geometry with SRID=4326");
       }
       arg_ti.set_subtype(kGEOGRAPHY);
       return arg0;
     } else if (rex_function->getName() == "ST_Point"sv) {
       CHECK_EQ(size_t(2), rex_function->size());
       arg_ti.set_type(kPOINT);
       arg_ti.set_subtype(kGEOMETRY);
       arg_ti.set_input_srid(0);
       arg_ti.set_output_srid(0);
       arg_ti.set_compression(kENCODING_NONE);
 
       auto coord1 = translateScalarRex(rex_function->getOperand(0));
       auto coord2 = translateScalarRex(rex_function->getOperand(1));
       auto d_ti = SQLTypeInfo(kDOUBLE, false);
       auto cast_coord1 = coord1->add_cast(d_ti);
       auto cast_coord2 = coord2->add_cast(d_ti);
       // First try to fold to geo literal
       auto 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,
                                              /*with_render_group=*/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);
       auto geospatial_base = Geospatial::GeoTypesFactory::createGeoType(*datum.stringval);
       CHECK(geospatial_base);
       SQLTypeInfo ti;
       ti.set_type(get_ti_from_geo(geospatial_base.get()));
       if (arg_ti.get_subtype() == kGEOGRAPHY) {
         ti.set_subtype(kGEOGRAPHY);
       } else {
         ti.set_subtype(kGEOMETRY);
       }
       ti.set_input_srid(arg_ti.get_input_srid());
       ti.set_output_srid(arg_ti.get_output_srid() == 0 ? arg_ti.get_input_srid()
                                                        : arg_ti.get_output_srid());
       // TODO: remove dependence on arg_ti
       if (ti.get_output_srid() == 4326 || arg_ti.get_compression() == kENCODING_GEOINT) {
         ti.set_compression(kENCODING_GEOINT);
         ti.set_comp_param(32);
       }
       ti.set_notnull(true);
       // Before removing dependence on arg_ti need to note that ST_Transform uses it
       // as a vehicle to pass transform output SRID to its args.
       // arg_ti is also expected to be filled with relevant data, which wasn't done here.
       // Not filling arg_ti with the geo constant data (which went to ti instead)
       // resulted in GeoConstant::add_cast adopting a corrupt type info,
       // which later killed codegen. Need to complete arg_ti composition:
       arg_ti = ti;
       return {makeExpr<Analyzer::GeoConstant>(std::move(geospatial_base), ti)};
     }
     return translateGeoLiteral(rex_literal, arg_ti, with_bounds);
   }
   throw QueryNotSupported("Geo function argument not supported");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

Definition at line 130 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();
   if (!Geospatial::GeoTypesFactory::getGeoColumns(
           *wkt->get_constval().stringval, ti, coords, bounds, ring_sizes, poly_rings)) {
     throw QueryNotSupported("Could not read geometry from text");
   }
   ti.set_subtype(kGEOMETRY);
   ti.set_input_srid(srid);
   ti.set_output_srid(srid);
   // Compress geo literals by default
   if (srid == 4326) {
     ti.set_compression(kENCODING_GEOINT);
     ti.set_comp_param(32);
   }
 
   std::vector<std::shared_ptr<Analyzer::Expr>> args;
 
   std::vector<uint8_t> compressed_coords = Geospatial::compress_coords(coords, ti);
   std::list<std::shared_ptr<Analyzer::Expr>> compressed_coords_exprs;
   for (auto cc : compressed_coords) {
     Datum d;
     d.tinyintval = cc;
     auto e = makeExpr<Analyzer::Constant>(kTINYINT, false, d);
     compressed_coords_exprs.push_back(e);
   }
   SQLTypeInfo arr_ti = SQLTypeInfo(kARRAY, true);
   arr_ti.set_subtype(kTINYINT);
   arr_ti.set_size(compressed_coords.size() * sizeof(int8_t));
   arr_ti.set_compression(ti.get_compression());
   arr_ti.set_comp_param((ti.get_compression() == kENCODING_GEOINT) ? 32 : 64);
   args.push_back(makeExpr<Analyzer::Constant>(arr_ti, false, compressed_coords_exprs));
 
   auto lit_type = ti.get_type();
   if (lit_type == 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::translateGeoOverlapsOper ( const RexOperator * rex_operator ) const

private

Definition at line 2012 of file RelAlgTranslatorGeo.cpp.

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

Referenced by translateOverlapsOper().

                                            {
   CHECK_EQ(rex_operator->size(), 2u);
 
   auto translate_input =
       [&](const RexScalar* operand) -> std::shared_ptr<Analyzer::Expr> {
     const auto input = dynamic_cast<const RexInput*>(operand);
     CHECK(input);
 
     SQLTypeInfo ti;
     const auto exprs = translateGeoColumn(input, ti, true, false, false);
     CHECK_GT(exprs.size(), 0u);
     if (ti.get_type() == kPOINT) {
       return exprs.front();
     } else {
       return exprs.back();
     }
   };
 
   SQLQualifier sql_qual{kONE};
   SQLOps sql_op{kOVERLAPS};
   return makeExpr<Analyzer::BinOper>(SQLTypeInfo(kBOOLEAN, false),
                                      false,
                                      sql_op,
                                      sql_qual,
                                      translate_input(rex_operator->getOperand(1)),
                                      translate_input(rex_operator->getOperand(0)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

Definition at line 912 of file RelAlgTranslatorGeo.cpp.

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

Referenced by translateFunction().

                                   {
   // note that this is a bit of a misnomer, as ST_SetSRID embedded in a transform will
   // eventually use geo expressions -- just not here
   const bool use_geo_projections = !(rex_function->getName() == "ST_GeomFromText" ||
                                      rex_function->getName() == "ST_GeogFromText" ||
                                      rex_function->getName() == "ST_SetSRID");
   auto geoargs = translateGeoFunctionArg(rex_function,
                                          ti,
                                          /*with_bounds=*/false,
                                          /*with_render_group=*/false,
                                          /*expand_geo_col=*/true,
                                          /*is_projection=*/true,
                                          /*use_geo_expressions=*/use_geo_projections);
   CHECK(!geoargs.empty());
   if (std::dynamic_pointer_cast<const Analyzer::GeoExpr>(geoargs.front()) &&
       !geoargs.front()->get_type_info().is_array()) {
     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 2680 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 680 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 478 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 2383 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 1509 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 1381 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 1373 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 1122 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 1151 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 359 of file RelAlgTranslator.cpp.

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

Referenced by ResultSetLogicalValuesBuilder::build(), translateGeoFunctionArg(), 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);
       }
       return makeExpr<Analyzer::Constant>(rex_literal->getTargetType(), true, Datum{0});
     }
     default: {
       LOG(FATAL) << "Unexpected literal type " << lit_ti.get_type_name();
     }
   }
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

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

References CHECK, CHECK_GT, executor_, RexOperator::getOperand(), RexOperator::getOperator(), getQuantifiedRhs(), IS_COMPARISON, kIN, kMINUS, kONE, kOVERLAPS, kPLUS, Parser::OperExpr::normalize(), RexOperator::size(), translateDatePlusMinus(), translateGeoComparison(), translateInOper(), translateOverlapsOper(), 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 == kOVERLAPS) {
     return translateOverlapsOper(rex_operator);
   } else if (IS_COMPARISON(sql_op)) {
     auto geo_comp = translateGeoComparison(rex_operator);
     if (geo_comp) {
       return geo_comp;
     }
   }
   auto lhs = translateScalarRex(rex_operator->getOperand(0));
   for (size_t i = 1; i < rex_operator->size(); ++i) {
     std::shared_ptr<Analyzer::Expr> rhs;
     SQLQualifier sql_qual{kONE};
     const auto rhs_op = rex_operator->getOperand(i);
     std::tie(rhs, sql_qual) = 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::translateOverlapsOper ( const RexOperator * rex_operator ) const

private

Definition at line 1046 of file RelAlgTranslator.cpp.

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

Referenced by translateOper().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

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

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation