#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, const bool is_gpu)

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, const bool is_gpu=false)

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 115 of file ExtensionFunctionsWhitelist.h.

Member Function Documentation

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

static

Definition at line 699 of file ExtensionFunctionsWhitelist.cpp.

References addCommon(), and functions_.

Referenced by DBHandler::initialize(), and 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 673 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 725 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 715 of file ExtensionFunctionsWhitelist.cpp.

References addCommon(), and udf_functions_.

Referenced by DBHandler::initialize(), and 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 721 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,
		const bool	is_gpu
	)

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_if(ext_func_sigs.begin(),
                  ext_func_sigs.end(),
                  std::back_inserter(ext_funcs),
                  [is_gpu](auto sig) { return (is_gpu ? sig.isGPU() : sig.isCPU()); });
   }
   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 65 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 85 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,
		const bool	is_gpu = `false`
	)

static

Definition at line 474 of file ExtensionFunctionsWhitelist.cpp.

References CHECK, functions_, table_functions::TableFunctionsFactory::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() || kv.second.useDefaultSizer()) {
       // Runtime UDTFs are defined in LLVM/NVVM IR module
       // UDTFs using default sizer share LLVM IR
       continue;
     }
     if (!((is_gpu && kv.second.isGPU()) || (!is_gpu && kv.second.isCPU()))) {
       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(/* ensure_column = */ true)) {
       arg_strs.push_back(serialize_type(arg, /* byval= */ kv.second.isRuntime()));
     }
     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 307 of file ExtensionFunctionsWhitelist.cpp.

References test_fsi::r.

Referenced by bind_function(), table_functions::anonymous_namespace{TableFunctionsFactory.cpp}::ext_arg_pointer_type_to_type_info(), table_functions::anonymous_namespace{TableFunctionsFactory.cpp}::ext_arg_type_to_type_info_output(), table_functions::TableFunction::getSignature(), anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_arguments(), ExtensionFunction::toString(), toString(), and table_functions::TableFunction::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 317 of file ExtensionFunctionsWhitelist.cpp.

References test_fsi::r.

                                              {
   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 330 of file ExtensionFunctionsWhitelist.cpp.

References test_fsi::r, anonymous_namespace{ExtensionFunctionsWhitelist.cpp}::serialize_type(), and t.

                                                  {
   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 356 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 343 of file ExtensionFunctionsWhitelist.cpp.

References test_fsi::r, and t.

Referenced by ExtensionFunction::toStringSQL(), and table_functions::TableFunction::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 360 of file ExtensionFunctionsWhitelist.cpp.

References ArrayBool, ArrayDouble, ArrayFloat, ArrayInt16, ArrayInt32, ArrayInt64, ArrayInt8, Bool, ColumnBool, ColumnDouble, ColumnFloat, ColumnInt16, ColumnInt32, ColumnInt64, ColumnInt8, ColumnListBool, ColumnListDouble, ColumnListFloat, ColumnListInt16, ColumnListInt32, ColumnListInt64, ColumnListInt8, Cursor, Double, Float, GeoLineString, GeoMultiPolygon, GeoPoint, GeoPolygon, Int16, Int32, Int64, Int8, PBool, PDouble, PFloat, PInt16, PInt32, PInt64, PInt8, TextEncodingDict16, TextEncodingDict32, TextEncodingDict8, TextEncodingNone, 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";
     case ExtArgumentType::TextEncodingNone:
       return "TEXT ENCODING NONE";
     case ExtArgumentType::TextEncodingDict8:
       return "TEXT ENCODING DICT(8)";
     case ExtArgumentType::TextEncodingDict16:
       return "TEXT ENCODING DICT(16)";
     case ExtArgumentType::TextEncodingDict32:
       return "TEXT ENCODING DICT(32)";
     case ExtArgumentType::ColumnListInt8:
       return "COLUMNLIST<TINYINT>";
     case ExtArgumentType::ColumnListInt16:
       return "COLUMNLIST<SMALLINT>";
     case ExtArgumentType::ColumnListInt32:
       return "COLUMNLIST<INT>";
     case ExtArgumentType::ColumnListInt64:
       return "COLUMNLIST<BIGINT>";
     case ExtArgumentType::ColumnListFloat:
       return "COLUMNLIST<FLOAT>";
     case ExtArgumentType::ColumnListDouble:
       return "COLUMNLIST<DOUBLE>";
     case ExtArgumentType::ColumnListBool:
       return "COLUMNLIST<BOOLEAN>";
     default:
       UNREACHABLE();
   }
   return "";
 }

Member Data Documentation

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

staticprivate

Definition at line 157 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 162 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 159 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

Static Public Member Functions

Static Private Member Functions

Static Private Attributes

Detailed Description

Member Function Documentation

Member Data Documentation