OmniSciDB  a5dc49c757
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
ExtensionFunctionsWhitelist.cpp
Go to the documentation of this file.
1 /*
2  * Copyright 2022 HEAVY.AI, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "QueryEngine/ExtensionFunctionsWhitelist.h"
18 
19 #include <boost/algorithm/string/join.hpp>
20 #include <iostream>
21 
22 #include "QueryEngine/ExtensionFunctionsBinding.h"
23 #include "QueryEngine/JsonAccessors.h"
24 #include "QueryEngine/TableFunctions/TableFunctionsFactory.h"
25 #include "Shared/StringTransform.h"
26 
27 // Get the list of all type specializations for the given function name.
28 std::vector<ExtensionFunction>* ExtensionFunctionsWhitelist::get(
29  const std::string& name) {
30  const auto it = functions_.find(to_upper(name));
31  if (it == functions_.end()) {
32  return nullptr;
33  }
34  return &it->second;
35 }
36 
37 std::vector<ExtensionFunction>* ExtensionFunctionsWhitelist::get_udf(
38  const std::string& name) {
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 }
45 
46 // Get the list of all udfs
47 std::unordered_set<std::string> ExtensionFunctionsWhitelist::get_udfs_name(
48  const bool is_runtime) {
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 }
61 
62 std::vector<ExtensionFunction> ExtensionFunctionsWhitelist::get_ext_funcs(
63  const std::string& name) {
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 }
77 
78 std::vector<ExtensionFunction> ExtensionFunctionsWhitelist::get_ext_funcs(
79  const std::string& name,
80  const bool is_gpu) {
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 }
97 
98 std::vector<ExtensionFunction> ExtensionFunctionsWhitelist::get_ext_funcs(
99  const std::string& name,
100  size_t arity) {
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 }
117 
118 std::vector<ExtensionFunction> ExtensionFunctionsWhitelist::get_ext_funcs(
119  const std::string& name,
120  size_t arity,
121  const SQLTypeInfo& rtype) {
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 }
151 
152 namespace {
153 
154 // Returns the LLVM name for `type`.
155 std::string serialize_type(const ExtArgumentType type,
156  bool byval = true,
157  bool declare = false) {
158  switch (type) {
159  case ExtArgumentType::Bool:
160  return "i8"; // clang converts bool to i8
161  case ExtArgumentType::Int8:
162  return "i8";
163  case ExtArgumentType::Int16:
164  return "i16";
165  case ExtArgumentType::Int32:
166  return "i32";
167  case ExtArgumentType::Int64:
168  return "i64";
169  case ExtArgumentType::Float:
170  return "float";
171  case ExtArgumentType::Double:
172  return "double";
173  case ExtArgumentType::Void:
174  return "void";
175  case ExtArgumentType::PInt8:
176  return "i8*";
177  case ExtArgumentType::PInt16:
178  return "i16*";
179  case ExtArgumentType::PInt32:
180  return "i32*";
181  case ExtArgumentType::PInt64:
182  return "i64*";
183  case ExtArgumentType::PFloat:
184  return "float*";
185  case ExtArgumentType::PDouble:
186  return "double*";
187  case ExtArgumentType::PBool:
188  return "i1*";
189  case ExtArgumentType::ArrayInt8:
190  return (declare ? "{i8*, i64, i8}*" : "Array<i8>");
191  case ExtArgumentType::ArrayInt16:
192  return (declare ? "{i16*, i64, i8}*" : "Array<i16>");
193  case ExtArgumentType::ArrayInt32:
194  return (declare ? "{i32*, i64, i8}*" : "Array<i32>");
195  case ExtArgumentType::ArrayInt64:
196  return (declare ? "{i64*, i64, i8}*" : "Array<i64>");
197  case ExtArgumentType::ArrayFloat:
198  return (declare ? "{float*, i64, i8}*" : "Array<float>");
199  case ExtArgumentType::ArrayDouble:
200  return (declare ? "{double*, i64, i8}*" : "Array<double>");
201  case ExtArgumentType::ArrayBool:
202  return (declare ? "{i1*, i64, i8}*" : "Array<i1>");
203  case ExtArgumentType::ArrayTextEncodingDict:
204  return (declare ? "{i32*, i64, i8}*" : "Array<TextEncodingDict>");
205  case ExtArgumentType::GeoPoint:
206  return (declare ? "{i8*, i32, i32, i32, i32}*" : "GeoPoint");
207  case ExtArgumentType::GeoMultiPoint:
208  return (declare ? "{i8*, i32, i32, i32, i32}*" : "GeoMultiPoint");
209  case ExtArgumentType::GeoLineString:
210  return (declare ? "{i8*, i32, i32, i32, i32}*" : "GeoLineString");
211  case ExtArgumentType::GeoMultiLineString:
212  return (declare ? "{i8*, i32, i8*, i32, i32, i32, i32}*" : "GeoMultiLineSting");
213  case ExtArgumentType::GeoPolygon:
214  return (declare ? "{i8*, i32, i8*, i32, i32, i32, i32}*" : "GeoPolygon");
215  case ExtArgumentType::GeoMultiPolygon:
216  return (declare ? "{i8*, i32, i8*, i32, i8*, i32, i32, i32, i32}*"
217  : "GeoMultiPolygon");
218  case ExtArgumentType::Cursor:
219  return "cursor";
220  case ExtArgumentType::ColumnInt8:
221  return (declare ? (byval ? "{i8*, i64}" : "i8*") : "Column<i8>");
222  case ExtArgumentType::ColumnInt16:
223  return (declare ? (byval ? "{i16*, i64}" : "i8*") : "Column<i16>");
224  case ExtArgumentType::ColumnInt32:
225  return (declare ? (byval ? "{i32*, i64}" : "i8*") : "Column<i32>");
226  case ExtArgumentType::ColumnInt64:
227  return (declare ? (byval ? "{i64*, i64}" : "i8*") : "Column<i64>");
228  case ExtArgumentType::ColumnFloat:
229  return (declare ? (byval ? "{float*, i64}" : "i8*") : "Column<float>");
230  case ExtArgumentType::ColumnDouble:
231  return (declare ? (byval ? "{double*, i64}" : "i8*") : "Column<double>");
232  case ExtArgumentType::ColumnBool:
233  return (declare ? (byval ? "{i8*, i64}" : "i8*") : "Column<bool>");
234  case ExtArgumentType::ColumnTextEncodingDict:
235  return (declare ? (byval ? "{i32*, i64}" : "i8*") : "Column<TextEncodingDict>");
236  case ExtArgumentType::ColumnTimestamp:
237  return (declare ? (byval ? "{i64*, i64}" : "i8*") : "Column<Timestamp>");
238  case ExtArgumentType::TextEncodingNone:
239  return (declare ? (byval ? "{i8*, i64}" : "i8*") : "TextEncodingNone");
240  case ExtArgumentType::TextEncodingDict:
241  return (declare ? "{ i32 }" : "TextEncodingDict");
242  case ExtArgumentType::Timestamp:
243  return (declare ? "{ i64 }" : "Timestamp");
244  case ExtArgumentType::ColumnListInt8:
245  return (declare ? "{i8**, i64, i64}*" : "ColumnList<i8>");
246  case ExtArgumentType::ColumnListInt16:
247  return (declare ? "{i8**, i64, i64}*" : "ColumnList<i16>");
248  case ExtArgumentType::ColumnListInt32:
249  return (declare ? "{i8**, i64, i64}*" : "ColumnList<i32>");
250  case ExtArgumentType::ColumnListInt64:
251  return (declare ? "{i8**, i64, i64}*" : "ColumnList<i64>");
252  case ExtArgumentType::ColumnListFloat:
253  return (declare ? "{i8**, i64, i64}*" : "ColumnList<float>");
254  case ExtArgumentType::ColumnListDouble:
255  return (declare ? "{i8**, i64, i64}*" : "ColumnList<double>");
256  case ExtArgumentType::ColumnListBool:
257  return (declare ? "{i8**, i64, i64}*" : "ColumnList<bool>");
258  case ExtArgumentType::ColumnListTextEncodingDict:
259  return (declare ? "{i8**, i64, i64}*" : "ColumnList<TextEncodingDict>");
260  case ExtArgumentType::ColumnArrayInt8:
261  return (declare ? "{i8*, i64}*" : "Column<Array<i8>>");
262  case ExtArgumentType::ColumnArrayInt16:
263  return (declare ? "{i8*, i64}*" : "Column<Array<i16>>");
264  case ExtArgumentType::ColumnArrayInt32:
265  return (declare ? "{i8*, i64}*" : "Column<Array<i32>>");
266  case ExtArgumentType::ColumnArrayInt64:
267  return (declare ? "{i8*, i64}*" : "Column<Array<i64>>");
268  case ExtArgumentType::ColumnArrayFloat:
269  return (declare ? "{i8*, i64}*" : "Column<Array<float>>");
270  case ExtArgumentType::ColumnArrayDouble:
271  return (declare ? "{i8*, i64}*" : "Column<Array<double>>");
272  case ExtArgumentType::ColumnArrayBool:
273  return (declare ? "{i8*, i64}*" : "Column<Array<bool>>");
274  case ExtArgumentType::ColumnArrayTextEncodingDict:
275  return (declare ? "{i8*, i64}" : "Column<Array<TextEncodingDict>>");
276  case ExtArgumentType::ColumnListArrayInt8:
277  return (declare ? "{i8**, i64, i64}*" : "ColumnListArray<i8>");
278  case ExtArgumentType::ColumnListArrayInt16:
279  return (declare ? "{i8**, i64, i64}*" : "ColumnListArray<i16>");
280  case ExtArgumentType::ColumnListArrayInt32:
281  return (declare ? "{i8**, i64, i64}*" : "ColumnListArray<i32>");
282  case ExtArgumentType::ColumnListArrayInt64:
283  return (declare ? "{i8**, i64, i64}*" : "ColumnListArray<i64>");
284  case ExtArgumentType::ColumnListArrayFloat:
285  return (declare ? "{i8**, i64, i64}*" : "ColumnListArray<float>");
286  case ExtArgumentType::ColumnListArrayDouble:
287  return (declare ? "{i8**, i64, i64}*" : "ColumnListArray<double>");
288  case ExtArgumentType::ColumnListArrayBool:
289  return (declare ? "{i8**, i64, i64}*" : "ColumnListArray<bool>");
290  case ExtArgumentType::ColumnListArrayTextEncodingDict:
291  return (declare ? "{i8**, i64, i64}" : "ColumnList<Array<TextEncodingDict>>");
292  case ExtArgumentType::DayTimeInterval:
293  return (declare ? "{ i64 }" : "DayTimeInterval");
294  case ExtArgumentType::YearMonthTimeInterval:
295  return (declare ? "{ i64 }" : "YearMonthTimeInterval");
296  case ExtArgumentType::ColumnGeoPoint:
297  return (declare ? "{i8*, i64}*" : "Column<GeoPoint>");
298  case ExtArgumentType::ColumnGeoLineString:
299  return (declare ? "{i8*, i64}*" : "Column<GeoLineString>");
300  case ExtArgumentType::ColumnGeoPolygon:
301  return (declare ? "{i8*, i64}*" : "Column<GeoPolygon>");
302  case ExtArgumentType::ColumnGeoMultiPoint:
303  return (declare ? "{i8*, i64}*" : "Column<GeoMultiPoint>");
304  case ExtArgumentType::ColumnGeoMultiLineString:
305  return (declare ? "{i8*, i64}*" : "Column<GeoMultiLineString>");
306  case ExtArgumentType::ColumnGeoMultiPolygon:
307  return (declare ? "{i8*, i64}*" : "Column<GeoMultiPolygon>");
308  case ExtArgumentType::ColumnListGeoPoint:
309  return (declare ? "{i8*, i64, i64}*" : "ColumnList<GeoPoint>");
310  case ExtArgumentType::ColumnListGeoLineString:
311  return (declare ? "{i8*, i64, i64}*" : "ColumnList<GeoLineString>");
312  case ExtArgumentType::ColumnListGeoPolygon:
313  return (declare ? "{i8*, i64, i64}*" : "ColumnList<GeoPolygon>");
314  case ExtArgumentType::ColumnListGeoMultiPoint:
315  return (declare ? "{i8*, i64, i64}*" : "ColumnList<GeoMultiPoint>");
316  case ExtArgumentType::ColumnListGeoMultiLineString:
317  return (declare ? "{i8*, i64, i64}*" : "ColumnList<GeoMultiLineString>");
318  case ExtArgumentType::ColumnListGeoMultiPolygon:
319  return (declare ? "{i8*, i64, i64}*" : "ColumnList<GeoMultiPolygon>");
320  case ExtArgumentType::ColumnTextEncodingNone:
321  return (declare ? "{i8*, i64}*" : "Column<TextEncodingNone>");
322  case ExtArgumentType::ColumnArrayTextEncodingNone:
323  return (declare ? "{i8*, i64}*" : "Column<Array<TextEncodingNone>>");
324  case ExtArgumentType::ColumnListTextEncodingNone:
325  return (declare ? "{i8*, i64, i64}*" : "ColumnList<TextEncodingNone>");
326  case ExtArgumentType::ColumnListArrayTextEncodingNone:
327  return (declare ? "{i8*, i64, i64}*" : "ColumnList<Array<TextEncodingNone>>");
328  default:
329  CHECK(false);
330  }
331  CHECK(false);
332  return "";
333 }
334 
335 std::string drop_suffix(const std::string& str) {
336  const auto idx = str.find("__");
337  if (idx == std::string::npos) {
338  return str;
339  }
340  CHECK_GT(idx, std::string::size_type(0));
341  return str.substr(0, idx);
342 }
343 
344 } // namespace
345 
346 SQLTypeInfo ext_arg_type_to_type_info(const ExtArgumentType ext_arg_type) {
347  SQLTypes type = kNULLT;
348  int d = 0;
349  int s = 0;
350  bool n = false;
351  EncodingType c = kENCODING_NONE;
352  int p = 0;
353  SQLTypes subtype = kNULLT;
354 
355 #define EXTARGTYPECASE(EXTARGTYPE, ELEMTYPE, ENCODING, ARRAYENCODING) \
356  case ExtArgumentType::EXTARGTYPE: \
357  type = ELEMTYPE; \
358  c = kENCODING_##ENCODING; \
359  break; \
360  case ExtArgumentType::Array##EXTARGTYPE: \
361  type = kARRAY; \
362  c = kENCODING_##ENCODING; \
363  subtype = ELEMTYPE; \
364  n = true; \
365  break; \
366  case ExtArgumentType::Column##EXTARGTYPE: \
367  type = kCOLUMN; \
368  c = kENCODING_##ENCODING; \
369  subtype = ELEMTYPE; \
370  break; \
371  case ExtArgumentType::ColumnList##EXTARGTYPE: \
372  type = kCOLUMN_LIST; \
373  c = kENCODING_##ENCODING; \
374  subtype = ELEMTYPE; \
375  break; \
376  case ExtArgumentType::ColumnArray##EXTARGTYPE: \
377  type = kCOLUMN; \
378  subtype = ELEMTYPE; \
379  c = kENCODING_##ARRAYENCODING; \
380  break; \
381  case ExtArgumentType::ColumnListArray##EXTARGTYPE: \
382  type = kCOLUMN_LIST; \
383  subtype = ELEMTYPE; \
384  c = kENCODING_##ARRAYENCODING; \
385  break;
386 
387 #define EXTARGGEOTYPECASE(GEOTYPE, KTYPE) \
388  case ExtArgumentType::Geo##GEOTYPE: \
389  type = KTYPE; \
390  subtype = kGEOMETRY; \
391  break; \
392  case ExtArgumentType::ColumnGeo##GEOTYPE: \
393  type = kCOLUMN; \
394  subtype = KTYPE; \
395  break; \
396  case ExtArgumentType::ColumnListGeo##GEOTYPE: \
397  type = kCOLUMN_LIST; \
398  subtype = KTYPE; \
399  break;
400 
401  switch (ext_arg_type) {
402  EXTARGTYPECASE(Bool, kBOOLEAN, NONE, ARRAY);
403  EXTARGTYPECASE(Int8, kTINYINT, NONE, ARRAY);
404  EXTARGTYPECASE(Int16, kSMALLINT, NONE, ARRAY);
405  EXTARGTYPECASE(Int32, kINT, NONE, ARRAY);
406  EXTARGTYPECASE(Int64, kBIGINT, NONE, ARRAY);
407  EXTARGTYPECASE(Float, kFLOAT, NONE, ARRAY);
408  EXTARGTYPECASE(Double, kDOUBLE, NONE, ARRAY);
409  EXTARGTYPECASE(TextEncodingNone, kTEXT, NONE, ARRAY);
410  EXTARGTYPECASE(TextEncodingDict, kTEXT, DICT, ARRAY_DICT);
411  // TODO: EXTARGTYPECASE(Timestamp, kTIMESTAMP, NONE, ARRAY);
412  case ExtArgumentType::Timestamp:
413  type = kTIMESTAMP;
414  c = kENCODING_NONE;
415  d = 9;
416  break;
417  case ExtArgumentType::ColumnTimestamp:
418  type = kCOLUMN;
419  subtype = kTIMESTAMP;
420  c = kENCODING_NONE;
421  d = 9;
422  break;
423  case ExtArgumentType::DayTimeInterval:
424  type = kINTERVAL_DAY_TIME;
425  break;
426  case ExtArgumentType::YearMonthTimeInterval:
427  type = kINTERVAL_YEAR_MONTH;
428  break;
429  EXTARGGEOTYPECASE(Point, kPOINT);
430  EXTARGGEOTYPECASE(LineString, kLINESTRING);
431  EXTARGGEOTYPECASE(Polygon, kPOLYGON);
432  EXTARGGEOTYPECASE(MultiPoint, kMULTIPOINT);
433  EXTARGGEOTYPECASE(MultiLineString, kMULTILINESTRING);
434  EXTARGGEOTYPECASE(MultiPolygon, kMULTIPOLYGON);
435  default:
436  LOG(FATAL) << "ExtArgumentType `" << serialize_type(ext_arg_type)
437  << "` cannot be converted to SQLTypes.";
438  UNREACHABLE();
439  }
440  return SQLTypeInfo(type, d, s, n, c, p, subtype);
441 }
442 
443 std::string ExtensionFunctionsWhitelist::toString(
444  const std::vector<ExtensionFunction>& ext_funcs,
445  std::string tab) {
446  std::string r = "";
447  for (auto sig : ext_funcs) {
448  r += tab + sig.toString() + "\n";
449  }
450  return r;
451 }
452 
453 std::string ExtensionFunctionsWhitelist::toString(
454  const std::vector<SQLTypeInfo>& arg_types) {
455  std::string r = "";
456  for (auto sig = arg_types.begin(); sig != arg_types.end();) {
457  r += sig->get_type_name();
458  sig++;
459  if (sig != arg_types.end()) {
460  r += ", ";
461  }
462  }
463  return r;
464 }
465 
466 std::string ExtensionFunctionsWhitelist::toString(
467  const std::vector<ExtArgumentType>& sig_types) {
468  std::string r = "";
469  for (auto t = sig_types.begin(); t != sig_types.end();) {
470  r += serialize_type(*t, /* byval */ false, /* declare */ false);
471  t++;
472  if (t != sig_types.end()) {
473  r += ", ";
474  }
475  }
476  return r;
477 }
478 
479 std::string ExtensionFunctionsWhitelist::toStringSQL(
480  const std::vector<ExtArgumentType>& sig_types) {
481  std::string r = "";
482  for (auto t = sig_types.begin(); t != sig_types.end();) {
483  r += ExtensionFunctionsWhitelist::toStringSQL(*t);
484  t++;
485  if (t != sig_types.end()) {
486  r += ", ";
487  }
488  }
489  return r;
490 }
491 
492 std::string ExtensionFunctionsWhitelist::toString(const ExtArgumentType& sig_type) {
493  return serialize_type(sig_type, /* byval */ false, /* declare */ false);
494 }
495 
496 std::string ExtensionFunctionsWhitelist::toStringSQL(const ExtArgumentType& sig_type) {
497  switch (sig_type) {
498  case ExtArgumentType::Int8:
499  return "TINYINT";
500  case ExtArgumentType::Int16:
501  return "SMALLINT";
502  case ExtArgumentType::Int32:
503  return "INTEGER";
504  case ExtArgumentType::Int64:
505  return "BIGINT";
506  case ExtArgumentType::Float:
507  return "FLOAT";
508  case ExtArgumentType::Double:
509  return "DOUBLE";
510  case ExtArgumentType::Bool:
511  return "BOOLEAN";
512  case ExtArgumentType::PInt8:
513  return "TINYINT[]";
514  case ExtArgumentType::PInt16:
515  return "SMALLINT[]";
516  case ExtArgumentType::PInt32:
517  return "INT[]";
518  case ExtArgumentType::PInt64:
519  return "BIGINT[]";
520  case ExtArgumentType::PFloat:
521  return "FLOAT[]";
522  case ExtArgumentType::PDouble:
523  return "DOUBLE[]";
524  case ExtArgumentType::PBool:
525  return "BOOLEAN[]";
526  case ExtArgumentType::ArrayInt8:
527  return "ARRAY<TINYINT>";
528  case ExtArgumentType::ArrayInt16:
529  return "ARRAY<SMALLINT>";
530  case ExtArgumentType::ArrayInt32:
531  return "ARRAY<INT>";
532  case ExtArgumentType::ArrayInt64:
533  return "ARRAY<BIGINT>";
534  case ExtArgumentType::ArrayFloat:
535  return "ARRAY<FLOAT>";
536  case ExtArgumentType::ArrayDouble:
537  return "ARRAY<DOUBLE>";
538  case ExtArgumentType::ArrayBool:
539  return "ARRAY<BOOLEAN>";
540  case ExtArgumentType::ArrayTextEncodingDict:
541  return "ARRAY<TEXT ENCODING DICT>";
542  case ExtArgumentType::ArrayTextEncodingNone:
543  return "ARRAY<TEXT ENCODING NONE>";
544  case ExtArgumentType::ColumnInt8:
545  return "COLUMN<TINYINT>";
546  case ExtArgumentType::ColumnInt16:
547  return "COLUMN<SMALLINT>";
548  case ExtArgumentType::ColumnInt32:
549  return "COLUMN<INT>";
550  case ExtArgumentType::ColumnInt64:
551  return "COLUMN<BIGINT>";
552  case ExtArgumentType::ColumnFloat:
553  return "COLUMN<FLOAT>";
554  case ExtArgumentType::ColumnDouble:
555  return "COLUMN<DOUBLE>";
556  case ExtArgumentType::ColumnBool:
557  return "COLUMN<BOOLEAN>";
558  case ExtArgumentType::ColumnTextEncodingDict:
559  return "COLUMN<TEXT ENCODING DICT>";
560  case ExtArgumentType::ColumnTextEncodingNone:
561  return "COLUMN<TEXT ENCODING NONE>";
562  case ExtArgumentType::ColumnTimestamp:
563  return "COLUMN<TIMESTAMP(9)>";
564  case ExtArgumentType::Cursor:
565  return "CURSOR";
566  case ExtArgumentType::GeoPoint:
567  return "POINT";
568  case ExtArgumentType::GeoMultiPoint:
569  return "MULTIPOINT";
570  case ExtArgumentType::GeoLineString:
571  return "LINESTRING";
572  case ExtArgumentType::GeoMultiLineString:
573  return "MULTILINESTRING";
574  case ExtArgumentType::GeoPolygon:
575  return "POLYGON";
576  case ExtArgumentType::GeoMultiPolygon:
577  return "MULTIPOLYGON";
578  case ExtArgumentType::Void:
579  return "VOID";
580  case ExtArgumentType::TextEncodingNone:
581  return "TEXT ENCODING NONE";
582  case ExtArgumentType::TextEncodingDict:
583  return "TEXT ENCODING DICT";
584  case ExtArgumentType::Timestamp:
585  return "TIMESTAMP(9)";
586  case ExtArgumentType::ColumnListInt8:
587  return "COLUMNLIST<TINYINT>";
588  case ExtArgumentType::ColumnListInt16:
589  return "COLUMNLIST<SMALLINT>";
590  case ExtArgumentType::ColumnListInt32:
591  return "COLUMNLIST<INT>";
592  case ExtArgumentType::ColumnListInt64:
593  return "COLUMNLIST<BIGINT>";
594  case ExtArgumentType::ColumnListFloat:
595  return "COLUMNLIST<FLOAT>";
596  case ExtArgumentType::ColumnListDouble:
597  return "COLUMNLIST<DOUBLE>";
598  case ExtArgumentType::ColumnListBool:
599  return "COLUMNLIST<BOOLEAN>";
600  case ExtArgumentType::ColumnListTextEncodingDict:
601  return "COLUMNLIST<TEXT ENCODING DICT>";
602  case ExtArgumentType::ColumnListTextEncodingNone:
603  return "COLUMNLIST<TEXT ENCODING NONE>";
604  case ExtArgumentType::ColumnArrayInt8:
605  return "COLUMN<ARRAY<TINYINT>>";
606  case ExtArgumentType::ColumnArrayInt16:
607  return "COLUMN<ARRAY<SMALLINT>>";
608  case ExtArgumentType::ColumnArrayInt32:
609  return "COLUMN<ARRAY<INT>>";
610  case ExtArgumentType::ColumnArrayInt64:
611  return "COLUMN<ARRAY<BIGINT>>";
612  case ExtArgumentType::ColumnArrayFloat:
613  return "COLUMN<ARRAY<FLOAT>>";
614  case ExtArgumentType::ColumnArrayDouble:
615  return "COLUMN<ARRAY<DOUBLE>>";
616  case ExtArgumentType::ColumnArrayBool:
617  return "COLUMN<ARRAY<BOOLEAN>>";
618  case ExtArgumentType::ColumnArrayTextEncodingDict:
619  return "COLUMN<ARRAY<TEXT ENCODING DICT>>";
620  case ExtArgumentType::ColumnArrayTextEncodingNone:
621  return "COLUMN<ARRAY<TEXT ENCODING NONE>>";
622  case ExtArgumentType::ColumnListArrayInt8:
623  return "COLUMNLIST<ARRAY<TINYINT>>";
624  case ExtArgumentType::ColumnListArrayInt16:
625  return "COLUMNLIST<ARRAY<SMALLINT>>";
626  case ExtArgumentType::ColumnListArrayInt32:
627  return "COLUMNLIST<ARRAY<INT>>";
628  case ExtArgumentType::ColumnListArrayInt64:
629  return "COLUMNLIST<ARRAY<BIGINT>>";
630  case ExtArgumentType::ColumnListArrayFloat:
631  return "COLUMNLIST<ARRAY<FLOAT>>";
632  case ExtArgumentType::ColumnListArrayDouble:
633  return "COLUMNLIST<ARRAY<DOUBLE>>";
634  case ExtArgumentType::ColumnListArrayBool:
635  return "COLUMNLIST<ARRAY<BOOLEAN>>";
636  case ExtArgumentType::ColumnListArrayTextEncodingDict:
637  return "COLUMNLIST<ARRAY<TEXT ENCODING DICT>>";
638  case ExtArgumentType::ColumnListArrayTextEncodingNone:
639  return "COLUMNLIST<ARRAY<TEXT ENCODING NONE>>";
640  case ExtArgumentType::DayTimeInterval:
641  return "DAY TIME INTERVAL";
642  case ExtArgumentType::YearMonthTimeInterval:
643  return "YEAR MONTH INTERVAL";
644  case ExtArgumentType::ColumnGeoPoint:
645  return "COLUMN<GEOPOINT>";
646  case ExtArgumentType::ColumnGeoLineString:
647  return "COLUMN<GEOLINESTRING>";
648  case ExtArgumentType::ColumnGeoPolygon:
649  return "COLUMN<GEOPOLYGON>";
650  case ExtArgumentType::ColumnGeoMultiPoint:
651  return "COLUMN<GEOMULTIPOINT>";
652  case ExtArgumentType::ColumnGeoMultiLineString:
653  return "COLUMN<GEOMULTILINESTRING>";
654  case ExtArgumentType::ColumnGeoMultiPolygon:
655  return "COLUMN<GEOMULTIPOLYGON>";
656  case ExtArgumentType::ColumnListGeoPoint:
657  return "COLUMNLIST<GEOPOINT>";
658  case ExtArgumentType::ColumnListGeoLineString:
659  return "COLUMNLIST<GEOLINESTRING>";
660  case ExtArgumentType::ColumnListGeoPolygon:
661  return "COLUMNLIST<GEOPOLYGON>";
662  case ExtArgumentType::ColumnListGeoMultiPoint:
663  return "COLUMNLIST<GEOMULTIPOINT>";
664  case ExtArgumentType::ColumnListGeoMultiLineString:
665  return "COLUMNLIST<GEOMULTILINESTRING>";
666  case ExtArgumentType::ColumnListGeoMultiPolygon:
667  return "COLUMNLIST<GEOMULTIPOLYGON>";
668  default:
669  UNREACHABLE() << " sig_type=" << static_cast<int>(sig_type);
670  }
671  return "";
672 }
673 
674 bool ExtensionFunction::usesManager() const {
675  // if-else exists to keep compatibility with older versions of RBC
676  if (annotations_.empty()) {
677  return false;
678  } else {
679  auto func_annotations = annotations_.back();
680  auto mgr_annotation = func_annotations.find("uses_manager");
681  if (mgr_annotation != func_annotations.end()) {
682  return boost::algorithm::to_lower_copy(mgr_annotation->second) == "true";
683  }
684  return false;
685  }
686 }
687 
688 const std::string ExtensionFunction::getName(bool keep_suffix) const {
689  return (keep_suffix ? name_ : drop_suffix(name_));
690 }
691 
692 std::string ExtensionFunction::toString() const {
693  return getName() + "(" + ExtensionFunctionsWhitelist::toString(args_) + ") -> " +
694  ExtensionFunctionsWhitelist::toString({ret_});
695 }
696 
697 std::string ExtensionFunction::toStringSQL() const {
698  return getName(/* keep_suffix = */ false) + "(" +
699  ExtensionFunctionsWhitelist::toStringSQL(args_) + ") -> " +
700  ExtensionFunctionsWhitelist::toStringSQL(ret_);
701 }
702 
703 std::string ExtensionFunction::toSignature() const {
704  return "(" + ExtensionFunctionsWhitelist::toString(args_) + ") -> " +
705  ExtensionFunctionsWhitelist::toString(ret_);
706 }
707 
708 // Converts the extension function signatures to their LLVM representation.
709 std::vector<std::string> ExtensionFunctionsWhitelist::getLLVMDeclarations(
710  const std::unordered_set<std::string>& udf_decls,
711  const bool is_gpu) {
712  std::vector<std::string> declarations;
713  for (const auto& kv : functions_) {
714  const std::vector<ExtensionFunction>& ext_funcs = kv.second;
715  CHECK(!ext_funcs.empty());
716  for (const auto& ext_func : ext_funcs) {
717  // If there is a udf function declaration matching an extension function signature
718  // do not emit a duplicate declaration.
719  if (!udf_decls.empty() && udf_decls.find(ext_func.getName()) != udf_decls.end()) {
720  continue;
721  }
722 
723  std::string decl_prefix;
724  std::vector<std::string> arg_strs;
725 
726  if (is_ext_arg_type_array(ext_func.getRet())) {
727  decl_prefix = "declare void @" + ext_func.getName();
728  arg_strs.emplace_back(
729  serialize_type(ext_func.getRet(), /* byval */ true, /* declare */ true));
730  } else {
731  decl_prefix =
732  "declare " +
733  serialize_type(ext_func.getRet(), /* byval */ true, /* declare */ true) +
734  " @" + ext_func.getName();
735  }
736 
737  // if the extension function uses a Row Function Manager, append "i8*" as the first
738  // arg
739  if (ext_func.usesManager()) {
740  arg_strs.emplace_back("i8*");
741  }
742 
743  for (const auto arg : ext_func.getInputArgs()) {
744  arg_strs.emplace_back(serialize_type(arg, /* byval */ false, /* declare */ true));
745  }
746  declarations.emplace_back(decl_prefix + "(" +
747  boost::algorithm::join(arg_strs, ", ") + ");");
748  }
749  }
750 
751  for (const auto& kv : table_functions::TableFunctionsFactory::functions_) {
752  if (kv.second.isRuntime() || kv.second.useDefaultSizer()) {
753  // Runtime UDTFs are defined in LLVM/NVVM IR module
754  // UDTFs using default sizer share LLVM IR
755  continue;
756  }
757  if (!((is_gpu && kv.second.isGPU()) || (!is_gpu && kv.second.isCPU()))) {
758  continue;
759  }
760  std::string decl_prefix{
761  "declare " +
762  serialize_type(ExtArgumentType::Int32, /* byval */ true, /* declare */ true) +
763  " @" + kv.first};
764  std::vector<std::string> arg_strs;
765  for (const auto arg : kv.second.getArgs(/* ensure_column = */ true)) {
766  arg_strs.push_back(
767  serialize_type(arg, /* byval= */ kv.second.isRuntime(), /* declare= */ true));
768  }
769  declarations.push_back(decl_prefix + "(" + boost::algorithm::join(arg_strs, ", ") +
770  ");");
771  }
772  return declarations;
773 }
774 
775 namespace {
776 
777 ExtArgumentType deserialize_type(const std::string& type_name) {
778  if (type_name == "bool" || type_name == "i1") {
779  return ExtArgumentType::Bool;
780  }
781  if (type_name == "i8") {
782  return ExtArgumentType::Int8;
783  }
784  if (type_name == "i16") {
785  return ExtArgumentType::Int16;
786  }
787  if (type_name == "i32") {
788  return ExtArgumentType::Int32;
789  }
790  if (type_name == "i64") {
791  return ExtArgumentType::Int64;
792  }
793  if (type_name == "float") {
794  return ExtArgumentType::Float;
795  }
796  if (type_name == "double") {
797  return ExtArgumentType::Double;
798  }
799  if (type_name == "void") {
800  return ExtArgumentType::Void;
801  }
802  if (type_name == "i8*") {
803  return ExtArgumentType::PInt8;
804  }
805  if (type_name == "i16*") {
806  return ExtArgumentType::PInt16;
807  }
808  if (type_name == "i32*") {
809  return ExtArgumentType::PInt32;
810  }
811  if (type_name == "i64*") {
812  return ExtArgumentType::PInt64;
813  }
814  if (type_name == "float*") {
815  return ExtArgumentType::PFloat;
816  }
817  if (type_name == "double*") {
818  return ExtArgumentType::PDouble;
819  }
820  if (type_name == "i1*" || type_name == "bool*") {
821  return ExtArgumentType::PBool;
822  }
823  if (type_name == "Array<i8>") {
824  return ExtArgumentType::ArrayInt8;
825  }
826  if (type_name == "Array<i16>") {
827  return ExtArgumentType::ArrayInt16;
828  }
829  if (type_name == "Array<i32>") {
830  return ExtArgumentType::ArrayInt32;
831  }
832  if (type_name == "Array<i64>") {
833  return ExtArgumentType::ArrayInt64;
834  }
835  if (type_name == "Array<float>") {
836  return ExtArgumentType::ArrayFloat;
837  }
838  if (type_name == "Array<double>") {
839  return ExtArgumentType::ArrayDouble;
840  }
841  if (type_name == "Array<bool>" || type_name == "Array<i1>") {
842  return ExtArgumentType::ArrayBool;
843  }
844  if (type_name == "Array<TextEncodingDict>") {
845  return ExtArgumentType::ArrayTextEncodingDict;
846  }
847  if (type_name == "Array<TextEncodingNone>") {
848  return ExtArgumentType::ArrayTextEncodingNone;
849  }
850  if (type_name == "GeoPoint") {
851  return ExtArgumentType::GeoPoint;
852  }
853  if (type_name == "GeoMultiPoint") {
854  return ExtArgumentType::GeoMultiPoint;
855  }
856  if (type_name == "GeoLineString") {
857  return ExtArgumentType::GeoLineString;
858  }
859  if (type_name == "GeoMultiLineString") {
860  return ExtArgumentType::GeoMultiLineString;
861  }
862  if (type_name == "GeoPolygon") {
863  return ExtArgumentType::GeoPolygon;
864  }
865  if (type_name == "GeoMultiPolygon") {
866  return ExtArgumentType::GeoMultiPolygon;
867  }
868  if (type_name == "cursor") {
869  return ExtArgumentType::Cursor;
870  }
871  if (type_name == "Column<i8>") {
872  return ExtArgumentType::ColumnInt8;
873  }
874  if (type_name == "Column<i16>") {
875  return ExtArgumentType::ColumnInt16;
876  }
877  if (type_name == "Column<i32>") {
878  return ExtArgumentType::ColumnInt32;
879  }
880  if (type_name == "Column<i64>") {
881  return ExtArgumentType::ColumnInt64;
882  }
883  if (type_name == "Column<float>") {
884  return ExtArgumentType::ColumnFloat;
885  }
886  if (type_name == "Column<double>") {
887  return ExtArgumentType::ColumnDouble;
888  }
889  if (type_name == "Column<bool>") {
890  return ExtArgumentType::ColumnBool;
891  }
892  if (type_name == "Column<TextEncodingDict>") {
893  return ExtArgumentType::ColumnTextEncodingDict;
894  }
895  if (type_name == "Column<Timestamp>") {
896  return ExtArgumentType::ColumnTimestamp;
897  }
898  if (type_name == "TextEncodingNone") {
899  return ExtArgumentType::TextEncodingNone;
900  }
901  if (type_name == "TextEncodingDict") {
902  return ExtArgumentType::TextEncodingDict;
903  }
904  if (type_name == "timestamp") {
905  return ExtArgumentType::Timestamp;
906  }
907  if (type_name == "ColumnList<i8>") {
908  return ExtArgumentType::ColumnListInt8;
909  }
910  if (type_name == "ColumnList<i16>") {
911  return ExtArgumentType::ColumnListInt16;
912  }
913  if (type_name == "ColumnList<i32>") {
914  return ExtArgumentType::ColumnListInt32;
915  }
916  if (type_name == "ColumnList<i64>") {
917  return ExtArgumentType::ColumnListInt64;
918  }
919  if (type_name == "ColumnList<float>") {
920  return ExtArgumentType::ColumnListFloat;
921  }
922  if (type_name == "ColumnList<double>") {
923  return ExtArgumentType::ColumnListDouble;
924  }
925  if (type_name == "ColumnList<bool>") {
926  return ExtArgumentType::ColumnListBool;
927  }
928  if (type_name == "ColumnList<TextEncodingDict>") {
929  return ExtArgumentType::ColumnListTextEncodingDict;
930  }
931  if (type_name == "Column<Array<i8>>") {
932  return ExtArgumentType::ColumnArrayInt8;
933  }
934  if (type_name == "Column<Array<i16>>") {
935  return ExtArgumentType::ColumnArrayInt16;
936  }
937  if (type_name == "Column<Array<i32>>") {
938  return ExtArgumentType::ColumnArrayInt32;
939  }
940  if (type_name == "Column<Array<i64>>") {
941  return ExtArgumentType::ColumnArrayInt64;
942  }
943  if (type_name == "Column<Array<float>>") {
944  return ExtArgumentType::ColumnArrayFloat;
945  }
946  if (type_name == "Column<Array<double>>") {
947  return ExtArgumentType::ColumnArrayDouble;
948  }
949  if (type_name == "Column<Array<bool>>") {
950  return ExtArgumentType::ColumnArrayBool;
951  }
952  if (type_name == "Column<Array<TextEncodingDict>>") {
953  return ExtArgumentType::ColumnArrayTextEncodingDict;
954  }
955  if (type_name == "ColumnList<Array<i8>>") {
956  return ExtArgumentType::ColumnListArrayInt8;
957  }
958  if (type_name == "ColumnList<Array<i16>>") {
959  return ExtArgumentType::ColumnListArrayInt16;
960  }
961  if (type_name == "ColumnList<Array<i32>>") {
962  return ExtArgumentType::ColumnListArrayInt32;
963  }
964  if (type_name == "ColumnList<Array<i64>>") {
965  return ExtArgumentType::ColumnListArrayInt64;
966  }
967  if (type_name == "ColumnList<Array<float>>") {
968  return ExtArgumentType::ColumnListArrayFloat;
969  }
970  if (type_name == "ColumnList<Array<double>>") {
971  return ExtArgumentType::ColumnListArrayDouble;
972  }
973  if (type_name == "ColumnList<Array<bool>>") {
974  return ExtArgumentType::ColumnListArrayBool;
975  }
976  if (type_name == "ColumnList<Array<TextEncodingDict>>") {
977  return ExtArgumentType::ColumnListArrayTextEncodingDict;
978  }
979  if (type_name == "DayTimeInterval") {
980  return ExtArgumentType::DayTimeInterval;
981  }
982  if (type_name == "YearMonthTimeInterval") {
983  return ExtArgumentType::YearMonthTimeInterval;
984  }
985  if (type_name == "Column<GeoPoint>") {
986  return ExtArgumentType::ColumnGeoPoint;
987  }
988  if (type_name == "Column<GeoLineString>") {
989  return ExtArgumentType::ColumnGeoLineString;
990  }
991  if (type_name == "Column<GeoPolygon>") {
992  return ExtArgumentType::ColumnGeoPolygon;
993  }
994  if (type_name == "Column<GeoMultiPoint>") {
995  return ExtArgumentType::ColumnGeoMultiPoint;
996  }
997  if (type_name == "Column<GeoMultiLineString>") {
998  return ExtArgumentType::ColumnGeoMultiLineString;
999  }
1000  if (type_name == "Column<GeoMultiPolygon>") {
1001  return ExtArgumentType::ColumnGeoMultiPolygon;
1002  }
1003  if (type_name == "ColumnList<GeoPoint>") {
1004  return ExtArgumentType::ColumnListGeoPoint;
1005  }
1006  if (type_name == "ColumnList<GeoLineString>") {
1007  return ExtArgumentType::ColumnListGeoLineString;
1008  }
1009  if (type_name == "ColumnList<GeoPolygon>") {
1010  return ExtArgumentType::ColumnListGeoPolygon;
1011  }
1012  if (type_name == "ColumnList<GeoMultiPoint>") {
1013  return ExtArgumentType::ColumnListGeoMultiPoint;
1014  }
1015  if (type_name == "ColumnList<GeoMultiLineString>") {
1016  return ExtArgumentType::ColumnListGeoMultiLineString;
1017  }
1018  if (type_name == "ColumnList<GeoMultiPolygon>") {
1019  return ExtArgumentType::ColumnListGeoMultiPolygon;
1020  }
1021  CHECK(false);
1022  return ExtArgumentType::Int16;
1023 }
1024 
1025 } // namespace
1026 
1027 using SignatureMap = std::unordered_map<std::string, std::vector<ExtensionFunction>>;
1028 
1029 void ExtensionFunctionsWhitelist::addCommon(SignatureMap& signatures,
1030  const std::string& json_func_sigs,
1031  const bool is_runtime) {
1032  rapidjson::Document func_sigs;
1033  func_sigs.Parse(json_func_sigs.c_str());
1034  CHECK(func_sigs.IsArray());
1035  for (auto func_sigs_it = func_sigs.Begin(); func_sigs_it != func_sigs.End();
1036  ++func_sigs_it) {
1037  CHECK(func_sigs_it->IsObject());
1038  const auto name = json_str(field(*func_sigs_it, "name"));
1039  const auto ret = deserialize_type(json_str(field(*func_sigs_it, "ret")));
1040  std::vector<ExtArgumentType> args;
1041  const auto& args_serialized = field(*func_sigs_it, "args");
1042  CHECK(args_serialized.IsArray());
1043  for (auto args_serialized_it = args_serialized.Begin();
1044  args_serialized_it != args_serialized.End();
1045  ++args_serialized_it) {
1046  args.push_back(deserialize_type(json_str(*args_serialized_it)));
1047  }
1048 
1049  std::vector<std::map<std::string, std::string>> annotations;
1050  const auto& anns = field(*func_sigs_it, "annotations");
1051  CHECK(anns.IsArray());
1052  static const std::map<std::string, std::string> map_empty = {};
1053  for (auto obj = anns.Begin(); obj != anns.End(); ++obj) {
1054  CHECK(obj->IsObject());
1055  if (obj->ObjectEmpty()) {
1056  annotations.push_back(map_empty);
1057  } else {
1058  std::map<std::string, std::string> m;
1059  for (auto kv = obj->MemberBegin(); kv != obj->MemberEnd(); ++kv) {
1060  m[kv->name.GetString()] = kv->value.GetString();
1061  }
1062  annotations.push_back(m);
1063  }
1064  }
1065  signatures[to_upper(drop_suffix(name))].emplace_back(
1066  name, args, ret, annotations, is_runtime);
1067  }
1068 }
1069 
1070 // Calcite loads the available extensions from `ExtensionFunctions.ast`, adds
1071 // them to its operator table and shares the list with the execution layer in
1072 // JSON format. Build an in-memory representation of that list here so that it
1073 // can be used by getLLVMDeclarations(), when the LLVM IR codegen asks for it.
1074 void ExtensionFunctionsWhitelist::add(const std::string& json_func_sigs) {
1075  // Valid json_func_sigs example:
1076  // [
1077  // {
1078  // "name":"sum",
1079  // "ret":"i32",
1080  // "args":[
1081  // "i32",
1082  // "i32"
1083  // ]
1084  // }
1085  // ]
1086 
1087  addCommon(functions_, json_func_sigs, /* is_runtime */ false);
1088 }
1089 
1090 void ExtensionFunctionsWhitelist::addUdfs(const std::string& json_func_sigs) {
1091  if (!json_func_sigs.empty()) {
1092  addCommon(udf_functions_, json_func_sigs, /* is_runtime */ false);
1093  }
1094 }
1095 
1096 void ExtensionFunctionsWhitelist::clearRTUdfs() {
1097  rt_udf_functions_.clear();
1098 }
1099 
1100 void ExtensionFunctionsWhitelist::addRTUdfs(const std::string& json_func_sigs) {
1101  if (!json_func_sigs.empty()) {
1102  addCommon(rt_udf_functions_, json_func_sigs, /* is_runtime */ true);
1103  }
1104 }
1105 
1106 std::unordered_map<std::string, std::vector<ExtensionFunction>>
1107  ExtensionFunctionsWhitelist::functions_;
1108 
1109 std::unordered_map<std::string, std::vector<ExtensionFunction>>
1110  ExtensionFunctionsWhitelist::udf_functions_;
1111 
1112 std::unordered_map<std::string, std::vector<ExtensionFunction>>
1113  ExtensionFunctionsWhitelist::rt_udf_functions_;
1114 
1115 std::string toString(const ExtArgumentType& sig_type) {
1116  return ExtensionFunctionsWhitelist::toString(sig_type);
1117 }
ExtArgumentType::PInt16
ExtArgumentType::ColumnListGeoPolygon
ExtensionFunctionsWhitelist::addUdfs
static void addUdfs(const std::string &json_func_sigs)
Definition: ExtensionFunctionsWhitelist.cpp:1090
ExtensionFunctionsWhitelist::addCommon
static void addCommon(std::unordered_map< std::string, std::vector< ExtensionFunction >> &sigs, const std::string &json_func_sigs, const bool is_runtime)
Definition: ExtensionFunctionsWhitelist.cpp:1029
ExtArgumentType::ColumnArrayInt64
anonymous_namespace{ExtensionFunctionsWhitelist.cpp}::drop_suffix
std::string drop_suffix(const std::string &str)
Definition: ExtensionFunctionsWhitelist.cpp:335
ExtArgumentType::ColumnListGeoPoint
ExtArgumentType::YearMonthTimeInterval
ExtArgumentType::ColumnFloat
ExtArgumentType::ColumnArrayTextEncodingDict
run_benchmark_import.args
tuple args
Definition: run_benchmark_import.py:247
ExtArgumentType::ColumnInt64
ExtensionFunctionsWhitelist::get_ext_funcs
static std::vector< ExtensionFunction > get_ext_funcs(const std::string &name)
Definition: ExtensionFunctionsWhitelist.cpp:62
ExtensionFunctionsWhitelist::udf_functions_
static std::unordered_map< std::string, std::vector< ExtensionFunction > > udf_functions_
Definition: ExtensionFunctionsWhitelist.h:220
ExtArgumentType::Cursor
SQLTypes
SQLTypes
Definition: sqltypes.h:65
ExtArgumentType::ColumnListInt8
ExtArgumentType::ColumnArrayDouble
ExtensionFunctionsWhitelist::get
static std::vector< ExtensionFunction > * get(const std::string &name)
Definition: ExtensionFunctionsWhitelist.cpp:28
LOG
#define LOG(tag)
Definition: Logger.h:285
ExtensionFunction::toSignature
std::string toSignature() const
Definition: ExtensionFunctionsWhitelist.cpp:703
ExtArgumentType::Int64
ExtArgumentType::ColumnListArrayInt8
TableFunctionsFactory.h
json_str
const std::string json_str(const rapidjson::Value &obj) noexcept
Definition: JsonAccessors.h:46
ExtensionFunctionsWhitelist::rt_udf_functions_
static std::unordered_map< std::string, std::vector< ExtensionFunction > > rt_udf_functions_
Definition: ExtensionFunctionsWhitelist.h:223
ExtArgumentType::Int16
ExtArgumentType::ColumnInt32
join
std::string join(T const &container, std::string const &delim)
Definition: StringTransform.h:63
ExtensionFunction::args_
const std::vector< ExtArgumentType > args_
Definition: ExtensionFunctionsWhitelist.h:165
ExtensionFunctionsWhitelist::add
static void add(const std::string &json_func_sigs)
Definition: ExtensionFunctionsWhitelist.cpp:1074
UNREACHABLE
#define UNREACHABLE()
Definition: Logger.h:338
AggregationType::NONE
SignatureMap
std::unordered_map< std::string, std::vector< ExtensionFunction >> SignatureMap
Definition: ExtensionFunctionsWhitelist.cpp:1027
ExtArgumentType::ColumnGeoPolygon
ExtArgumentType::Bool
ExtArgumentType::ColumnArrayBool
ExtensionFunction::getName
const std::string getName(bool keep_suffix=true) const
Definition: ExtensionFunctionsWhitelist.cpp:688
ExtArgumentType::ColumnArrayInt32
ExtArgumentType::ColumnGeoMultiLineString
SQLTypeInfo::get_type
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:391
ExtensionFunction::toStringSQL
std::string toStringSQL() const
Definition: ExtensionFunctionsWhitelist.cpp:697
ExtArgumentType::ColumnArrayTextEncodingNone
ExtArgumentType::ColumnGeoLineString
CHECK_GT
#define CHECK_GT(x, y)
Definition: Logger.h:305
Double
Definition: HashJoinRuntime.h:120
ExtArgumentType::ArrayBool
ExtArgumentType::ColumnListArrayTextEncodingDict
ExtArgumentType::ColumnBool
ExtArgumentType::GeoMultiPoint
ExtensionFunctionsWhitelist::functions_
static std::unordered_map< std::string, std::vector< ExtensionFunction > > functions_
Definition: ExtensionFunctionsWhitelist.h:218
field
const rapidjson::Value & field(const rapidjson::Value &obj, const char field[]) noexcept
Definition: JsonAccessors.h:33
EncodingType
EncodingType
Definition: sqltypes.h:240
ExtArgumentType::ColumnDouble
ExtensionFunctionsWhitelist.h
Supported runtime functions management and retrieval.
ExtArgumentType::Int8
ExtensionFunctionsWhitelist::get_udf
static std::vector< ExtensionFunction > * get_udf(const std::string &name)
Definition: ExtensionFunctionsWhitelist.cpp:37
ExtArgumentType::PFloat
EXTARGTYPECASE
#define EXTARGTYPECASE(EXTARGTYPE, ELEMTYPE, ENCODING, ARRAYENCODING)
TextEncodingDict
Definition: heavydbTypes.h:215
ExtArgumentType::ColumnListFloat
ExtArgumentType::Timestamp
gpu_enabled::copy
DEVICE auto copy(ARGS &&...args)
Definition: gpu_enabled.h:51
ExtArgumentType::ColumnListDouble
anonymous_namespace{ExtensionFunctionsWhitelist.cpp}::deserialize_type
ExtArgumentType deserialize_type(const std::string &type_name)
Definition: ExtensionFunctionsWhitelist.cpp:777
ExtArgumentType::ColumnListArrayInt32
ExtArgumentType::ArrayInt8
ExtArgumentType::PInt32
ExtArgumentType::ArrayDouble
is_ext_arg_type_array
bool is_ext_arg_type_array(const ExtArgumentType ext_arg_type)
Definition: TableFunctionHelper.h:120
ExtensionFunctionsWhitelist::get_udfs_name
static std::unordered_set< std::string > get_udfs_name(const bool is_runtime)
Definition: ExtensionFunctionsWhitelist.cpp:47
ExtArgumentType::ColumnListGeoLineString
JsonAccessors.h
Checked json field retrieval.
ExtArgumentType::ColumnInt8
ExtArgumentType::ColumnInt16
StringTransform.h
ExtArgumentType
ExtArgumentType
Definition: ExtensionFunctionsWhitelist.h:37
toString
std::string toString(const Executor::ExtModuleKinds &kind)
Definition: Execute.h:1703
ExtensionFunctionsBinding.h
Argument type based extension function binding.
ExtArgumentType::ColumnListInt64
ExtArgumentType::Void
ExtArgumentType::DayTimeInterval
to_upper
std::string to_upper(const std::string &str)
Definition: StringTransform.h:93
ExtArgumentType::ColumnListGeoMultiLineString
kTEXT
Definition: sqltypes.h:79
EXTARGGEOTYPECASE
#define EXTARGGEOTYPECASE(GEOTYPE, KTYPE)
ExtArgumentType::PBool
ExtArgumentType::PInt64
TextEncodingNone
Definition: heavydbTypes.h:607
ExtArgumentType::ColumnListInt16
ExtArgumentType::Float
ExtArgumentType::ColumnTimestamp
ExtArgumentType::ColumnListGeoMultiPoint
anonymous_namespace{ExtensionFunctionsWhitelist.cpp}::serialize_type
std::string serialize_type(const ExtArgumentType type, bool byval=true, bool declare=false)
Definition: ExtensionFunctionsWhitelist.cpp:155
ExtensionFunction::annotations_
const std::vector< std::map< std::string, std::string > > annotations_
Definition: ExtensionFunctionsWhitelist.h:167
ExtArgumentType::ArrayInt32
ExtArgumentType::ArrayFloat
ExtensionFunction::ret_
const ExtArgumentType ret_
Definition: ExtensionFunctionsWhitelist.h:166
ExtArgumentType::ColumnArrayInt16
ExtArgumentType::ColumnGeoPoint
ExtArgumentType::ColumnTextEncodingNone
ExtArgumentType::ColumnTextEncodingDict
ExtensionFunctionsWhitelist::toString
static std::string toString(const std::vector< ExtensionFunction > &ext_funcs, std::string tab="")
Definition: ExtensionFunctionsWhitelist.cpp:443
ExtArgumentType::ColumnListArrayBool
ExtArgumentType::PInt8
CHECK
#define CHECK(condition)
Definition: Logger.h:291
ExtArgumentType::GeoMultiLineString
ExtArgumentType::ColumnListTextEncodingNone
ExtArgumentType::Int32
ExtArgumentType::ColumnGeoMultiPolygon
table_functions::TableFunctionsFactory::functions_
static std::unordered_map< std::string, TableFunction > functions_
Definition: TableFunctionsFactory.h:361
ExtArgumentType::ColumnGeoMultiPoint
ExtArgumentType::ColumnListArrayInt64
ExtArgumentType::ArrayTextEncodingNone
ExtArgumentType::GeoPoint
ExtArgumentType::ColumnListTextEncodingDict
ExtArgumentType::GeoPolygon
kINT
Definition: sqltypes.h:72
ExtArgumentType::ArrayInt16
ExtArgumentType::PDouble
ExtArgumentType::ColumnArrayFloat
ExtArgumentType::ColumnListArrayDouble
ExtArgumentType::TextEncodingDict
setup.name
string name
Definition: setup.in.py:72
anonymous_namespace{Utm.h}::n
constexpr double n
Definition: Utm.h:38
ExtArgumentType::ColumnListArrayTextEncodingNone
ExtArgumentType::ArrayTextEncodingDict
ExtArgumentType::ArrayInt64
type_name
constexpr auto type_name() noexcept
Definition: type_name_to_string.h:11
ExtArgumentType::ColumnArrayInt8
ExtensionFunctionsWhitelist::getLLVMDeclarations
static std::vector< std::string > getLLVMDeclarations(const std::unordered_set< std::string > &udf_decls, const bool is_gpu=false)
Definition: ExtensionFunctionsWhitelist.cpp:709
ExtArgumentType::Double
ExtArgumentType::ColumnListBool
ExtArgumentType::GeoMultiPolygon
ExtArgumentType::TextEncodingNone
ExpressionRangeType::Float
ExtArgumentType::ColumnListInt32
ExtArgumentType::ColumnListArrayInt16
ExtArgumentType::GeoLineString
ext_arg_type_to_type_info
SQLTypeInfo ext_arg_type_to_type_info(const ExtArgumentType ext_arg_type)
Definition: ExtensionFunctionsWhitelist.cpp:346
ExtensionFunctionsWhitelist::toStringSQL
static std::string toStringSQL(const std::vector< ExtArgumentType > &sig_types)
Definition: ExtensionFunctionsWhitelist.cpp:479
ExtArgumentType::ColumnListGeoMultiPolygon
ExtensionFunctionsWhitelist::addRTUdfs
static void addRTUdfs(const std::string &json_func_sigs)
Definition: ExtensionFunctionsWhitelist.cpp:1100
run_benchmark_import.type
type
Definition: run_benchmark_import.py:89
ExtArgumentType::ColumnListArrayFloat