ExtensionFunctionsBinding.cpp File Reference

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

Include dependency graph for ExtensionFunctionsBinding.cpp:

Go to the source code of this file.

Namespaces
	anonymous_namespace{ExtensionFunctionsBinding.cpp}

Functions
static int	anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_arguments (const SQLTypeInfo &arg_type, int sig_pos, const std::vector< ExtArgumentType > &sig_types, int &penalty_score)
ExtensionFunction	bind_function (std::string name, Analyzer::ExpressionPtrVector func_args, const std::vector< ExtensionFunction > &ext_funcs)
ExtensionFunction	bind_function (std::string name, Analyzer::ExpressionPtrVector func_args)
ExtensionFunction	bind_function (const Analyzer::FunctionOper *function_oper)
bool	is_ext_arg_type_array (const ExtArgumentType ext_arg_type)
bool	is_ext_arg_type_geo (const ExtArgumentType ext_arg_type)

Function Documentation

bind_function() [1/3]

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

Definition at line 254 of file ExtensionFunctionsBinding.cpp.

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

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

                                                                               {
  // worker function
  /*
    Return extension 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;
  for (auto ext_func : ext_funcs) {
    index++;
    auto ext_func_args = ext_func.getArgs();
    /* 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 atype : func_args) {
        int offset =
            match_arguments(atype->get_type_info(), 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` */
    std::vector<SQLTypeInfo> arg_types;
    for (size_t i = 0; i < func_args.size(); ++i) {
      arg_types.push_back(func_args[i]->get_type_info());
    }
    auto sarg_types = ExtensionFunctionsWhitelist::toString(arg_types);
    if (!ext_funcs.size()) {
      throw std::runtime_error("Function " + name + "(" + sarg_types +
                               ") not supported.");
    }
    auto choices = ExtensionFunctionsWhitelist::toString(ext_funcs, "    ");
    throw std::runtime_error(
        "Function " + name + "(" + sarg_types +
        ") not supported.\n  Existing extension function implementations:\n" + choices);
  }
  return ext_funcs[optimal];
}

Here is the call graph for this function:

Here is the caller graph for this function:

bind_function() [2/3]

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

Definition at line 336 of file ExtensionFunctionsBinding.cpp.

References bind_function(), and ExtensionFunctionsWhitelist::get_ext_funcs().

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

Here is the call graph for this function:

bind_function() [3/3]

ExtensionFunction bind_function

(

const Analyzer::FunctionOper *

function_oper

)

Definition at line 344 of file ExtensionFunctionsBinding.cpp.

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

                                                                           {
  // used in ExtensionIR.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:

is_ext_arg_type_array()

bool is_ext_arg_type_array

(

const ExtArgumentType

ext_arg_type

)

Definition at line 354 of file ExtensionFunctionsBinding.cpp.

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

Referenced by CodeGenerator::codegenFunctionOperCastArgs(), 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:
      return true;

    default:
      return false;
  }
}

Here is the caller graph for this function:

is_ext_arg_type_geo()

bool is_ext_arg_type_geo

(

const ExtArgumentType

ext_arg_type

)

Definition at line 369 of file ExtensionFunctionsBinding.cpp.

References GeoLineString, GeoPoint, and GeoPolygon.

Referenced by CodeGenerator::codegenFunctionOperCastArgs().

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

    default:
      return false;
  }
}

Here is the caller graph for this function: