OmniSciDB  addbbd5075
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Functions
anonymous_namespace{ExtensionFunctionsBinding.cpp} Namespace Reference

Functions

static int match_arguments (const SQLTypeInfo &arg_type, int sig_pos, const std::vector< ExtArgumentType > &sig_types, int &penalty_score)
 

Function Documentation

static int anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_arguments ( const SQLTypeInfo &  arg_type,
int  sig_pos,
const std::vector< ExtArgumentType > &  sig_types,
int &  penalty_score 
)
static

Definition at line 35 of file ExtensionFunctionsBinding.cpp.

References Bool, Double, Float, GeoLineString, GeoMultiPolygon, GeoPoint, GeoPolygon, SQLTypeInfoCore< TYPE_FACET_PACK >::get_logical_size(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_type(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_type_name(), Int16, Int32, Int64, Int8, is_ext_arg_type_array(), kARRAY, kBIGINT, kBOOLEAN, kDECIMAL, kDOUBLE, kFLOAT, kINT, kLINESTRING, kMULTIPOLYGON, kNULLT, kNUMERIC, kPOINT, kPOLYGON, kSMALLINT, kTINYINT, PDouble, PFloat, PInt16, PInt32, PInt64, PInt8, to_string(), and ExtensionFunctionsWhitelist::toString().

Referenced by bind_function().

38  {
39  /*
40  Returns non-negative integer `offset` if `arg_type` and
41  `sig_types[sig_pos:sig_pos + offset]` match.
42 
43  The `offset` value can be interpreted as the number of extension
44  function arguments that is consumed by the given `arg_type`. For
45  instance, for scalar types the offset is always 1, for array
46  types the offset is 2: one argument for array pointer value and
47  one argument for the array size value, etc.
48 
49  Returns -1 when the types of an argument and the corresponding
50  extension function argument(s) mismatch, or when downcasting would
51  be effective.
52 
53  In case of non-negative `offset` result, the function updates
54  penalty_score argument as follows:
55 
56  add 1000 if arg_type is non-scalar, otherwise:
57  add 1000 * sizeof(sig_type) / sizeof(arg_type)
58  add 1000000 if type kinds differ (integer vs double, for instance)
59 
60  */
61  auto stype = sig_types[sig_pos];
62  int max_pos = sig_types.size() - 1;
63  switch (arg_type.get_type()) {
64  case kBOOLEAN:
65  if (stype == ExtArgumentType::Bool) {
66  penalty_score += 1000;
67  return 1;
68  }
69  break;
70  case kTINYINT:
71  switch (stype) {
72  case ExtArgumentType::Int8:
73  penalty_score += 1000;
74  break;
75  case ExtArgumentType::Int16:
76  penalty_score += 2000;
77  break;
78  case ExtArgumentType::Int32:
79  penalty_score += 4000;
80  break;
81  case ExtArgumentType::Int64:
82  penalty_score += 8000;
83  break;
84  case ExtArgumentType::Double:
85  penalty_score += 1008000;
86  break; // temporary: allow integers as double arguments
87  default:
88  return -1;
89  }
90  return 1;
91  case kSMALLINT:
92  switch (stype) {
93  case ExtArgumentType::Int16:
94  penalty_score += 1000;
95  break;
96  case ExtArgumentType::Int32:
97  penalty_score += 2000;
98  break;
99  case ExtArgumentType::Int64:
100  penalty_score += 4000;
101  break;
102  case ExtArgumentType::Double:
103  penalty_score += 1004000;
104  break; // temporary: allow integers as double arguments
105  default:
106  return -1;
107  }
108  return 1;
109  case kINT:
110  switch (stype) {
111  case ExtArgumentType::Int32:
112  penalty_score += 1000;
113  break;
114  case ExtArgumentType::Int64:
115  penalty_score += 2000;
116  break;
117  case ExtArgumentType::Double:
118  penalty_score += 1002000;
119  break; // temporary: allow integers as double arguments
120  default:
121  return -1;
122  }
123  return 1;
124  case kBIGINT:
125  switch (stype) {
126  case ExtArgumentType::Int64:
127  penalty_score += 1000;
128  break;
129  case ExtArgumentType::Double:
130  penalty_score += 1001000;
131  break; // temporary: allow integers as double arguments
132  default:
133  return -1;
134  }
135  return 1;
136  case kFLOAT:
137  switch (stype) {
138  case ExtArgumentType::Float:
139  penalty_score += 1000;
140  break;
141  case ExtArgumentType::Double:
142  penalty_score += 2000;
143  break; // is it ok to use floats as double arguments?
144  default:
145  return -1;
146  }
147  return 1;
148  case kDOUBLE:
149  if (stype == ExtArgumentType::Double) {
150  penalty_score += 1000;
151  return 1;
152  }
153  break;
154 
155  case kPOINT:
156  case kLINESTRING:
157  if ((stype == ExtArgumentType::PInt8 || stype == ExtArgumentType::PInt16 ||
158  stype == ExtArgumentType::PInt32 || stype == ExtArgumentType::PInt64 ||
159  stype == ExtArgumentType::PFloat || stype == ExtArgumentType::PDouble) &&
160  sig_pos < max_pos && sig_types[sig_pos + 1] == ExtArgumentType::Int64) {
161  penalty_score += 1000;
162  return 2;
163  } else if (stype == ExtArgumentType::GeoPoint ||
164  stype == ExtArgumentType::GeoLineString) {
165  penalty_score += 1000;
166  return 1;
167  }
168  break;
169  case kARRAY:
170  if ((stype == ExtArgumentType::PInt8 || stype == ExtArgumentType::PInt16 ||
171  stype == ExtArgumentType::PInt32 || stype == ExtArgumentType::PInt64 ||
172  stype == ExtArgumentType::PFloat || stype == ExtArgumentType::PDouble) &&
173  sig_pos < max_pos && sig_types[sig_pos + 1] == ExtArgumentType::Int64) {
174  penalty_score += 1000;
175  return 2;
176  } else if (is_ext_arg_type_array(stype)) {
177  penalty_score += 1000;
178  return 1;
179  }
180  break;
181  case kPOLYGON:
182  if (stype == ExtArgumentType::PInt8 && sig_pos + 3 < max_pos &&
183  sig_types[sig_pos + 1] == ExtArgumentType::Int64 &&
184  sig_types[sig_pos + 2] == ExtArgumentType::PInt32 &&
185  sig_types[sig_pos + 3] == ExtArgumentType::Int64) {
186  penalty_score += 1000;
187  return 4;
188  } else if (stype == ExtArgumentType::GeoPolygon) {
189  penalty_score += 1000;
190  return 1;
191  }
192 
193  break;
194 
195  case kMULTIPOLYGON:
196  if (stype == ExtArgumentType::PInt8 && sig_pos + 5 < max_pos &&
197  sig_types[sig_pos + 1] == ExtArgumentType::Int64 &&
198  sig_types[sig_pos + 2] == ExtArgumentType::PInt32 &&
199  sig_types[sig_pos + 3] == ExtArgumentType::Int64 &&
200  sig_types[sig_pos + 4] == ExtArgumentType::PInt32 &&
201  sig_types[sig_pos + 5] == ExtArgumentType::Int64) {
202  penalty_score += 1000;
203  return 6;
204  } else if (stype == ExtArgumentType::GeoMultiPolygon) {
205  penalty_score += 1000;
206  return 1;
207  }
208  break;
209  case kDECIMAL:
210  case kNUMERIC:
211  if (stype == ExtArgumentType::Double && arg_type.get_logical_size() == 8) {
212  penalty_score += 1000;
213  return 1;
214  }
215  if (stype == ExtArgumentType::Float && arg_type.get_logical_size() == 4) {
216  penalty_score += 1000;
217  return 1;
218  }
219  break;
220  case kNULLT: // NULL maps to a pointer and size argument
221  if ((stype == ExtArgumentType::PInt8 || stype == ExtArgumentType::PInt16 ||
222  stype == ExtArgumentType::PInt32 || stype == ExtArgumentType::PInt64 ||
223  stype == ExtArgumentType::PFloat || stype == ExtArgumentType::PDouble) &&
224  sig_pos < max_pos && sig_types[sig_pos + 1] == ExtArgumentType::Int64) {
225  penalty_score += 1000;
226  return 2;
227  }
228  break;
229  /* Not implemented types:
230  kCHAR
231  kVARCHAR
232  kTIME
233  kTIMESTAMP
234  kTEXT
235  kDATE
236  kINTERVAL_DAY_TIME
237  kINTERVAL_YEAR_MONTH
238  kGEOMETRY
239  kGEOGRAPHY
240  kEVAL_CONTEXT_TYPE
241  kVOID
242  kCURSOR
243  */
244  default:
245  throw std::runtime_error(std::string(__FILE__) + "#" + std::to_string(__LINE__) +
246  ": support for " + arg_type.get_type_name() +
247  "(type=" + std::to_string(arg_type.get_type()) + ")" +
248  +" not implemented: \n pos=" + std::to_string(sig_pos) +
249  " max_pos=" + std::to_string(max_pos) + "\n sig_types=(" +
250  ExtensionFunctionsWhitelist::toString(sig_types) + ")");
251  }
252  return -1;
253 }
ExtArgumentType::PInt16
ExtArgumentType::Int64
ExtArgumentType::Int16
ExtArgumentType::Bool
to_string
std::string to_string(char const *&&v)
Definition: StringTransform.cpp:93
SQLTypeInfoCore::get_type_name
std::string get_type_name() const
Definition: sqltypes.h:429
ExtArgumentType::Int8
ExtArgumentType::PFloat
SQLTypeInfoCore::get_logical_size
int get_logical_size() const
Definition: sqltypes.h:337
SQLTypeInfoCore::get_type
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:326
ExtArgumentType::PInt32
is_ext_arg_type_array
bool is_ext_arg_type_array(const ExtArgumentType ext_arg_type)
Definition: ExtensionFunctionsBinding.cpp:357
ExtArgumentType::PInt64
ExtArgumentType::Float
ExtensionFunctionsWhitelist::toString
static std::string toString(const std::vector< ExtensionFunction > &ext_funcs, std::string tab="")
Definition: ExtensionFunctionsWhitelist.cpp:204
ExtArgumentType::PInt8
ExtArgumentType::Int32
ExtArgumentType::GeoPoint
ExtArgumentType::GeoPolygon
kINT
Definition: sqltypes.h:48
ExtArgumentType::PDouble
ExtArgumentType::Double
ExtArgumentType::GeoMultiPolygon
ExtArgumentType::GeoLineString

+ Here is the call graph for this function:

+ Here is the caller graph for this function: