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_column_list_arg_elem_type (const ExtArgumentType ext_arg_column_list_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)
bool	anonymous_namespace{ExtensionFunctionsBinding.cpp}::is_valid_identifier (std::string str)
template<typename T >
std::tuple< T, std::vector < SQLTypeInfo > >	bind_function (std::string name, Analyzer::ExpressionPtrVector func_args, const std::vector< T > &ext_funcs, const std::string processor)
const std::tuple < table_functions::TableFunction, std::vector< SQLTypeInfo > >	bind_table_function (std::string name, Analyzer::ExpressionPtrVector input_args, const std::vector< table_functions::TableFunction > &table_funcs, const bool is_gpu)
ExtensionFunction	bind_function (std::string name, Analyzer::ExpressionPtrVector func_args)
ExtensionFunction	bind_function (std::string name, Analyzer::ExpressionPtrVector func_args, const bool is_gpu)
ExtensionFunction	bind_function (const Analyzer::FunctionOper *function_oper, const bool is_gpu)
const std::tuple < table_functions::TableFunction, std::vector< SQLTypeInfo > >	bind_table_function (std::string name, Analyzer::ExpressionPtrVector input_args, const bool is_gpu)
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_column_list (const ExtArgumentType ext_arg_type)
bool	is_ext_arg_type_geo (const ExtArgumentType ext_arg_type)
bool	is_ext_arg_type_pointer (const ExtArgumentType ext_arg_type)
bool	is_ext_arg_type_scalar (const ExtArgumentType ext_arg_type)

Function Documentation

template<typename T >

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

Definition at line 408 of file ExtensionFunctionsBinding.cpp.

References ext_arg_type_to_type_info(), logger::FATAL, generate_column_list_type(), generate_column_type(), anonymous_namespace{ExtensionFunctionsBinding.cpp}::is_valid_identifier(), LOG, anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_arguments(), setup::name, omnisci.dtypes::T, 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.
   */
  if (!is_valid_identifier(name)) {
    throw NativeExecutionError(
        "Cannot bind function with invalid UDF/UDTF function name: " + name);
  }

  int minimal_score = std::numeric_limits<int>::max();
  int index = -1;
  int optimal = -1;
  int optimal_variant = -1;

  std::vector<SQLTypeInfo> type_infos_input;
  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 = generate_column_type(atype->get_type_info().get_type());
        type_infos_input.push_back(ti);
        continue;
      }
    }
    type_infos_input.push_back(atype->get_type_info());
  }

  // clang-format off
  /*
    Table functions may have arguments such as ColumnList that collect
    neighboring columns with the same data type into a single object.
    Here we compute all possible combinations of mapping a subset of
    columns into columns sets. For example, if the types of function
    arguments are (as given in func_args argument)

      (Column<int>, Column<int>, Column<int>, int)

    then the computed variants will be

      (Column<int>, Column<int>, Column<int>, int)
      (Column<int>, Column<int>, ColumnList[1]<int>, int)
      (Column<int>, ColumnList[1]<int>, Column<int>, int)
      (Column<int>, ColumnList[2]<int>, int)
      (ColumnList[1]<int>, Column<int>, Column<int>, int)
      (ColumnList[1]<int>, Column<int>, ColumnList[1]<int>, int)
      (ColumnList[2]<int>, Column<int>, int)
      (ColumnList[3]<int>, int)

    where the integers in [..] indicate the number of collected
    columns. In the SQLTypeInfo instance, this number is stored in the
    SQLTypeInfo dimension attribute.

    As an example, let us consider a SQL query containing the
    following expression calling a UDTF foo:

      table(foo(cursor(select a, b, c from tableofints), 1))

    Here follows a list of table functions and the corresponding
    optimal argument type variants that are computed for the given
    query expression:

    UDTF:  foo(ColumnList<int>, RowMultiplier) -> Column<int>
           (ColumnList[3]<int>, int)               # a, b, c are all collected to column_list

    UDTF:  foo(Column<int>, ColumnList<int>, RowMultiplier) -> Column<int>
           (Column<int>, ColumnList[2]<int>, int)  # b and c are collected to column_list

    UDTF:  foo(Column<int>, Column<int>, Column<int>, RowMultiplier) -> Column<int>
           (Column<int>, Column<int>, Column<int>, int)
   */
  // clang-format on
  std::vector<std::vector<SQLTypeInfo>> type_infos_variants;
  for (auto ti : type_infos_input) {
    if (type_infos_variants.begin() == type_infos_variants.end()) {
      type_infos_variants.push_back({ti});
      if constexpr (std::is_same_v<T, table_functions::TableFunction>) {
        if (ti.is_column()) {
          auto mti = generate_column_list_type(ti.get_subtype());
          mti.set_dimension(1);
          type_infos_variants.push_back({mti});
        }
      }
      continue;
    }
    std::vector<std::vector<SQLTypeInfo>> new_type_infos_variants;
    for (auto& type_infos : type_infos_variants) {
      if constexpr (std::is_same_v<T, table_functions::TableFunction>) {
        if (ti.is_column()) {
          auto new_type_infos = type_infos;  // makes a copy
          const auto& last = type_infos.back();
          if (last.is_column_list() && last.get_subtype() == ti.get_subtype()) {
            // last column_list consumes column argument if types match
            new_type_infos.back().set_dimension(last.get_dimension() + 1);
          } else {
            // add column as column_list argument
            auto mti = generate_column_list_type(ti.get_subtype());
            mti.set_dimension(1);
            new_type_infos.push_back(mti);
          }
          new_type_infos_variants.push_back(new_type_infos);
        }
      }
      type_infos.push_back(ti);
    }
    type_infos_variants.insert(type_infos_variants.end(),
                               new_type_infos_variants.begin(),
                               new_type_infos_variants.end());
  }
  // Find extension function that gives the best match on the set of
  // argument type variants:
  for (auto ext_func : ext_funcs) {
    index++;
    auto ext_func_args = ext_func.getInputArgs();
    int index_variant = -1;
    for (const auto& type_infos : type_infos_variants) {
      index_variant++;
      int penalty_score = 0;
      int pos = 0;
      for (const 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 ((size_t)pos == ext_func_args.size()) {
        // 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;
          optimal_variant = index_variant;
        }
      }
    }
  }

  if (optimal == -1) {
    /* no extension function found that argument types would match
       with types in `arg_types` */
    auto sarg_types = ExtensionFunctionsWhitelist::toString(type_infos_input);
    std::string message;
    if (!ext_funcs.size()) {
      message = "Function " + name + "(" + sarg_types + ") not supported.";
      throw ExtensionFunctionBindingError(message);
    } else {
      if constexpr (std::is_same_v<T, table_functions::TableFunction>) {
        message = "Could not bind " + name + "(" + sarg_types + ") to any " + processor +
                  " UDTF implementation.";
      } else if constexpr (std::is_same_v<T, ExtensionFunction>) {
        message = "Could not bind " + name + "(" + sarg_types + ") to any " + processor +
                  " UDF implementation.";
      } else {
        LOG(FATAL) << "bind_function: unknown extension function type "
                   << typeid(T).name();
      }
      message += "\n  Existing extension function implementations:";
      for (const auto& ext_func : ext_funcs) {
        message += "\n    " + ext_func.toStringSQL();
      }
    }
    throw ExtensionFunctionBindingError(message);
  }
  return {ext_funcs[optimal], type_infos_variants[optimal_variant]};
}

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 617 of file ExtensionFunctionsBinding.cpp.

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

                                                                       {
  // used in RelAlgTranslator.cpp, first try GPU UDFs, then fall back
  // to CPU UDFs.
  bool is_gpu = true;
  std::string processor = "GPU";
  auto ext_funcs = ExtensionFunctionsWhitelist::get_ext_funcs(name, is_gpu);
  if (!ext_funcs.size()) {
    is_gpu = false;
    processor = "CPU";
    ext_funcs = ExtensionFunctionsWhitelist::get_ext_funcs(name, is_gpu);
  }
  try {
    return std::get<0>(
        bind_function<ExtensionFunction>(name, func_args, ext_funcs, processor));
  } catch (ExtensionFunctionBindingError& e) {
    if (is_gpu) {
      is_gpu = false;
      processor = "GPU|CPU";
      ext_funcs = ExtensionFunctionsWhitelist::get_ext_funcs(name, is_gpu);
      return std::get<0>(
          bind_function<ExtensionFunction>(name, func_args, ext_funcs, processor));
    } else {
      throw;
    }
  }
}

Here is the call graph for this function:

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

Definition at line 645 of file ExtensionFunctionsBinding.cpp.

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

                                                   {
  // used below
  std::vector<ExtensionFunction> ext_funcs =
      ExtensionFunctionsWhitelist::get_ext_funcs(name, is_gpu);
  std::string processor = (is_gpu ? "GPU" : "CPU");
  return std::get<0>(
      bind_function<ExtensionFunction>(name, func_args, ext_funcs, processor));
}

Here is the call graph for this function:

ExtensionFunction bind_function	(	const Analyzer::FunctionOper *	function_oper,
		const bool	is_gpu
	)

Definition at line 656 of file ExtensionFunctionsBinding.cpp.

References bind_function(), Analyzer::FunctionOper::getArity(), Analyzer::FunctionOper::getName(), Analyzer::FunctionOper::getOwnArg(), i, 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, is_gpu);
}

Here is the call graph for this function:

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

Definition at line 608 of file ExtensionFunctionsBinding.cpp.

References setup::name.

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

                                       {
  std::string processor = (is_gpu ? "GPU" : "CPU");
  return bind_function<table_functions::TableFunction>(
      name, input_args, table_funcs, processor);
}

Here is the caller graph for this function:

const std::tuple<table_functions::TableFunction, std::vector<SQLTypeInfo> > bind_table_function	(	std::string	name,
		Analyzer::ExpressionPtrVector	input_args,
		const bool	is_gpu
	)

Definition at line 668 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, is_gpu);
  return bind_table_function(name, input_args, table_funcs, is_gpu);
}

Here is the call graph for this function:

bool is_ext_arg_type_array

(

const ExtArgumentType

ext_arg_type

)

Definition at line 677 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 693 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_column_list

(

const ExtArgumentType

ext_arg_type

)

Definition at line 709 of file ExtensionFunctionsBinding.cpp.

References ColumnListBool, ColumnListDouble, ColumnListFloat, ColumnListInt16, ColumnListInt32, ColumnListInt64, and ColumnListInt8.

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

                                                                     {
  switch (ext_arg_type) {
    case ExtArgumentType::ColumnListInt8:
    case ExtArgumentType::ColumnListInt16:
    case ExtArgumentType::ColumnListInt32:
    case ExtArgumentType::ColumnListInt64:
    case ExtArgumentType::ColumnListFloat:
    case ExtArgumentType::ColumnListDouble:
    case ExtArgumentType::ColumnListBool:
      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 725 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:

bool is_ext_arg_type_pointer

(

const ExtArgumentType

ext_arg_type

)

Definition at line 738 of file ExtensionFunctionsBinding.cpp.

References PBool, PDouble, PFloat, PInt16, PInt32, PInt64, and PInt8.

Referenced by CodeGenerator::codegenFunctionOperCastArgs().

                                                                 {
  switch (ext_arg_type) {
    case ExtArgumentType::PInt8:
    case ExtArgumentType::PInt16:
    case ExtArgumentType::PInt32:
    case ExtArgumentType::PInt64:
    case ExtArgumentType::PFloat:
    case ExtArgumentType::PDouble:
    case ExtArgumentType::PBool:
      return true;

    default:
      return false;
  }
}

Here is the caller graph for this function:

bool is_ext_arg_type_scalar

(

const ExtArgumentType

ext_arg_type

)

Definition at line 754 of file ExtensionFunctionsBinding.cpp.

References Bool, Double, Float, Int16, Int32, Int64, and Int8.

                                                                {
  switch (ext_arg_type) {
    case ExtArgumentType::Int8:
    case ExtArgumentType::Int16:
    case ExtArgumentType::Int32:
    case ExtArgumentType::Int64:
    case ExtArgumentType::Float:
    case ExtArgumentType::Double:
    case ExtArgumentType::Bool:
      return true;

    default:
      return false;
  }
}