#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::unordered_set < std::string >	get_udfs_name (const bool is_runtime)

static std::vector < ExtensionFunction >	get_ext_funcs (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, const bool is_runtime)

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

Member Function Documentation

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

static

Definition at line 947 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, /* is_runtime */ false);
 }

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

staticprivate

Definition at line 902 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)));
     }
 
     std::vector<std::map<std::string, std::string>> annotations;
     const auto& anns = field(*func_sigs_it, "annotations");
     CHECK(anns.IsArray());
     static const std::map<std::string, std::string> map_empty = {};
     for (auto obj = anns.Begin(); obj != anns.End(); ++obj) {
       CHECK(obj->IsObject());
       if (obj->ObjectEmpty()) {
         annotations.push_back(map_empty);
       } else {
         std::map<std::string, std::string> m;
         for (auto kv = obj->MemberBegin(); kv != obj->MemberEnd(); ++kv) {
           m[kv->name.GetString()] = kv->value.GetString();
         }
         annotations.push_back(m);
       }
     }
     signatures[to_upper(drop_suffix(name))].emplace_back(
         name, args, ret, annotations, is_runtime);
   }
 }

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

References addCommon(), and rt_udf_functions_.

Referenced by DBHandler::register_runtime_extension_functions().

                                                                            {
   if (!json_func_sigs.empty()) {
     addCommon(rt_udf_functions_, json_func_sigs, /* is_runtime */ true);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

static

Definition at line 963 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, /* is_runtime */ false);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ExtensionFunctionsWhitelist::clearRTUdfs ( )

static

Definition at line 969 of file ExtensionFunctionsWhitelist.cpp.

References rt_udf_functions_.

Referenced by DBHandler::register_runtime_extension_functions().

                                               {
   rt_udf_functions_.clear();
 }

Here is the caller graph for this function:

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

References gpu_enabled::copy(), functions_, rt_udf_functions_, to_upper(), and udf_functions_.

Referenced by bind_function(), ShowFunctionsCommand::execute(), and DBHandler::get_function_details().

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

static

Definition at line 78 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),
                  [is_gpu](auto sig) { return (is_gpu ? sig.isGPU() : sig.isCPU()); });
   }
   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
	)

static

Definition at line 98 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.getInputArgs().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 118 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.getInputArgs().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 37 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::unordered_set< std::string > ExtensionFunctionsWhitelist::get_udfs_name ( const bool is_runtime )

static

Definition at line 47 of file ExtensionFunctionsWhitelist.cpp.

References functions_, ExtensionFunction::getName(), ExtensionFunction::isRuntime(), rt_udf_functions_, and udf_functions_.

Referenced by ShowFunctionsCommand::execute(), ShowRuntimeFunctionsCommand::execute(), DBHandler::get_function_names(), and DBHandler::get_runtime_function_names().

                            {
   std::unordered_set<std::string> names;
   const auto collections = {&functions_, &udf_functions_, &rt_udf_functions_};
   for (auto funcs : collections) {
     for (auto& pair : *funcs) {
       ExtensionFunction udf = pair.second.at(0);
       if (udf.isRuntime() == is_runtime) {
         names.insert(udf.getName(/* keep_suffix */ false));
       }
     }
   }
   return names;
 }

Here is the call graph for this function:

Here is the caller 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 621 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 std::vector<ExtensionFunction>& ext_funcs = kv.second;
     CHECK(!ext_funcs.empty());
     for (const auto& ext_func : ext_funcs) {
       // 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(ext_func.getName()) != udf_decls.end()) {
         continue;
       }
 
       std::string decl_prefix;
       std::vector<std::string> arg_strs;
 
       if (is_ext_arg_type_array(ext_func.getRet())) {
         decl_prefix = "declare void @" + ext_func.getName();
         arg_strs.emplace_back(
             serialize_type(ext_func.getRet(), /* byval */ true, /* declare */ true));
       } else {
         decl_prefix =
             "declare " +
             serialize_type(ext_func.getRet(), /* byval */ true, /* declare */ true) +
             " @" + ext_func.getName();
       }
 
       // if the extension function uses a Row Function Manager, append "i8*" as the first
       // arg
       if (ext_func.usesManager()) {
         arg_strs.emplace_back("i8*");
       }
 
       for (const auto arg : ext_func.getInputArgs()) {
         arg_strs.emplace_back(serialize_type(arg, /* byval */ false, /* declare */ true));
       }
       declarations.emplace_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, /* byval */ true, /* declare */ true) +
         " @" + 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(), /* declare= */ true));
     }
     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 389 of file ExtensionFunctionsWhitelist.cpp.

Referenced by bind_function(), table_functions::TableFunction::getArgTypes(), table_functions::TableFunction::getSignature(), anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_arguments(), ExtensionFunction::toSignature(), 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 399 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 412 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, /* byval */ false, /* declare */ false);
     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 438 of file ExtensionFunctionsWhitelist.cpp.

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

                                                                                {
   return serialize_type(sig_type, /* byval */ false, /* declare */ false);
 }

Here is the call graph for this function:

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

static

Definition at line 425 of file ExtensionFunctionsWhitelist.cpp.

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

References ArrayBool, ArrayDouble, ArrayFloat, ArrayInt16, ArrayInt32, ArrayInt64, ArrayInt8, ArrayTextEncodingDict, Bool, ColumnArrayBool, ColumnArrayDouble, ColumnArrayFloat, ColumnArrayInt16, ColumnArrayInt32, ColumnArrayInt64, ColumnArrayInt8, ColumnArrayTextEncodingDict, ColumnBool, ColumnDouble, ColumnFloat, ColumnInt16, ColumnInt32, ColumnInt64, ColumnInt8, ColumnListArrayBool, ColumnListArrayDouble, ColumnListArrayFloat, ColumnListArrayInt16, ColumnListArrayInt32, ColumnListArrayInt64, ColumnListArrayInt8, ColumnListArrayTextEncodingDict, ColumnListBool, ColumnListDouble, ColumnListFloat, ColumnListInt16, ColumnListInt32, ColumnListInt64, ColumnListInt8, ColumnListTextEncodingDict, ColumnTextEncodingDict, ColumnTimestamp, Cursor, DayTimeInterval, Double, Float, GeoLineString, GeoMultiLineString, GeoMultiPoint, GeoMultiPolygon, GeoPoint, GeoPolygon, Int16, Int32, Int64, Int8, PBool, PDouble, PFloat, PInt16, PInt32, PInt64, PInt8, TextEncodingDict, TextEncodingNone, Timestamp, UNREACHABLE, Void, and YearMonthTimeInterval.

                                                                                   {
   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::ArrayTextEncodingDict:
       return "ARRAY<TEXT ENCODING DICT>";
     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::ColumnTextEncodingDict:
       return "COLUMN<TEXT ENCODING DICT>";
     case ExtArgumentType::ColumnTimestamp:
       return "COLUMN<TIMESTAMP(9)>";
     case ExtArgumentType::Cursor:
       return "CURSOR";
     case ExtArgumentType::GeoPoint:
       return "POINT";
     case ExtArgumentType::GeoMultiPoint:
       return "MULTIPOINT";
     case ExtArgumentType::GeoLineString:
       return "LINESTRING";
     case ExtArgumentType::GeoMultiLineString:
       return "MULTILINESTRING";
     case ExtArgumentType::GeoPolygon:
       return "POLYGON";
     case ExtArgumentType::GeoMultiPolygon:
       return "MULTIPOLYGON";
     case ExtArgumentType::Void:
       return "VOID";
     case ExtArgumentType::TextEncodingNone:
       return "TEXT ENCODING NONE";
     case ExtArgumentType::TextEncodingDict:
       return "TEXT ENCODING DICT";
     case ExtArgumentType::Timestamp:
       return "TIMESTAMP(9)";
     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>";
     case ExtArgumentType::ColumnListTextEncodingDict:
       return "COLUMNLIST<TEXT ENCODING DICT>";
     case ExtArgumentType::ColumnArrayInt8:
       return "COLUMN<ARRAY<TINYINT>>";
     case ExtArgumentType::ColumnArrayInt16:
       return "COLUMN<ARRAY<SMALLINT>>";
     case ExtArgumentType::ColumnArrayInt32:
       return "COLUMN<ARRAY<INT>>";
     case ExtArgumentType::ColumnArrayInt64:
       return "COLUMN<ARRAY<BIGINT>>";
     case ExtArgumentType::ColumnArrayFloat:
       return "COLUMN<ARRAY<FLOAT>>";
     case ExtArgumentType::ColumnArrayDouble:
       return "COLUMN<ARRAY<DOUBLE>>";
     case ExtArgumentType::ColumnArrayBool:
       return "COLUMN<ARRAY<BOOLEAN>>";
     case ExtArgumentType::ColumnArrayTextEncodingDict:
       return "COLUMN<ARRAY<TEXT ENCODING DICT>>";
     case ExtArgumentType::ColumnListArrayInt8:
       return "COLUMNLIST<ARRAY<TINYINT>>";
     case ExtArgumentType::ColumnListArrayInt16:
       return "COLUMNLIST<ARRAY<SMALLINT>>";
     case ExtArgumentType::ColumnListArrayInt32:
       return "COLUMNLIST<ARRAY<INT>>";
     case ExtArgumentType::ColumnListArrayInt64:
       return "COLUMNLIST<ARRAY<BIGINT>>";
     case ExtArgumentType::ColumnListArrayFloat:
       return "COLUMNLIST<ARRAY<FLOAT>>";
     case ExtArgumentType::ColumnListArrayDouble:
       return "COLUMNLIST<ARRAY<DOUBLE>>";
     case ExtArgumentType::ColumnListArrayBool:
       return "COLUMNLIST<ARRAY<BOOLEAN>>";
     case ExtArgumentType::ColumnListArrayTextEncodingDict:
       return "COLUMNLIST<ARRAY<TEXT ENCODING DICT>>";
     case ExtArgumentType::DayTimeInterval:
       return "DAY TIME INTERVAL";
     case ExtArgumentType::YearMonthTimeInterval:
       return "YEAR MONTH INTERVAL";
     default:
       UNREACHABLE();
   }
   return "";
 }

Member Data Documentation

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

staticprivate

Definition at line 206 of file ExtensionFunctionsWhitelist.h.

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

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

staticprivate

Definition at line 211 of file ExtensionFunctionsWhitelist.h.

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

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

staticprivate

Definition at line 208 of file ExtensionFunctionsWhitelist.h.

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

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