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

Include dependency graph for ExtensionFunctionsBinding.cpp:

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

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:

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:

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:

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:

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:

Namespaces

Functions

Function Documentation