#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::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 84 of file ExtensionFunctionsWhitelist.h.

Member Function Documentation

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

static

Definition at line 404 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 378 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(), 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 430 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 420 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 426 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 27 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 44 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 60 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 80 of file ExtensionFunctionsWhitelist.cpp.

References ext_arg_type_to_type_info(), functions_, SQLTypeInfoCore< TYPE_FACET_PACK >::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 35 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 244 of file ExtensionFunctionsWhitelist.cpp.

References CHECK(), table_functions::TableFunctionsFactory::functions_, functions_, Int32, 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{"declare " + serialize_type(signature.getRet()) + " @" +
                               signature.getName()};
       std::vector<std::string> arg_strs;
       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 202 of file ExtensionFunctionsWhitelist.cpp.

Referenced by bind_function(), anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_arguments(), and ExtensionFunction::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 212 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 225 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:

Member Data Documentation

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

staticprivate

Definition at line 121 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 124 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 122 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