ExtensionFunctionsWhitelist Class Reference

#include <ExtensionFunctionsWhitelist.h>

Static Public Member Functions
static void	add (const std::string &json_func_sigs)
static void	addUdfs (const std::string &json_func_sigs)
static void	clearRTUdfs ()
static void	addRTUdfs (const std::string &json_func_sigs)
static std::vector < ExtensionFunction > *	get (const std::string &name)
static std::vector < ExtensionFunction > *	get_udf (const std::string &name)
static std::vector < ExtensionFunction >	get_ext_funcs (const std::string &name)
static std::vector < ExtensionFunction >	get_ext_funcs (const std::string &name, size_t arity)
static std::vector < ExtensionFunction >	get_ext_funcs (const std::string &name, size_t arity, const SQLTypeInfo &rtype)
static std::string	toString (const std::vector< ExtensionFunction > &ext_funcs, std::string tab="")
static std::string	toString (const std::vector< SQLTypeInfo > &arg_types)
static std::string	toString (const std::vector< ExtArgumentType > &sig_types)
static std::string	toStringSQL (const std::vector< ExtArgumentType > &sig_types)
static std::string	toString (const ExtArgumentType &sig_type)
static std::string	toStringSQL (const ExtArgumentType &sig_type)
static std::vector< std::string >	getLLVMDeclarations (const std::unordered_set< std::string > &udf_decls)

Static Private Member Functions
static void	addCommon (std::unordered_map< std::string, std::vector< ExtensionFunction >> &sigs, const std::string &json_func_sigs)

Static Private Attributes
static std::unordered_map < std::string, std::vector < ExtensionFunction > >	functions_
static std::unordered_map < std::string, std::vector < ExtensionFunction > >	udf_functions_
static std::unordered_map < std::string, std::vector < ExtensionFunction > >	rt_udf_functions_

Detailed Description

Definition at line 96 of file ExtensionFunctionsWhitelist.h.

Member Function Documentation

void ExtensionFunctionsWhitelist::add ( const std::string &  json_func_sigs )

static

Definition at line 605 of file ExtensionFunctionsWhitelist.cpp.

References addCommon(), and functions_.

Referenced by QueryRunner::QueryRunner::QueryRunner().

                                                                     {
  // Valid json_func_sigs example:
  // [
  //    {
  //       "name":"sum",
  //       "ret":"i32",
  //       "args":[
  //          "i32",
  //          "i32"
  //       ]
  //    }
  // ]

  addCommon(functions_, json_func_sigs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ExtensionFunctionsWhitelist::addCommon ( std::unordered_map< std::string, std::vector< ExtensionFunction >> &  sigs, const std::string &  json_func_sigs  )

staticprivate

Definition at line 579 of file ExtensionFunctionsWhitelist.cpp.

References run_benchmark_import::args, CHECK, anonymous_namespace{ExtensionFunctionsWhitelist.cpp}::deserialize_type(), anonymous_namespace{ExtensionFunctionsWhitelist.cpp}::drop_suffix(), field(), json_str(), setup::name, and to_upper().

Referenced by add(), addRTUdfs(), and addUdfs().

                                                                             {
  rapidjson::Document func_sigs;
  func_sigs.Parse(json_func_sigs.c_str());
  CHECK(func_sigs.IsArray());
  for (auto func_sigs_it = func_sigs.Begin(); func_sigs_it != func_sigs.End();
       ++func_sigs_it) {
    CHECK(func_sigs_it->IsObject());
    const auto name = json_str(field(*func_sigs_it, "name"));
    const auto ret = deserialize_type(json_str(field(*func_sigs_it, "ret")));
    std::vector<ExtArgumentType> args;
    const auto& args_serialized = field(*func_sigs_it, "args");
    CHECK(args_serialized.IsArray());
    for (auto args_serialized_it = args_serialized.Begin();
         args_serialized_it != args_serialized.End();
         ++args_serialized_it) {
      args.push_back(deserialize_type(json_str(*args_serialized_it)));
    }
    signatures[to_upper(drop_suffix(name))].emplace_back(name, args, ret);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ExtensionFunctionsWhitelist::addRTUdfs ( const std::string &  json_func_sigs )

static

Definition at line 631 of file ExtensionFunctionsWhitelist.cpp.

References addCommon(), and rt_udf_functions_.

                                                                           {
  if (!json_func_sigs.empty()) {
    addCommon(rt_udf_functions_, json_func_sigs);
  }
}

Here is the call graph for this function:

void ExtensionFunctionsWhitelist::addUdfs ( const std::string &  json_func_sigs )

static

Definition at line 621 of file ExtensionFunctionsWhitelist.cpp.

References addCommon(), and udf_functions_.

Referenced by QueryRunner::QueryRunner::QueryRunner().

                                                                         {
  if (!json_func_sigs.empty()) {
    addCommon(udf_functions_, json_func_sigs);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ExtensionFunctionsWhitelist::clearRTUdfs ( )

static

Definition at line 627 of file ExtensionFunctionsWhitelist.cpp.

References rt_udf_functions_.

                                              {
  rt_udf_functions_.clear();
}

std::vector< ExtensionFunction > * ExtensionFunctionsWhitelist::get ( const std::string &  name )

static

Definition at line 28 of file ExtensionFunctionsWhitelist.cpp.

References functions_, and to_upper().

                           {
  const auto it = functions_.find(to_upper(name));
  if (it == functions_.end()) {
    return nullptr;
  }
  return &it->second;
}

Here is the call graph for this function:

std::vector< ExtensionFunction > ExtensionFunctionsWhitelist::get_ext_funcs ( const std::string &  name )

static

Definition at line 45 of file ExtensionFunctionsWhitelist.cpp.

References functions_, rt_udf_functions_, to_upper(), and udf_functions_.

Referenced by bind_function().

                           {
  std::vector<ExtensionFunction> ext_funcs = {};
  const auto collections = {&functions_, &udf_functions_, &rt_udf_functions_};
  const auto uname = to_upper(name);
  for (auto funcs : collections) {
    const auto it = funcs->find(uname);
    if (it == funcs->end()) {
      continue;
    }
    auto ext_func_sigs = it->second;
    std::copy(ext_func_sigs.begin(), ext_func_sigs.end(), std::back_inserter(ext_funcs));
  }
  return ext_funcs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< ExtensionFunction > ExtensionFunctionsWhitelist::get_ext_funcs ( const std::string &  name, size_t  arity  )

static

Definition at line 61 of file ExtensionFunctionsWhitelist.cpp.

References functions_, rt_udf_functions_, to_upper(), and udf_functions_.

                  {
  std::vector<ExtensionFunction> ext_funcs = {};
  const auto collections = {&functions_, &udf_functions_, &rt_udf_functions_};
  const auto uname = to_upper(name);
  for (auto funcs : collections) {
    const auto it = funcs->find(uname);
    if (it == funcs->end()) {
      continue;
    }
    auto ext_func_sigs = it->second;
    std::copy_if(ext_func_sigs.begin(),
                 ext_func_sigs.end(),
                 std::back_inserter(ext_funcs),
                 [arity](auto sig) { return arity == sig.getArgs().size(); });
  }
  return ext_funcs;
}

Here is the call graph for this function:

std::vector< ExtensionFunction > ExtensionFunctionsWhitelist::get_ext_funcs ( const std::string &  name, size_t  arity, const SQLTypeInfo &  rtype  )

static

Definition at line 81 of file ExtensionFunctionsWhitelist.cpp.

References ext_arg_type_to_type_info(), functions_, SQLTypeInfo::get_type(), kBOOLEAN, kTINYINT, rt_udf_functions_, to_upper(), and udf_functions_.

                              {
  std::vector<ExtensionFunction> ext_funcs = {};
  const auto collections = {&functions_, &udf_functions_, &rt_udf_functions_};
  const auto uname = to_upper(name);
  for (auto funcs : collections) {
    const auto it = funcs->find(uname);
    if (it == funcs->end()) {
      continue;
    }
    auto ext_func_sigs = it->second;
    std::copy_if(ext_func_sigs.begin(),
                 ext_func_sigs.end(),
                 std::back_inserter(ext_funcs),
                 [arity, rtype](auto sig) {
                   // Ideally, arity should be equal to the number of
                   // sig arguments but there seems to be many cases
                   // where some sig arguments will be represented
                   // with multiple arguments, for instance, array
                   // argument is translated to data pointer and array
                   // size arguments.
                   if (arity > sig.getArgs().size()) {
                     return false;
                   }
                   auto rt = rtype.get_type();
                   auto st = ext_arg_type_to_type_info(sig.getRet()).get_type();
                   return (st == rt || (st == kTINYINT && rt == kBOOLEAN));
                 });
  }
  return ext_funcs;
}

Here is the call graph for this function:

std::vector< ExtensionFunction > * ExtensionFunctionsWhitelist::get_udf ( const std::string &  name )

static

Definition at line 36 of file ExtensionFunctionsWhitelist.cpp.

References to_upper(), and udf_functions_.

                           {
  const auto it = udf_functions_.find(to_upper(name));
  if (it == udf_functions_.end()) {
    return nullptr;
  }
  return &it->second;
}

Here is the call graph for this function:

std::vector< std::string > ExtensionFunctionsWhitelist::getLLVMDeclarations ( const std::unordered_set< std::string > &  udf_decls )

static

Definition at line 418 of file ExtensionFunctionsWhitelist.cpp.

References CHECK, table_functions::TableFunctionsFactory::functions_, functions_, Int32, is_ext_arg_type_array(), join(), and anonymous_namespace{ExtensionFunctionsWhitelist.cpp}::serialize_type().

                                                  {
  std::vector<std::string> declarations;
  for (const auto& kv : functions_) {
    const auto& signatures = kv.second;
    CHECK(!signatures.empty());
    for (const auto& signature : kv.second) {
      // If there is a udf function declaration matching an extension function signature
      // do not emit a duplicate declaration.
      if (!udf_decls.empty() && udf_decls.find(signature.getName()) != udf_decls.end()) {
        continue;
      }

      std::string decl_prefix;
      std::vector<std::string> arg_strs;

      if (is_ext_arg_type_array(signature.getRet())) {
        decl_prefix = "declare void @" + signature.getName();
        arg_strs.emplace_back(serialize_type(signature.getRet()));
      } else {
        decl_prefix =
            "declare " + serialize_type(signature.getRet()) + " @" + signature.getName();
      }
      for (const auto arg : signature.getArgs()) {
        arg_strs.push_back(serialize_type(arg));
      }
      declarations.push_back(decl_prefix + "(" + boost::algorithm::join(arg_strs, ", ") +
                             ");");
    }
  }

  for (const auto& kv : table_functions::TableFunctionsFactory::functions_) {
    if (kv.second.isRuntime()) {
      // Runtime UDTFs are defined in LLVM/NVVM IR module
      continue;
    }
    std::string decl_prefix{"declare " + serialize_type(ExtArgumentType::Int32) + " @" +
                            kv.first};
    std::vector<std::string> arg_strs;
    for (const auto arg : kv.second.getArgs()) {
      arg_strs.push_back(serialize_type(arg));
    }
    declarations.push_back(decl_prefix + "(" + boost::algorithm::join(arg_strs, ", ") +
                           ");");
  }
  return declarations;
}

Here is the call graph for this function:

std::string ExtensionFunctionsWhitelist::toString ( const std::vector< ExtensionFunction > &  ext_funcs, std::string  tab = ""  )

static

Definition at line 273 of file ExtensionFunctionsWhitelist.cpp.

Referenced by bind_function(), table_functions::anonymous_namespace{TableFunctionsFactory.cpp}::ext_arg_pointer_type_to_type_info(), anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_arguments(), table_functions::TableFunction::toString(), ExtensionFunction::toString(), and toString().

                   {
  std::string r = "";
  for (auto sig : ext_funcs) {
    r += tab + sig.toString() + "\n";
  }
  return r;
}

Here is the caller graph for this function:

std::string ExtensionFunctionsWhitelist::toString ( const std::vector< SQLTypeInfo > &  arg_types )

static

Definition at line 283 of file ExtensionFunctionsWhitelist.cpp.

                                             {
  std::string r = "";
  for (auto sig = arg_types.begin(); sig != arg_types.end();) {
    r += sig->get_type_name();
    sig++;
    if (sig != arg_types.end()) {
      r += ", ";
    }
  }
  return r;
}

std::string ExtensionFunctionsWhitelist::toString ( const std::vector< ExtArgumentType > &  sig_types )

static

Definition at line 296 of file ExtensionFunctionsWhitelist.cpp.

References anonymous_namespace{ExtensionFunctionsWhitelist.cpp}::serialize_type().

                                                 {
  std::string r = "";
  for (auto t = sig_types.begin(); t != sig_types.end();) {
    r += serialize_type(*t);
    t++;
    if (t != sig_types.end()) {
      r += ", ";
    }
  }
  return r;
}

Here is the call graph for this function:

std::string ExtensionFunctionsWhitelist::toString ( const ExtArgumentType &  sig_type )

static

Definition at line 322 of file ExtensionFunctionsWhitelist.cpp.

References anonymous_namespace{ExtensionFunctionsWhitelist.cpp}::serialize_type().

                                                                               {
  return serialize_type(sig_type);
}

Here is the call graph for this function:

std::string ExtensionFunctionsWhitelist::toStringSQL ( const std::vector< ExtArgumentType > &  sig_types )

static

Definition at line 309 of file ExtensionFunctionsWhitelist.cpp.

Referenced by table_functions::TableFunction::toStringSQL(), and ExtensionFunction::toStringSQL().

                                                 {
  std::string r = "";
  for (auto t = sig_types.begin(); t != sig_types.end();) {
    r += ExtensionFunctionsWhitelist::toStringSQL(*t);
    t++;
    if (t != sig_types.end()) {
      r += ", ";
    }
  }
  return r;
}

Here is the caller graph for this function:

std::string ExtensionFunctionsWhitelist::toStringSQL ( const ExtArgumentType &  sig_type )

static

Definition at line 326 of file ExtensionFunctionsWhitelist.cpp.

References ArrayBool, ArrayDouble, ArrayFloat, ArrayInt16, ArrayInt32, ArrayInt64, ArrayInt8, Bool, ColumnBool, ColumnDouble, ColumnFloat, ColumnInt16, ColumnInt32, ColumnInt64, ColumnInt8, Cursor, Double, Float, GeoLineString, GeoMultiPolygon, GeoPoint, GeoPolygon, Int16, Int32, Int64, Int8, PBool, PDouble, PFloat, PInt16, PInt32, PInt64, PInt8, UNREACHABLE, and Void.

                                                                                  {
  switch (sig_type) {
    case ExtArgumentType::Int8:
      return "TINYINT";
    case ExtArgumentType::Int16:
      return "SMALLINT";
    case ExtArgumentType::Int32:
      return "INTEGER";
    case ExtArgumentType::Int64:
      return "BIGINT";
    case ExtArgumentType::Float:
      return "FLOAT";
    case ExtArgumentType::Double:
      return "DOUBLE";
    case ExtArgumentType::Bool:
      return "BOOLEAN";
    case ExtArgumentType::PInt8:
      return "TINYINT[]";
    case ExtArgumentType::PInt16:
      return "SMALLINT[]";
    case ExtArgumentType::PInt32:
      return "INT[]";
    case ExtArgumentType::PInt64:
      return "BIGINT[]";
    case ExtArgumentType::PFloat:
      return "FLOAT[]";
    case ExtArgumentType::PDouble:
      return "DOUBLE[]";
    case ExtArgumentType::PBool:
      return "BOOLEAN[]";
    case ExtArgumentType::ArrayInt8:
      return "ARRAY<TINYINT>";
    case ExtArgumentType::ArrayInt16:
      return "ARRAY<SMALLINT>";
    case ExtArgumentType::ArrayInt32:
      return "ARRAY<INT>";
    case ExtArgumentType::ArrayInt64:
      return "ARRAY<BIGINT>";
    case ExtArgumentType::ArrayFloat:
      return "ARRAY<FLOAT>";
    case ExtArgumentType::ArrayDouble:
      return "ARRAY<DOUBLE>";
    case ExtArgumentType::ArrayBool:
      return "ARRAY<BOOLEAN>";
    case ExtArgumentType::ColumnInt8:
      return "COLUMN<TINYINT>";
    case ExtArgumentType::ColumnInt16:
      return "COLUMN<SMALLINT>";
    case ExtArgumentType::ColumnInt32:
      return "COLUMN<INT>";
    case ExtArgumentType::ColumnInt64:
      return "COLUMN<BIGINT>";
    case ExtArgumentType::ColumnFloat:
      return "COLUMN<FLOAT>";
    case ExtArgumentType::ColumnDouble:
      return "COLUMN<DOUBLE>";
    case ExtArgumentType::ColumnBool:
      return "COLUMN<BOOLEAN>";
    case ExtArgumentType::Cursor:
      return "CURSOR";
    case ExtArgumentType::GeoPoint:
      return "POINT";
    case ExtArgumentType::GeoLineString:
      return "LINESTRING";
    case ExtArgumentType::GeoPolygon:
      return "POLYGON";
    case ExtArgumentType::GeoMultiPolygon:
      return "MULTIPOLYGON";
    case ExtArgumentType::Void:
      return "VOID";
    default:
      UNREACHABLE();
  }
  return "";
}

Member Data Documentation

std::unordered_map< std::string, std::vector< ExtensionFunction > > ExtensionFunctionsWhitelist::functions_

staticprivate

Definition at line 136 of file ExtensionFunctionsWhitelist.h.

Referenced by add(), get(), get_ext_funcs(), and getLLVMDeclarations().

std::unordered_map< std::string, std::vector< ExtensionFunction > > ExtensionFunctionsWhitelist::rt_udf_functions_

staticprivate

Definition at line 139 of file ExtensionFunctionsWhitelist.h.

Referenced by addRTUdfs(), clearRTUdfs(), and get_ext_funcs().

std::unordered_map< std::string, std::vector< ExtensionFunction > > ExtensionFunctionsWhitelist::udf_functions_

staticprivate

Definition at line 137 of file ExtensionFunctionsWhitelist.h.

Referenced by addUdfs(), get_ext_funcs(), and get_udf().

---

The documentation for this class was generated from the following files:

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ExtensionFunctionsWhitelist.h
• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ExtensionFunctionsWhitelist.cpp