OmniSciDB  85c2d10cdc
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
ThriftSerializers.h
Go to the documentation of this file.
1 /*
2  * Copyright 2018 MapD Technologies, 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 
23 #ifndef QUERYENGINE_THRIFTSERIALIZERS_H
24 #define QUERYENGINE_THRIFTSERIALIZERS_H
25 
26 #include "gen-cpp/serialized_result_set_types.h"
27 
28 #include "Logger/Logger.h"
38 
39 namespace ThriftSerializers {
40 
41 #define THRIFT_LAYOUT_CASE(layout) \
42  case QueryDescriptionType::layout: \
43  return TResultSetLayout::layout;
44 
46  switch (layout) {
51  default:
52  CHECK(false) << static_cast<int>(layout);
53  }
54  abort();
55 }
56 
57 #undef THRIFT_LAYOUT_CASE
58 
59 #define UNTHRIFT_LAYOUT_CASE(layout) \
60  case TResultSetLayout::layout: \
61  return QueryDescriptionType::layout;
62 
64  switch (layout) {
69  default:
70  CHECK(false) << static_cast<int>(layout);
71  }
72  abort();
73 }
74 
75 #undef UNTHRIFT_LAYOUT_CASE
76 
77 #define THRIFT_AGGKIND_CASE(kind) \
78  case k##kind: \
79  return TAggKind::kind;
80 
82  switch (agg) {
88  THRIFT_AGGKIND_CASE(APPROX_COUNT_DISTINCT)
89  THRIFT_AGGKIND_CASE(SAMPLE)
90  THRIFT_AGGKIND_CASE(SINGLE_VALUE)
91  default:
92  CHECK(false) << static_cast<int>(agg);
93  }
94  abort();
95 }
96 
97 #undef THRIFT_AGGKIND_CASE
98 
99 #define UNTHRIFT_AGGKIND_CASE(kind) \
100  case TAggKind::kind: \
101  return k##kind;
102 
104  switch (agg) {
110  UNTHRIFT_AGGKIND_CASE(APPROX_COUNT_DISTINCT)
111  UNTHRIFT_AGGKIND_CASE(SAMPLE)
112  UNTHRIFT_AGGKIND_CASE(SINGLE_VALUE)
113  default:
114  CHECK(false) << static_cast<int>(agg);
115  }
116  abort();
117 }
118 
119 #undef UNTHRIFT_AGGKIND_CASE
120 
122  const std::vector<TColumnRange>& thrift_column_ranges) {
123  AggregatedColRange column_ranges;
124  for (const auto& thrift_column_range : thrift_column_ranges) {
125  PhysicalInput phys_input{thrift_column_range.col_id, thrift_column_range.table_id};
126  switch (thrift_column_range.type) {
128  column_ranges.setColRange(
129  phys_input,
130  ExpressionRange::makeIntRange(thrift_column_range.int_min,
131  thrift_column_range.int_max,
132  thrift_column_range.bucket,
133  thrift_column_range.has_nulls));
134  break;
136  column_ranges.setColRange(
137  phys_input,
138  ExpressionRange::makeFloatRange(thrift_column_range.fp_min,
139  thrift_column_range.fp_max,
140  thrift_column_range.has_nulls));
141  break;
143  column_ranges.setColRange(
144  phys_input,
145  ExpressionRange::makeDoubleRange(thrift_column_range.fp_min,
146  thrift_column_range.fp_max,
147  thrift_column_range.has_nulls));
148  break;
149  case TExpressionRangeType::INVALID:
150  column_ranges.setColRange(phys_input, ExpressionRange::makeInvalidRange());
151  break;
152  default:
153  CHECK(false);
154  }
155  }
156  return column_ranges;
157 }
158 
160  const std::vector<TDictionaryGeneration>& thrift_string_dictionary_generations) {
161  StringDictionaryGenerations string_dictionary_generations;
162  for (const auto& thrift_string_dictionary_generation :
163  thrift_string_dictionary_generations) {
164  string_dictionary_generations.setGeneration(
165  thrift_string_dictionary_generation.dict_id,
166  thrift_string_dictionary_generation.entry_count);
167  }
168  return string_dictionary_generations;
169 }
170 
171 inline TTypeInfo type_info_to_thrift(const SQLTypeInfo& ti) {
172  TTypeInfo thrift_ti;
173  thrift_ti.type =
175  thrift_ti.encoding = encoding_to_thrift(ti);
176  thrift_ti.nullable = !ti.get_notnull();
177  thrift_ti.is_array = ti.is_array();
178  // TODO: Properly serialize geospatial subtype. For now, the value in precision is the
179  // same as the value in scale; overload the precision field with the subtype of the
180  // geospatial type (currently kGEOMETRY or kGEOGRAPHY)
181  thrift_ti.precision =
182  IS_GEO(ti.get_type()) ? static_cast<int32_t>(ti.get_subtype()) : ti.get_precision();
183  thrift_ti.scale = ti.get_scale();
184  thrift_ti.comp_param = ti.get_comp_param();
185  thrift_ti.size = ti.get_size();
186  return thrift_ti;
187 }
188 
189 inline bool takes_arg(const TargetInfo& target_info) {
190  return target_info.is_agg &&
191  (target_info.agg_kind != kCOUNT || is_distinct_target(target_info));
192 }
193 
194 inline std::vector<TargetMetaInfo> target_meta_infos_from_thrift(
195  const TRowDescriptor& row_desc) {
196  std::vector<TargetMetaInfo> target_meta_infos;
197  for (const auto& col : row_desc) {
198  target_meta_infos.emplace_back(col.col_name, type_info_from_thrift(col.col_type));
199  }
200  return target_meta_infos;
201 }
202 
203 inline void fixup_geo_column_descriptor(TColumnType& col_type,
204  const SQLTypes subtype,
205  const int output_srid) {
206  col_type.col_type.precision = static_cast<int>(subtype);
207  col_type.col_type.scale = output_srid;
208 }
209 
210 inline TColumnType target_meta_info_to_thrift(const TargetMetaInfo& target,
211  const size_t idx) {
212  TColumnType proj_info;
213  proj_info.col_name = target.get_resname();
214  if (proj_info.col_name.empty()) {
215  proj_info.col_name = "result_" + std::to_string(idx + 1);
216  }
217  const auto& target_ti = target.get_type_info();
218  proj_info.col_type.type = type_to_thrift(target_ti);
219  proj_info.col_type.encoding = encoding_to_thrift(target_ti);
220  proj_info.col_type.nullable = !target_ti.get_notnull();
221  proj_info.col_type.is_array = target_ti.get_type() == kARRAY;
222  if (IS_GEO(target_ti.get_type())) {
224  proj_info, target_ti.get_subtype(), target_ti.get_output_srid());
225  } else {
226  proj_info.col_type.precision = target_ti.get_precision();
227  proj_info.col_type.scale = target_ti.get_scale();
228  }
229  if (target_ti.get_type() == kDATE) {
230  proj_info.col_type.size = target_ti.get_size();
231  }
232  proj_info.col_type.comp_param =
233  (target_ti.is_date_in_days() && target_ti.get_comp_param() == 0)
234  ? 32
235  : target_ti.get_comp_param();
236  return proj_info;
237 }
238 
239 inline TRowDescriptor target_meta_infos_to_thrift(
240  const std::vector<TargetMetaInfo>& targets) {
241  TRowDescriptor row_desc;
242  size_t i = 0;
243  for (const auto& target : targets) {
244  row_desc.push_back(target_meta_info_to_thrift(target, i));
245  ++i;
246  }
247  return row_desc;
248 }
249 
250 inline TTargetInfo target_info_to_thrift(const TargetInfo& target_info) {
251  TTargetInfo thrift_target_info;
252  thrift_target_info.is_agg = target_info.is_agg;
253  thrift_target_info.kind = agg_kind_to_thrift(target_info.agg_kind);
254  thrift_target_info.type = type_info_to_thrift(target_info.sql_type);
255  thrift_target_info.arg_type = takes_arg(target_info)
256  ? type_info_to_thrift(target_info.agg_arg_type)
257  : thrift_target_info.type;
258  thrift_target_info.skip_nulls = target_info.skip_null_val;
259  thrift_target_info.is_distinct = target_info.is_distinct;
260  return thrift_target_info;
261 }
262 
263 inline TargetInfo target_info_from_thrift(const TTargetInfo& thrift_target_info) {
264  TargetInfo target_info;
265  target_info.is_agg = thrift_target_info.is_agg;
266  target_info.agg_kind = agg_kind_from_thrift(thrift_target_info.kind);
267  target_info.sql_type = type_info_from_thrift(thrift_target_info.type);
268  target_info.is_distinct = thrift_target_info.is_distinct;
269  target_info.agg_arg_type = takes_arg(target_info)
270  ? type_info_from_thrift(thrift_target_info.arg_type)
271  : SQLTypeInfo(kNULLT, false);
272  target_info.skip_null_val = thrift_target_info.skip_nulls;
273  return target_info;
274 }
275 
276 inline std::vector<TTargetInfo> target_infos_to_thrift(
277  const std::vector<TargetInfo>& targets) {
278  std::vector<TTargetInfo> thrift_targets;
279  for (const auto& target_info : targets) {
280  thrift_targets.push_back(target_info_to_thrift(target_info));
281  }
282  return thrift_targets;
283 }
284 
285 inline std::vector<TargetInfo> target_infos_from_thrift(
286  const std::vector<TTargetInfo>& thrift_targets) {
287  std::vector<TargetInfo> targets;
288  for (const auto& thrift_target_info : thrift_targets) {
289  targets.push_back(target_info_from_thrift(thrift_target_info));
290  }
291  return targets;
292 }
293 
294 #define THRIFT_COUNTDESCRIPTORIMPL_CASE(kind) \
295  case CountDistinctImplType::kind: \
296  return TCountDistinctImplType::kind;
297 
299  const CountDistinctImplType impl_type) {
300  switch (impl_type) {
304  default:
305  CHECK(false);
306  }
307  abort();
308 }
309 
310 #undef THRIFT_COUNTDESCRIPTORIMPL_CASE
311 
312 inline TCountDistinctDescriptor count_distinct_descriptor_to_thrift(
313  const CountDistinctDescriptor& count_distinct_descriptor) {
314  TCountDistinctDescriptor thrift_count_distinct_descriptor;
315  thrift_count_distinct_descriptor.impl_type =
316  count_distinct_impl_type_to_thrift(count_distinct_descriptor.impl_type_);
317  thrift_count_distinct_descriptor.min_val = count_distinct_descriptor.min_val;
318  thrift_count_distinct_descriptor.bitmap_sz_bits =
319  count_distinct_descriptor.bitmap_sz_bits;
320  thrift_count_distinct_descriptor.approximate = count_distinct_descriptor.approximate;
321  thrift_count_distinct_descriptor.device_type =
322  count_distinct_descriptor.device_type == ExecutorDeviceType::GPU ? TDeviceType::GPU
323  : TDeviceType::CPU;
324  thrift_count_distinct_descriptor.sub_bitmap_count =
325  count_distinct_descriptor.sub_bitmap_count;
326  return thrift_count_distinct_descriptor;
327 }
328 
329 #define UNTHRIFT_COUNTDESCRIPTORIMPL_CASE(kind) \
330  case TCountDistinctImplType::kind: \
331  return CountDistinctImplType::kind;
332 
334  const TCountDistinctImplType::type impl_type) {
335  switch (impl_type) {
339  default:
340  CHECK(false);
341  }
342  abort();
343 }
344 
345 #undef UNTHRIFT_COUNTDESCRIPTORIMPL_CASE
346 
348  const TCountDistinctDescriptor& thrift_count_distinct_descriptor) {
349  CountDistinctDescriptor count_distinct_descriptor;
350  count_distinct_descriptor.impl_type_ =
351  count_distinct_impl_type_from_thrift(thrift_count_distinct_descriptor.impl_type);
352  count_distinct_descriptor.min_val = thrift_count_distinct_descriptor.min_val;
353  count_distinct_descriptor.bitmap_sz_bits =
354  thrift_count_distinct_descriptor.bitmap_sz_bits;
355  count_distinct_descriptor.approximate = thrift_count_distinct_descriptor.approximate;
356  count_distinct_descriptor.device_type =
357  thrift_count_distinct_descriptor.device_type == TDeviceType::GPU
360  count_distinct_descriptor.sub_bitmap_count =
361  thrift_count_distinct_descriptor.sub_bitmap_count;
362  return count_distinct_descriptor;
363 }
364 
366  switch (t) {
367  case TExtArgumentType::Int8:
368  return ExtArgumentType::Int8;
369  case TExtArgumentType::Int16:
370  return ExtArgumentType::Int16;
371  case TExtArgumentType::Int32:
372  return ExtArgumentType::Int32;
373  case TExtArgumentType::Int64:
374  return ExtArgumentType::Int64;
375  case TExtArgumentType::Float:
376  return ExtArgumentType::Float;
379  case TExtArgumentType::Void:
380  return ExtArgumentType::Void;
381  case TExtArgumentType::PInt8:
382  return ExtArgumentType::PInt8;
383  case TExtArgumentType::PInt16:
385  case TExtArgumentType::PInt32:
387  case TExtArgumentType::PInt64:
389  case TExtArgumentType::PFloat:
391  case TExtArgumentType::PDouble:
393  case TExtArgumentType::PBool:
394  return ExtArgumentType::PBool;
395  case TExtArgumentType::Bool:
396  return ExtArgumentType::Bool;
397  case TExtArgumentType::ArrayInt8:
399  case TExtArgumentType::ArrayInt16:
401  case TExtArgumentType::ArrayInt32:
403  case TExtArgumentType::ArrayInt64:
405  case TExtArgumentType::ArrayFloat:
407  case TExtArgumentType::ArrayDouble:
409  case TExtArgumentType::ArrayBool:
411  case TExtArgumentType::GeoPoint:
413  case TExtArgumentType::GeoLineString:
415  case TExtArgumentType::Cursor:
417  case TExtArgumentType::GeoPolygon:
419  case TExtArgumentType::GeoMultiPolygon:
421  case TExtArgumentType::ColumnInt8:
423  case TExtArgumentType::ColumnInt16:
425  case TExtArgumentType::ColumnInt32:
427  case TExtArgumentType::ColumnInt64:
429  case TExtArgumentType::ColumnFloat:
431  case TExtArgumentType::ColumnDouble:
433  case TExtArgumentType::ColumnBool:
435  case TExtArgumentType::TextEncodingNone:
437  case TExtArgumentType::TextEncodingDict8:
439  case TExtArgumentType::TextEncodingDict16:
441  case TExtArgumentType::TextEncodingDict32:
443  case TExtArgumentType::ColumnListInt8:
445  case TExtArgumentType::ColumnListInt16:
447  case TExtArgumentType::ColumnListInt32:
449  case TExtArgumentType::ColumnListInt64:
451  case TExtArgumentType::ColumnListFloat:
453  case TExtArgumentType::ColumnListDouble:
455  case TExtArgumentType::ColumnListBool:
457  }
458  UNREACHABLE();
459  return ExtArgumentType{};
460 }
461 
463  switch (t) {
465  return TExtArgumentType::Int8;
467  return TExtArgumentType::Int16;
469  return TExtArgumentType::Int32;
471  return TExtArgumentType::Int64;
473  return TExtArgumentType::Float;
477  return TExtArgumentType::Void;
479  return TExtArgumentType::PInt8;
481  return TExtArgumentType::PInt16;
483  return TExtArgumentType::PInt32;
485  return TExtArgumentType::PInt64;
487  return TExtArgumentType::PFloat;
489  return TExtArgumentType::PDouble;
491  return TExtArgumentType::PBool;
493  return TExtArgumentType::Bool;
495  return TExtArgumentType::ArrayInt8;
497  return TExtArgumentType::ArrayInt16;
499  return TExtArgumentType::ArrayInt32;
501  return TExtArgumentType::ArrayInt64;
503  return TExtArgumentType::ArrayFloat;
505  return TExtArgumentType::ArrayDouble;
507  return TExtArgumentType::ArrayBool;
509  return TExtArgumentType::GeoPoint;
511  return TExtArgumentType::GeoLineString;
513  return TExtArgumentType::Cursor;
515  return TExtArgumentType::GeoPolygon;
517  return TExtArgumentType::GeoMultiPolygon;
519  return TExtArgumentType::ColumnInt8;
521  return TExtArgumentType::ColumnInt16;
523  return TExtArgumentType::ColumnInt32;
525  return TExtArgumentType::ColumnInt64;
527  return TExtArgumentType::ColumnFloat;
529  return TExtArgumentType::ColumnDouble;
531  return TExtArgumentType::ColumnBool;
533  return TExtArgumentType::TextEncodingNone;
535  return TExtArgumentType::TextEncodingDict8;
537  return TExtArgumentType::TextEncodingDict16;
539  return TExtArgumentType::TextEncodingDict32;
541  return TExtArgumentType::ColumnListInt8;
543  return TExtArgumentType::ColumnListInt16;
545  return TExtArgumentType::ColumnListInt32;
547  return TExtArgumentType::ColumnListInt64;
549  return TExtArgumentType::ColumnListFloat;
551  return TExtArgumentType::ColumnListDouble;
553  return TExtArgumentType::ColumnListBool;
554  }
555  UNREACHABLE();
556  return TExtArgumentType::type{};
557 }
558 
559 inline std::vector<ExtArgumentType> from_thrift(
560  const std::vector<TExtArgumentType::type>& v) {
561  std::vector<ExtArgumentType> result;
562  std::transform(
563  v.begin(),
564  v.end(),
565  std::back_inserter(result),
566  [](TExtArgumentType::type c) -> ExtArgumentType { return from_thrift(c); });
567  return result;
568 }
569 
570 inline std::vector<TExtArgumentType::type> to_thrift(
571  const std::vector<ExtArgumentType>& v) {
572  std::vector<TExtArgumentType::type> result;
573  std::transform(
574  v.begin(),
575  v.end(),
576  std::back_inserter(result),
577  [](ExtArgumentType c) -> TExtArgumentType::type { return to_thrift(c); });
578  return result;
579 }
580 
583  switch (t) {
584  case TOutputBufferSizeType::kConstant:
586  case TOutputBufferSizeType::kUserSpecifiedConstantParameter:
588  case TOutputBufferSizeType::kUserSpecifiedRowMultiplier:
590  }
591  UNREACHABLE();
593 }
594 
597  switch (t) {
599  return TOutputBufferSizeType::kConstant;
601  return TOutputBufferSizeType::kUserSpecifiedConstantParameter;
603  return TOutputBufferSizeType::kUserSpecifiedRowMultiplier;
604  }
605  UNREACHABLE();
607 }
608 
609 inline TUserDefinedTableFunction to_thrift(const table_functions::TableFunction& func) {
610  TUserDefinedTableFunction tfunc;
611  tfunc.name = func.getName();
612  tfunc.sizerType = to_thrift(func.getOutputRowSizeType());
613  tfunc.sizerArgPos = func.getOutputRowSizeParameter();
614  tfunc.inputArgTypes = to_thrift(func.getInputArgs());
615  tfunc.outputArgTypes = to_thrift(func.getOutputArgs());
616  tfunc.sqlArgTypes = to_thrift(func.getSqlArgs());
617  return tfunc;
618 }
619 
620 inline std::vector<TUserDefinedTableFunction> to_thrift(
621  const std::vector<table_functions::TableFunction>& v) {
622  std::vector<TUserDefinedTableFunction> result;
623  std::transform(v.begin(),
624  v.end(),
625  std::back_inserter(result),
626  [](table_functions::TableFunction c) -> TUserDefinedTableFunction {
627  return to_thrift(c);
628  });
629  return result;
630 }
631 
632 } // namespace ThriftSerializers
633 
634 #endif // QUERYENGINE_THRIFTSERIALIZERS_H
TCountDistinctImplType::type count_distinct_impl_type_to_thrift(const CountDistinctImplType impl_type)
AggregatedColRange column_ranges_from_thrift(const std::vector< TColumnRange > &thrift_column_ranges)
std::vector< TTargetInfo > target_infos_to_thrift(const std::vector< TargetInfo > &targets)
HOST DEVICE SQLTypes get_subtype() const
Definition: sqltypes.h:315
SQLAgg
Definition: sqldefs.h:71
StringDictionaryGenerations string_dictionary_generations_from_thrift(const std::vector< TDictionaryGeneration > &thrift_string_dictionary_generations)
HOST DEVICE int get_size() const
Definition: sqltypes.h:324
Descriptor for the storage layout use for (approximate) count distinct operations.
TDatumType::type type_to_thrift(const SQLTypeInfo &type_info)
SQLTypes
Definition: sqltypes.h:37
#define UNTHRIFT_AGGKIND_CASE(kind)
TCountDistinctDescriptor count_distinct_descriptor_to_thrift(const CountDistinctDescriptor &count_distinct_descriptor)
TRowDescriptor target_meta_infos_to_thrift(const std::vector< TargetMetaInfo > &targets)
QueryDescriptionType layout_from_thrift(const TResultSetLayout::type layout)
TargetInfo target_info_from_thrift(const TTargetInfo &thrift_target_info)
SQLTypeInfo sql_type
Definition: TargetInfo.h:42
HOST DEVICE int get_scale() const
Definition: sqltypes.h:319
CountDistinctDescriptor count_distinct_descriptor_from_thrift(const TCountDistinctDescriptor &thrift_count_distinct_descriptor)
#define DOUBLE
#define UNREACHABLE()
Definition: Logger.h:241
ExtArgumentType from_thrift(const TExtArgumentType::type &t)
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:314
bool skip_null_val
Definition: TargetInfo.h:44
CountDistinctImplType impl_type_
const SQLTypeInfo & get_type_info() const
static ExpressionRange makeFloatRange(const float fp_min, const float fp_max, const bool has_nulls)
std::string to_string(char const *&&v)
SQLTypeInfo agg_arg_type
Definition: TargetInfo.h:43
std::vector< TargetInfo > target_infos_from_thrift(const std::vector< TTargetInfo > &thrift_targets)
bool is_agg
Definition: TargetInfo.h:40
void setGeneration(const uint32_t id, const uint64_t generation)
bool is_distinct_target(const TargetInfo &target_info)
Definition: TargetInfo.h:130
const std::vector< ExtArgumentType > & getOutputArgs() const
SQLTypeInfo type_info_from_thrift(const TTypeInfo &thrift_ti, const bool strip_geo_encoding=false)
SQLAgg agg_kind_from_thrift(const TAggKind::type agg)
SQLAgg agg_kind
Definition: TargetInfo.h:41
int get_precision() const
Definition: sqltypes.h:317
static ExpressionRange makeIntRange(const int64_t int_min, const int64_t int_max, const int64_t bucket, const bool has_nulls)
void fixup_geo_column_descriptor(TColumnType &col_type, const SQLTypes subtype, const int output_srid)
#define THRIFT_COUNTDESCRIPTORIMPL_CASE(kind)
static ExpressionRange makeDoubleRange(const double fp_min, const double fp_max, const bool has_nulls)
Definition: sqltypes.h:52
TExtArgumentType::type to_thrift(const ExtArgumentType &t)
CountDistinctImplType count_distinct_impl_type_from_thrift(const TCountDistinctImplType::type impl_type)
#define UNTHRIFT_COUNTDESCRIPTORIMPL_CASE(kind)
Definition: sqldefs.h:76
const std::vector< ExtArgumentType > & getInputArgs() const
bool takes_arg(const TargetInfo &target_info)
TColumnType target_meta_info_to_thrift(const TargetMetaInfo &target, const size_t idx)
CountDistinctImplType
HOST DEVICE int get_comp_param() const
Definition: sqltypes.h:323
const std::vector< ExtArgumentType > & getSqlArgs() const
#define CHECK(condition)
Definition: Logger.h:197
char * t
SQLTypes type
Definition: sqltypes.h:745
QueryDescriptionType
Definition: Types.h:26
std::vector< TargetMetaInfo > target_meta_infos_from_thrift(const TRowDescriptor &row_desc)
TAggKind::type agg_kind_to_thrift(const SQLAgg agg)
void setColRange(const PhysicalInput &, const ExpressionRange &)
TResultSetLayout::type layout_to_thrift(const QueryDescriptionType layout)
static ExpressionRange makeInvalidRange()
const std::string & get_resname() const
#define THRIFT_LAYOUT_CASE(layout)
bool is_distinct
Definition: TargetInfo.h:45
HOST DEVICE bool get_notnull() const
Definition: sqltypes.h:321
#define FLOAT
TTypeInfo type_info_to_thrift(const SQLTypeInfo &ti)
SQLTypeInfo get_elem_type() const
Definition: sqltypes.h:712
OutputBufferSizeType getOutputRowSizeType() const
#define UNTHRIFT_LAYOUT_CASE(layout)
#define IS_GEO(T)
Definition: sqltypes.h:245
#define THRIFT_AGGKIND_CASE(kind)
bool is_array() const
Definition: sqltypes.h:496
TTargetInfo target_info_to_thrift(const TargetInfo &target_info)
TEncodingType::type encoding_to_thrift(const SQLTypeInfo &type_info)
#define INTEGER