ExtensionFunctionsBinding.cpp File Reference

#include "ExtensionFunctionsBinding.h"
#include <algorithm>
#include "ExternalExecutor.h"

Include dependency graph for ExtensionFunctionsBinding.cpp:

Go to the source code of this file.

Namespaces
	anonymous_namespace{ExtensionFunctionsBinding.cpp}

Functions
ExtArgumentType	anonymous_namespace{ExtensionFunctionsBinding.cpp}::get_column_arg_elem_type (const ExtArgumentType ext_arg_column_type)
ExtArgumentType	anonymous_namespace{ExtensionFunctionsBinding.cpp}::get_array_arg_elem_type (const ExtArgumentType ext_arg_array_type)
static int	anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_arguments (const SQLTypeInfo &arg_type, int sig_pos, const std::vector< ExtArgumentType > &sig_types, int &penalty_score)
template<typename T >
T	bind_function (std::string name, Analyzer::ExpressionPtrVector func_args, const std::vector< T > &ext_funcs)
const table_functions::TableFunction	bind_table_function (std::string name, Analyzer::ExpressionPtrVector input_args, const std::vector< table_functions::TableFunction > &table_funcs)
ExtensionFunction	bind_function (std::string name, Analyzer::ExpressionPtrVector func_args)
ExtensionFunction	bind_function (const Analyzer::FunctionOper *function_oper)
const table_functions::TableFunction	bind_table_function (std::string name, Analyzer::ExpressionPtrVector input_args)
bool	is_ext_arg_type_array (const ExtArgumentType ext_arg_type)
bool	is_ext_arg_type_column (const ExtArgumentType ext_arg_type)
bool	is_ext_arg_type_geo (const ExtArgumentType ext_arg_type)

Function Documentation

template<typename T >

T bind_function	(	std::string	name,
		Analyzer::ExpressionPtrVector	func_args,
		const std::vector< T > &	ext_funcs
	)

Definition at line 333 of file ExtensionFunctionsBinding.cpp.

References ext_arg_type_to_type_info(), kCOLUMN, anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_arguments(), and ExtensionFunctionsWhitelist::toString().

Referenced by bind_function(), CodeGenerator::codegenFunctionOper(), and RelAlgTranslator::translateFunction().

                                               {
  /* worker function

     Template type T must implement the following methods:

       std::vector<ExtArgumentType> getInputArgs()
   */
  /*
    Return extension function/table function that has the following
    properties

    1. each argument type in `arg_types` matches with extension
       function argument types.

       For scalar types, the matching means that the types are either
       equal or the argument type is smaller than the corresponding
       the extension function argument type. This ensures that no
       information is lost when casting of argument values is
       required.

       For array and geo types, the matching means that the argument
       type matches exactly with a group of extension function
       argument types. See `match_arguments`.

    2. has minimal penalty score among all implementations of the
       extension function with given `name`, see `get_penalty_score`
       for the definition of penalty score.

    It is assumed that function_oper and extension functions in
    ext_funcs have the same name.
   */
  int minimal_score = std::numeric_limits<int>::max();
  int index = -1;
  int optimal = -1;

  std::vector<SQLTypeInfo> type_infos;
  for (auto atype : func_args) {
    if constexpr (std::is_same_v<T, table_functions::TableFunction>) {
      if (dynamic_cast<const Analyzer::ColumnVar*>(atype.get())) {
        auto ti = SQLTypeInfo(kCOLUMN, false);
        ti.set_subtype(atype->get_type_info().get_type());
        type_infos.push_back(ti);
        continue;
      }
    }
    type_infos.push_back(atype->get_type_info());
  }
  for (auto ext_func : ext_funcs) {
    index++;
    auto ext_func_args = ext_func.getInputArgs();
    /* In general, `arg_types.size() <= ext_func_args.size()` because
       non-scalar arguments (such as arrays and geo-objects) are
       mapped to multiple `ext_func` arguments. */
    if (func_args.size() <= ext_func_args.size()) {
      /* argument type must fit into the corresponding signature
         argument type, reject signature if not */
      int penalty_score = 0;
      int pos = 0;
      for (auto ti : type_infos) {
        int offset = match_arguments(ti, pos, ext_func_args, penalty_score);
        if (offset < 0) {
          // atype does not match with ext_func argument
          pos = -1;
          break;
        }
        pos += offset;
      }
      if (pos >= 0) {
        // prefer smaller return types
        penalty_score += ext_arg_type_to_type_info(ext_func.getRet()).get_logical_size();
        if (penalty_score < minimal_score) {
          optimal = index;
          minimal_score = penalty_score;
        }
      }
    }
  }

  if (optimal == -1) {
    /* no extension function found that argument types would match
       with types in `arg_types` */
    auto sarg_types = ExtensionFunctionsWhitelist::toString(type_infos);
    if (!ext_funcs.size()) {
      throw NativeExecutionError("Function " + name + "(" + sarg_types +
                                 ") not supported.");
    }
    std::string choices;
    for (const auto& ext_func : ext_funcs) {
      choices += "\n    " + ext_func.toStringSQL();
    }
    throw std::runtime_error(
        "Function " + name + "(" + sarg_types +
        ") not supported.\n  Existing extension function implementations:" + choices);
  }
  return ext_funcs[optimal];
}

Here is the call graph for this function:

Here is the caller graph for this function:

ExtensionFunction bind_function	(	std::string	name,
		Analyzer::ExpressionPtrVector	func_args
	)

Definition at line 439 of file ExtensionFunctionsBinding.cpp.

References ExtensionFunctionsWhitelist::get_ext_funcs(), and setup::name.

                                                                       {
  // used in RelAlgTranslator.cpp
  std::vector<ExtensionFunction> ext_funcs =
      ExtensionFunctionsWhitelist::get_ext_funcs(name);
  return bind_function<ExtensionFunction>(name, func_args, ext_funcs);
}

Here is the call graph for this function:

ExtensionFunction bind_function

(

const Analyzer::FunctionOper *

function_oper

)

Definition at line 447 of file ExtensionFunctionsBinding.cpp.

References bind_function(), Analyzer::FunctionOper::getArity(), Analyzer::FunctionOper::getName(), Analyzer::FunctionOper::getOwnArg(), and setup::name.

                                                                           {
  // used in ExtensionsIR.cpp
  auto name = function_oper->getName();
  Analyzer::ExpressionPtrVector func_args = {};
  for (size_t i = 0; i < function_oper->getArity(); ++i) {
    func_args.push_back(function_oper->getOwnArg(i));
  }
  return bind_function(name, func_args);
}

Here is the call graph for this function:

const table_functions::TableFunction bind_table_function	(	std::string	name,
		Analyzer::ExpressionPtrVector	input_args,
		const std::vector< table_functions::TableFunction > &	table_funcs
	)

Definition at line 432 of file ExtensionFunctionsBinding.cpp.

References setup::name.

Referenced by bind_table_function(), and RelAlgExecutor::createTableFunctionWorkUnit().

                                                                {
  return bind_function<table_functions::TableFunction>(name, input_args, table_funcs);
}

Here is the caller graph for this function:

const table_functions::TableFunction bind_table_function	(	std::string	name,
		Analyzer::ExpressionPtrVector	input_args
	)

Definition at line 457 of file ExtensionFunctionsBinding.cpp.

References bind_table_function(), and table_functions::TableFunctionsFactory::get_table_funcs().

                                            {
  // used in RelAlgExecutor.cpp
  std::vector<table_functions::TableFunction> table_funcs =
      table_functions::TableFunctionsFactory::get_table_funcs(name);
  return bind_table_function(name, input_args, table_funcs);
}

Here is the call graph for this function:

bool is_ext_arg_type_array

(

const ExtArgumentType

ext_arg_type

)

Definition at line 466 of file ExtensionFunctionsBinding.cpp.

References ArrayBool, ArrayDouble, ArrayFloat, ArrayInt16, ArrayInt32, ArrayInt64, and ArrayInt8.

Referenced by CodeGenerator::codegenFunctionOperCastArgs(), ExtensionFunctionsWhitelist::getLLVMDeclarations(), and anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_arguments().

                                                               {
  switch (ext_arg_type) {
    case ExtArgumentType::ArrayInt8:
    case ExtArgumentType::ArrayInt16:
    case ExtArgumentType::ArrayInt32:
    case ExtArgumentType::ArrayInt64:
    case ExtArgumentType::ArrayFloat:
    case ExtArgumentType::ArrayDouble:
    case ExtArgumentType::ArrayBool:
      return true;

    default:
      return false;
  }
}

Here is the caller graph for this function:

bool is_ext_arg_type_column

(

const ExtArgumentType

ext_arg_type

)

Definition at line 482 of file ExtensionFunctionsBinding.cpp.

References ColumnBool, ColumnDouble, ColumnFloat, ColumnInt16, ColumnInt32, ColumnInt64, and ColumnInt8.

Referenced by anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_arguments().

                                                                {
  switch (ext_arg_type) {
    case ExtArgumentType::ColumnInt8:
    case ExtArgumentType::ColumnInt16:
    case ExtArgumentType::ColumnInt32:
    case ExtArgumentType::ColumnInt64:
    case ExtArgumentType::ColumnFloat:
    case ExtArgumentType::ColumnDouble:
    case ExtArgumentType::ColumnBool:
      return true;

    default:
      return false;
  }
}

Here is the caller graph for this function:

bool is_ext_arg_type_geo

(

const ExtArgumentType

ext_arg_type

)

Definition at line 498 of file ExtensionFunctionsBinding.cpp.

References GeoLineString, GeoMultiPolygon, GeoPoint, and GeoPolygon.

Referenced by CodeGenerator::codegenFunctionOperCastArgs().

                                                             {
  switch (ext_arg_type) {
    case ExtArgumentType::GeoPoint:
    case ExtArgumentType::GeoLineString:
    case ExtArgumentType::GeoPolygon:
    case ExtArgumentType::GeoMultiPolygon:
      return true;

    default:
      return false;
  }
}

Here is the caller graph for this function: