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

Member Function Documentation

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

Definition at line 941 of file ExtensionFunctionsWhitelist.cpp.

References addCommon(), and functions_.

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

941  {
942  // Valid json_func_sigs example:
943  // [
944  // {
945  // "name":"sum",
946  // "ret":"i32",
947  // "args":[
948  // "i32",
949  // "i32"
950  // ]
951  // }
952  // ]
953 
954  addCommon(functions_, json_func_sigs, /* is_runtime */ false);
955 }
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 896 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().

898  {
899  rapidjson::Document func_sigs;
900  func_sigs.Parse(json_func_sigs.c_str());
901  CHECK(func_sigs.IsArray());
902  for (auto func_sigs_it = func_sigs.Begin(); func_sigs_it != func_sigs.End();
903  ++func_sigs_it) {
904  CHECK(func_sigs_it->IsObject());
905  const auto name = json_str(field(*func_sigs_it, "name"));
906  const auto ret = deserialize_type(json_str(field(*func_sigs_it, "ret")));
907  std::vector<ExtArgumentType> args;
908  const auto& args_serialized = field(*func_sigs_it, "args");
909  CHECK(args_serialized.IsArray());
910  for (auto args_serialized_it = args_serialized.Begin();
911  args_serialized_it != args_serialized.End();
912  ++args_serialized_it) {
913  args.push_back(deserialize_type(json_str(*args_serialized_it)));
914  }
915 
916  std::vector<std::map<std::string, std::string>> annotations;
917  const auto& anns = field(*func_sigs_it, "annotations");
918  CHECK(anns.IsArray());
919  static const std::map<std::string, std::string> map_empty = {};
920  for (auto obj = anns.Begin(); obj != anns.End(); ++obj) {
921  CHECK(obj->IsObject());
922  if (obj->ObjectEmpty()) {
923  annotations.push_back(map_empty);
924  } else {
925  std::map<std::string, std::string> m;
926  for (auto kv = obj->MemberBegin(); kv != obj->MemberEnd(); ++kv) {
927  m[kv->name.GetString()] = kv->value.GetString();
928  }
929  annotations.push_back(m);
930  }
931  }
932  signatures[to_upper(drop_suffix(name))].emplace_back(
933  name, args, ret, annotations, is_runtime);
934  }
935 }
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:289
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 967 of file ExtensionFunctionsWhitelist.cpp.

References addCommon(), and rt_udf_functions_.

Referenced by DBHandler::register_runtime_extension_functions().

967  {
968  if (!json_func_sigs.empty()) {
969  addCommon(rt_udf_functions_, json_func_sigs, /* is_runtime */ true);
970  }
971 }
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 957 of file ExtensionFunctionsWhitelist.cpp.

References addCommon(), and udf_functions_.

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

957  {
958  if (!json_func_sigs.empty()) {
959  addCommon(udf_functions_, json_func_sigs, /* is_runtime */ false);
960  }
961 }
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 963 of file ExtensionFunctionsWhitelist.cpp.

References rt_udf_functions_.

Referenced by DBHandler::register_runtime_extension_functions().

963  {
964  rt_udf_functions_.clear();
965 }
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:380
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 615 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().

617  {
618  std::vector<std::string> declarations;
619  for (const auto& kv : functions_) {
620  const std::vector<ExtensionFunction>& ext_funcs = kv.second;
621  CHECK(!ext_funcs.empty());
622  for (const auto& ext_func : ext_funcs) {
623  // If there is a udf function declaration matching an extension function signature
624  // do not emit a duplicate declaration.
625  if (!udf_decls.empty() && udf_decls.find(ext_func.getName()) != udf_decls.end()) {
626  continue;
627  }
628 
629  std::string decl_prefix;
630  std::vector<std::string> arg_strs;
631 
632  if (is_ext_arg_type_array(ext_func.getRet())) {
633  decl_prefix = "declare void @" + ext_func.getName();
634  arg_strs.emplace_back(
635  serialize_type(ext_func.getRet(), /* byval */ true, /* declare */ true));
636  } else {
637  decl_prefix =
638  "declare " +
639  serialize_type(ext_func.getRet(), /* byval */ true, /* declare */ true) +
640  " @" + ext_func.getName();
641  }
642 
643  // if the extension function uses a Row Function Manager, append "i8*" as the first
644  // arg
645  if (ext_func.usesManager()) {
646  arg_strs.emplace_back("i8*");
647  }
648 
649  for (const auto arg : ext_func.getInputArgs()) {
650  arg_strs.emplace_back(serialize_type(arg, /* byval */ false, /* declare */ true));
651  }
652  declarations.emplace_back(decl_prefix + "(" +
653  boost::algorithm::join(arg_strs, ", ") + ");");
654  }
655  }
656 
658  if (kv.second.isRuntime() || kv.second.useDefaultSizer()) {
659  // Runtime UDTFs are defined in LLVM/NVVM IR module
660  // UDTFs using default sizer share LLVM IR
661  continue;
662  }
663  if (!((is_gpu && kv.second.isGPU()) || (!is_gpu && kv.second.isCPU()))) {
664  continue;
665  }
666  std::string decl_prefix{
667  "declare " +
668  serialize_type(ExtArgumentType::Int32, /* byval */ true, /* declare */ true) +
669  " @" + kv.first};
670  std::vector<std::string> arg_strs;
671  for (const auto arg : kv.second.getArgs(/* ensure_column = */ true)) {
672  arg_strs.push_back(
673  serialize_type(arg, /* byval= */ kv.second.isRuntime(), /* declare= */ true));
674  }
675  declarations.push_back(decl_prefix + "(" + boost::algorithm::join(arg_strs, ", ") +
676  ");");
677  }
678  return declarations;
679 }
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:289
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 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().

391  {
392  std::string r = "";
393  for (auto sig : ext_funcs) {
394  r += tab + sig.toString() + "\n";
395  }
396  return r;
397 }

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

400  {
401  std::string r = "";
402  for (auto sig = arg_types.begin(); sig != arg_types.end();) {
403  r += sig->get_type_name();
404  sig++;
405  if (sig != arg_types.end()) {
406  r += ", ";
407  }
408  }
409  return r;
410 }
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().

413  {
414  std::string r = "";
415  for (auto t = sig_types.begin(); t != sig_types.end();) {
416  r += serialize_type(*t, /* byval */ false, /* declare */ false);
417  t++;
418  if (t != sig_types.end()) {
419  r += ", ";
420  }
421  }
422  return r;
423 }
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 438 of file ExtensionFunctionsWhitelist.cpp.

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

438  {
439  return serialize_type(sig_type, /* byval */ false, /* declare */ false);
440 }
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 425 of file ExtensionFunctionsWhitelist.cpp.

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

426  {
427  std::string r = "";
428  for (auto t = sig_types.begin(); t != sig_types.end();) {
430  t++;
431  if (t != sig_types.end()) {
432  r += ", ";
433  }
434  }
435  return r;
436 }
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 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.

442  {
443  switch (sig_type) {
445  return "TINYINT";
447  return "SMALLINT";
449  return "INTEGER";
451  return "BIGINT";
453  return "FLOAT";
455  return "DOUBLE";
457  return "BOOLEAN";
459  return "TINYINT[]";
461  return "SMALLINT[]";
463  return "INT[]";
465  return "BIGINT[]";
467  return "FLOAT[]";
469  return "DOUBLE[]";
471  return "BOOLEAN[]";
473  return "ARRAY<TINYINT>";
475  return "ARRAY<SMALLINT>";
477  return "ARRAY<INT>";
479  return "ARRAY<BIGINT>";
481  return "ARRAY<FLOAT>";
483  return "ARRAY<DOUBLE>";
485  return "ARRAY<BOOLEAN>";
487  return "ARRAY<TEXT ENCODING DICT>";
489  return "COLUMN<TINYINT>";
491  return "COLUMN<SMALLINT>";
493  return "COLUMN<INT>";
495  return "COLUMN<BIGINT>";
497  return "COLUMN<FLOAT>";
499  return "COLUMN<DOUBLE>";
501  return "COLUMN<BOOLEAN>";
503  return "COLUMN<TEXT ENCODING DICT>";
505  return "COLUMN<TIMESTAMP(9)>";
507  return "CURSOR";
509  return "POINT";
511  return "MULTIPOINT";
513  return "LINESTRING";
515  return "MULTILINESTRING";
517  return "POLYGON";
519  return "MULTIPOLYGON";
521  return "VOID";
523  return "TEXT ENCODING NONE";
525  return "TEXT ENCODING DICT";
527  return "TIMESTAMP(9)";
529  return "COLUMNLIST<TINYINT>";
531  return "COLUMNLIST<SMALLINT>";
533  return "COLUMNLIST<INT>";
535  return "COLUMNLIST<BIGINT>";
537  return "COLUMNLIST<FLOAT>";
539  return "COLUMNLIST<DOUBLE>";
541  return "COLUMNLIST<BOOLEAN>";
543  return "COLUMNLIST<TEXT ENCODING DICT>";
545  return "COLUMN<ARRAY<TINYINT>>";
547  return "COLUMN<ARRAY<SMALLINT>>";
549  return "COLUMN<ARRAY<INT>>";
551  return "COLUMN<ARRAY<BIGINT>>";
553  return "COLUMN<ARRAY<FLOAT>>";
555  return "COLUMN<ARRAY<DOUBLE>>";
557  return "COLUMN<ARRAY<BOOLEAN>>";
559  return "COLUMN<ARRAY<TEXT ENCODING DICT>>";
561  return "COLUMNLIST<ARRAY<TINYINT>>";
563  return "COLUMNLIST<ARRAY<SMALLINT>>";
565  return "COLUMNLIST<ARRAY<INT>>";
567  return "COLUMNLIST<ARRAY<BIGINT>>";
569  return "COLUMNLIST<ARRAY<FLOAT>>";
571  return "COLUMNLIST<ARRAY<DOUBLE>>";
573  return "COLUMNLIST<ARRAY<BOOLEAN>>";
575  return "COLUMNLIST<ARRAY<TEXT ENCODING DICT>>";
577  return "DAY TIME INTERVAL";
579  return "YEAR MONTH INTERVAL";
580  default:
581  UNREACHABLE();
582  }
583  return "";
584 }
#define UNREACHABLE()
Definition: Logger.h:333

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 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: