OmniSciDB  4201147b46
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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::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 123 of file ExtensionFunctionsWhitelist.h.

Member Function Documentation

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

Definition at line 766 of file ExtensionFunctionsWhitelist.cpp.

References addCommon(), and functions_.

Referenced by DBHandler::initialize(), and QueryRunner::QueryRunner::QueryRunner().

766  {
767  // Valid json_func_sigs example:
768  // [
769  // {
770  // "name":"sum",
771  // "ret":"i32",
772  // "args":[
773  // "i32",
774  // "i32"
775  // ]
776  // }
777  // ]
778 
779  addCommon(functions_, json_func_sigs, /* is_runtime */ false);
780 }
static void addCommon(std::unordered_map< std::string, std::vector< ExtensionFunction >> &sigs, const std::string &json_func_sigs, const bool is_runtime)
static std::unordered_map< std::string, std::vector< ExtensionFunction > > functions_

+ 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 739 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().

741  {
742  rapidjson::Document func_sigs;
743  func_sigs.Parse(json_func_sigs.c_str());
744  CHECK(func_sigs.IsArray());
745  for (auto func_sigs_it = func_sigs.Begin(); func_sigs_it != func_sigs.End();
746  ++func_sigs_it) {
747  CHECK(func_sigs_it->IsObject());
748  const auto name = json_str(field(*func_sigs_it, "name"));
749  const auto ret = deserialize_type(json_str(field(*func_sigs_it, "ret")));
750  std::vector<ExtArgumentType> args;
751  const auto& args_serialized = field(*func_sigs_it, "args");
752  CHECK(args_serialized.IsArray());
753  for (auto args_serialized_it = args_serialized.Begin();
754  args_serialized_it != args_serialized.End();
755  ++args_serialized_it) {
756  args.push_back(deserialize_type(json_str(*args_serialized_it)));
757  }
758  signatures[to_upper(drop_suffix(name))].emplace_back(name, args, ret, is_runtime);
759  }
760 }
const std::string json_str(const rapidjson::Value &obj) noexcept
Definition: JsonAccessors.h:44
const rapidjson::Value & field(const rapidjson::Value &obj, const char field[]) noexcept
Definition: JsonAccessors.h:31
ExtArgumentType deserialize_type(const std::string &type_name)
std::string to_upper(const std::string &str)
#define CHECK(condition)
Definition: Logger.h:222
string name
Definition: setup.in.py:72

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

References addCommon(), and rt_udf_functions_.

Referenced by DBHandler::register_runtime_extension_functions().

792  {
793  if (!json_func_sigs.empty()) {
794  addCommon(rt_udf_functions_, json_func_sigs, /* is_runtime */ true);
795  }
796 }
static void addCommon(std::unordered_map< std::string, std::vector< ExtensionFunction >> &sigs, const std::string &json_func_sigs, const bool is_runtime)
static std::unordered_map< std::string, std::vector< ExtensionFunction > > rt_udf_functions_

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

References addCommon(), and udf_functions_.

Referenced by DBHandler::initialize(), and QueryRunner::QueryRunner::QueryRunner().

782  {
783  if (!json_func_sigs.empty()) {
784  addCommon(udf_functions_, json_func_sigs, /* is_runtime */ false);
785  }
786 }
static void addCommon(std::unordered_map< std::string, std::vector< ExtensionFunction >> &sigs, const std::string &json_func_sigs, const bool is_runtime)
static std::unordered_map< std::string, std::vector< ExtensionFunction > > udf_functions_

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void ExtensionFunctionsWhitelist::clearRTUdfs ( )
static

Definition at line 788 of file ExtensionFunctionsWhitelist.cpp.

References rt_udf_functions_.

Referenced by DBHandler::register_runtime_extension_functions().

788  {
789  rt_udf_functions_.clear();
790 }
static std::unordered_map< std::string, std::vector< ExtensionFunction > > rt_udf_functions_

+ 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().

29  {
30  const auto it = functions_.find(to_upper(name));
31  if (it == functions_.end()) {
32  return nullptr;
33  }
34  return &it->second;
35 }
static std::unordered_map< std::string, std::vector< ExtensionFunction > > functions_
std::string to_upper(const std::string &str)
string name
Definition: setup.in.py:72

+ 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().

63  {
64  std::vector<ExtensionFunction> ext_funcs = {};
65  const auto collections = {&functions_, &udf_functions_, &rt_udf_functions_};
66  const auto uname = to_upper(name);
67  for (auto funcs : collections) {
68  const auto it = funcs->find(uname);
69  if (it == funcs->end()) {
70  continue;
71  }
72  auto ext_func_sigs = it->second;
73  std::copy(ext_func_sigs.begin(), ext_func_sigs.end(), std::back_inserter(ext_funcs));
74  }
75  return ext_funcs;
76 }
static std::unordered_map< std::string, std::vector< ExtensionFunction > > udf_functions_
static std::unordered_map< std::string, std::vector< ExtensionFunction > > rt_udf_functions_
static std::unordered_map< std::string, std::vector< ExtensionFunction > > functions_
DEVICE auto copy(ARGS &&...args)
Definition: gpu_enabled.h:51
std::string to_upper(const std::string &str)
string name
Definition: setup.in.py:72

+ 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_.

80  {
81  std::vector<ExtensionFunction> ext_funcs = {};
82  const auto collections = {&functions_, &udf_functions_, &rt_udf_functions_};
83  const auto uname = to_upper(name);
84  for (auto funcs : collections) {
85  const auto it = funcs->find(uname);
86  if (it == funcs->end()) {
87  continue;
88  }
89  auto ext_func_sigs = it->second;
90  std::copy_if(ext_func_sigs.begin(),
91  ext_func_sigs.end(),
92  std::back_inserter(ext_funcs),
93  [is_gpu](auto sig) { return (is_gpu ? sig.isGPU() : sig.isCPU()); });
94  }
95  return ext_funcs;
96 }
static std::unordered_map< std::string, std::vector< ExtensionFunction > > udf_functions_
static std::unordered_map< std::string, std::vector< ExtensionFunction > > rt_udf_functions_
static std::unordered_map< std::string, std::vector< ExtensionFunction > > functions_
std::string to_upper(const std::string &str)
string name
Definition: setup.in.py:72

+ 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_.

100  {
101  std::vector<ExtensionFunction> ext_funcs = {};
102  const auto collections = {&functions_, &udf_functions_, &rt_udf_functions_};
103  const auto uname = to_upper(name);
104  for (auto funcs : collections) {
105  const auto it = funcs->find(uname);
106  if (it == funcs->end()) {
107  continue;
108  }
109  auto ext_func_sigs = it->second;
110  std::copy_if(ext_func_sigs.begin(),
111  ext_func_sigs.end(),
112  std::back_inserter(ext_funcs),
113  [arity](auto sig) { return arity == sig.getInputArgs().size(); });
114  }
115  return ext_funcs;
116 }
static std::unordered_map< std::string, std::vector< ExtensionFunction > > udf_functions_
static std::unordered_map< std::string, std::vector< ExtensionFunction > > rt_udf_functions_
static std::unordered_map< std::string, std::vector< ExtensionFunction > > functions_
std::string to_upper(const std::string &str)
string name
Definition: setup.in.py:72

+ 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_.

121  {
122  std::vector<ExtensionFunction> ext_funcs = {};
123  const auto collections = {&functions_, &udf_functions_, &rt_udf_functions_};
124  const auto uname = to_upper(name);
125  for (auto funcs : collections) {
126  const auto it = funcs->find(uname);
127  if (it == funcs->end()) {
128  continue;
129  }
130  auto ext_func_sigs = it->second;
131  std::copy_if(ext_func_sigs.begin(),
132  ext_func_sigs.end(),
133  std::back_inserter(ext_funcs),
134  [arity, rtype](auto sig) {
135  // Ideally, arity should be equal to the number of
136  // sig arguments but there seems to be many cases
137  // where some sig arguments will be represented
138  // with multiple arguments, for instance, array
139  // argument is translated to data pointer and array
140  // size arguments.
141  if (arity > sig.getInputArgs().size()) {
142  return false;
143  }
144  auto rt = rtype.get_type();
145  auto st = ext_arg_type_to_type_info(sig.getRet()).get_type();
146  return (st == rt || (st == kTINYINT && rt == kBOOLEAN));
147  });
148  }
149  return ext_funcs;
150 }
static std::unordered_map< std::string, std::vector< ExtensionFunction > > udf_functions_
static std::unordered_map< std::string, std::vector< ExtensionFunction > > rt_udf_functions_
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:329
static std::unordered_map< std::string, std::vector< ExtensionFunction > > functions_
std::string to_upper(const std::string &str)
string name
Definition: setup.in.py:72
SQLTypeInfo ext_arg_type_to_type_info(const ExtArgumentType ext_arg_type)

+ 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_.

38  {
39  const auto it = udf_functions_.find(to_upper(name));
40  if (it == udf_functions_.end()) {
41  return nullptr;
42  }
43  return &it->second;
44 }
static std::unordered_map< std::string, std::vector< ExtensionFunction > > udf_functions_
std::string to_upper(const std::string &str)
string name
Definition: setup.in.py:72

+ 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().

48  {
49  std::unordered_set<std::string> names;
50  const auto collections = {&functions_, &udf_functions_, &rt_udf_functions_};
51  for (auto funcs : collections) {
52  for (auto& pair : *funcs) {
53  ExtensionFunction udf = pair.second.at(0);
54  if (udf.isRuntime() == is_runtime) {
55  names.insert(udf.getName(/* keep_suffix */ false));
56  }
57  }
58  }
59  return names;
60 }
static std::unordered_map< std::string, std::vector< ExtensionFunction > > udf_functions_
static std::unordered_map< std::string, std::vector< ExtensionFunction > > rt_udf_functions_
const std::string getName(bool keep_suffix=true) const
static std::unordered_map< std::string, std::vector< ExtensionFunction > > functions_

+ 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 528 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().

530  {
531  std::vector<std::string> declarations;
532  for (const auto& kv : functions_) {
533  const auto& signatures = kv.second;
534  CHECK(!signatures.empty());
535  for (const auto& signature : kv.second) {
536  // If there is a udf function declaration matching an extension function signature
537  // do not emit a duplicate declaration.
538  if (!udf_decls.empty() && udf_decls.find(signature.getName()) != udf_decls.end()) {
539  continue;
540  }
541 
542  std::string decl_prefix;
543  std::vector<std::string> arg_strs;
544 
545  if (is_ext_arg_type_array(signature.getRet())) {
546  decl_prefix = "declare void @" + signature.getName();
547  arg_strs.emplace_back(
548  serialize_type(signature.getRet(), /* byval */ true, /* declare */ true));
549  } else {
550  decl_prefix =
551  "declare " +
552  serialize_type(signature.getRet(), /* byval */ true, /* declare */ true) +
553  " @" + signature.getName();
554  }
555  for (const auto arg : signature.getInputArgs()) {
556  arg_strs.push_back(serialize_type(arg, /* byval */ false, /* declare */ true));
557  }
558  declarations.push_back(decl_prefix + "(" + boost::algorithm::join(arg_strs, ", ") +
559  ");");
560  }
561  }
562 
564  if (kv.second.isRuntime() || kv.second.useDefaultSizer()) {
565  // Runtime UDTFs are defined in LLVM/NVVM IR module
566  // UDTFs using default sizer share LLVM IR
567  continue;
568  }
569  if (!((is_gpu && kv.second.isGPU()) || (!is_gpu && kv.second.isCPU()))) {
570  continue;
571  }
572  std::string decl_prefix{
573  "declare " +
574  serialize_type(ExtArgumentType::Int32, /* byval */ true, /* declare */ true) +
575  " @" + kv.first};
576  std::vector<std::string> arg_strs;
577  for (const auto arg : kv.second.getArgs(/* ensure_column = */ true)) {
578  arg_strs.push_back(
579  serialize_type(arg, /* byval= */ kv.second.isRuntime(), /* declare= */ true));
580  }
581  declarations.push_back(decl_prefix + "(" + boost::algorithm::join(arg_strs, ", ") +
582  ");");
583  }
584  return declarations;
585 }
std::string join(T const &container, std::string const &delim)
static std::unordered_map< std::string, std::vector< ExtensionFunction > > functions_
bool is_ext_arg_type_array(const ExtArgumentType ext_arg_type)
std::string serialize_type(const ExtArgumentType type, bool byval=true, bool declare=false)
#define CHECK(condition)
Definition: Logger.h:222
static std::unordered_map< std::string, TableFunction > functions_

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

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::getArgTypes(), table_functions::TableFunction::getSignature(), anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_arguments(), ExtensionFunction::toSignature(), ExtensionFunction::toString(), toString(), and table_functions::TableFunction::toString().

354  {
355  std::string r = "";
356  for (auto sig : ext_funcs) {
357  r += tab + sig.toString() + "\n";
358  }
359  return r;
360 }

+ Here is the caller graph for this function:

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

Definition at line 362 of file ExtensionFunctionsWhitelist.cpp.

363  {
364  std::string r = "";
365  for (auto sig = arg_types.begin(); sig != arg_types.end();) {
366  r += sig->get_type_name();
367  sig++;
368  if (sig != arg_types.end()) {
369  r += ", ";
370  }
371  }
372  return r;
373 }
std::string ExtensionFunctionsWhitelist::toString ( const std::vector< ExtArgumentType > &  sig_types)
static

Definition at line 375 of file ExtensionFunctionsWhitelist.cpp.

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

376  {
377  std::string r = "";
378  for (auto t = sig_types.begin(); t != sig_types.end();) {
379  r += serialize_type(*t, /* byval */ false, /* declare */ false);
380  t++;
381  if (t != sig_types.end()) {
382  r += ", ";
383  }
384  }
385  return r;
386 }
std::string serialize_type(const ExtArgumentType type, bool byval=true, bool declare=false)

+ Here is the call graph for this function:

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

Definition at line 401 of file ExtensionFunctionsWhitelist.cpp.

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

401  {
402  return serialize_type(sig_type, /* byval */ false, /* declare */ false);
403 }
std::string serialize_type(const ExtArgumentType type, bool byval=true, bool declare=false)

+ Here is the call graph for this function:

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

Definition at line 388 of file ExtensionFunctionsWhitelist.cpp.

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

389  {
390  std::string r = "";
391  for (auto t = sig_types.begin(); t != sig_types.end();) {
393  t++;
394  if (t != sig_types.end()) {
395  r += ", ";
396  }
397  }
398  return r;
399 }
static std::string toStringSQL(const std::vector< ExtArgumentType > &sig_types)

+ Here is the caller graph for this function:

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

Definition at line 405 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, ColumnListTextEncodingDict, ColumnTextEncodingDict, ColumnTimestamp, Cursor, Double, Float, GeoLineString, GeoMultiPolygon, GeoPoint, GeoPolygon, Int16, Int32, Int64, Int8, PBool, PDouble, PFloat, PInt16, PInt32, PInt64, PInt8, TextEncodingDict, TextEncodingNone, Timestamp, UNREACHABLE, and Void.

405  {
406  switch (sig_type) {
408  return "TINYINT";
410  return "SMALLINT";
412  return "INTEGER";
414  return "BIGINT";
416  return "FLOAT";
418  return "DOUBLE";
420  return "BOOLEAN";
422  return "TINYINT[]";
424  return "SMALLINT[]";
426  return "INT[]";
428  return "BIGINT[]";
430  return "FLOAT[]";
432  return "DOUBLE[]";
434  return "BOOLEAN[]";
436  return "ARRAY<TINYINT>";
438  return "ARRAY<SMALLINT>";
440  return "ARRAY<INT>";
442  return "ARRAY<BIGINT>";
444  return "ARRAY<FLOAT>";
446  return "ARRAY<DOUBLE>";
448  return "ARRAY<BOOLEAN>";
450  return "COLUMN<TINYINT>";
452  return "COLUMN<SMALLINT>";
454  return "COLUMN<INT>";
456  return "COLUMN<BIGINT>";
458  return "COLUMN<FLOAT>";
460  return "COLUMN<DOUBLE>";
462  return "COLUMN<BOOLEAN>";
464  return "COLUMN<TEXT ENCODING DICT>";
466  return "COLUMN<TIMESTAMP(9)>";
468  return "CURSOR";
470  return "POINT";
472  return "LINESTRING";
474  return "POLYGON";
476  return "MULTIPOLYGON";
478  return "VOID";
480  return "TEXT ENCODING NONE";
482  return "TEXT ENCODING DICT";
484  return "TIMESTAMP(9)";
486  return "COLUMNLIST<TINYINT>";
488  return "COLUMNLIST<SMALLINT>";
490  return "COLUMNLIST<INT>";
492  return "COLUMNLIST<BIGINT>";
494  return "COLUMNLIST<FLOAT>";
496  return "COLUMNLIST<DOUBLE>";
498  return "COLUMNLIST<BOOLEAN>";
500  return "COLUMNLIST<TEXT ENCODING DICT>";
501  default:
502  UNREACHABLE();
503  }
504  return "";
505 }
#define UNREACHABLE()
Definition: Logger.h:266

Member Data Documentation

std::unordered_map< std::string, std::vector< ExtensionFunction > > ExtensionFunctionsWhitelist::functions_
staticprivate
std::unordered_map< std::string, std::vector< ExtensionFunction > > ExtensionFunctionsWhitelist::rt_udf_functions_
staticprivate
std::unordered_map< std::string, std::vector< ExtensionFunction > > ExtensionFunctionsWhitelist::udf_functions_
staticprivate

Definition at line 172 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: