ThriftSerializers Namespace Reference

Functions
TResultSetLayout::type	layout_to_thrift (const QueryDescriptionType layout)
QueryDescriptionType	layout_from_thrift (const TResultSetLayout::type layout)
TAggKind::type	agg_kind_to_thrift (const SQLAgg agg)
SQLAgg	agg_kind_from_thrift (const TAggKind::type agg)
AggregatedColRange	column_ranges_from_thrift (const std::vector< TColumnRange > &thrift_column_ranges)
StringDictionaryGenerations	string_dictionary_generations_from_thrift (const std::vector< TDictionaryGeneration > &thrift_string_dictionary_generations)
TTypeInfo	type_info_to_thrift (const SQLTypeInfo &ti)
bool	takes_arg (const TargetInfo &target_info)
std::vector< TargetMetaInfo >	target_meta_infos_from_thrift (const TRowDescriptor &row_desc)
void	fixup_geo_column_descriptor (TColumnType &col_type, const SQLTypes subtype, const int output_srid)
TColumnType	target_meta_info_to_thrift (const TargetMetaInfo &target, const size_t idx)
TRowDescriptor	target_meta_infos_to_thrift (const std::vector< TargetMetaInfo > &targets)
TTargetInfo	target_info_to_thrift (const TargetInfo &target_info)
TargetInfo	target_info_from_thrift (const TTargetInfo &thrift_target_info)
std::vector< TTargetInfo >	target_infos_to_thrift (const std::vector< TargetInfo > &targets)
std::vector< TargetInfo >	target_infos_from_thrift (const std::vector< TTargetInfo > &thrift_targets)
TCountDistinctImplType::type	count_distinct_impl_type_to_thrift (const CountDistinctImplType impl_type)
TCountDistinctDescriptor	count_distinct_descriptor_to_thrift (const CountDistinctDescriptor &count_distinct_descriptor)
CountDistinctImplType	count_distinct_impl_type_from_thrift (const TCountDistinctImplType::type impl_type)
CountDistinctDescriptor	count_distinct_descriptor_from_thrift (const TCountDistinctDescriptor &thrift_count_distinct_descriptor)
ExtArgumentType	from_thrift (const TExtArgumentType::type &t)
TExtArgumentType::type	to_thrift (const ExtArgumentType &t)
std::vector< ExtArgumentType >	from_thrift (const std::vector< TExtArgumentType::type > &v)
std::vector < TExtArgumentType::type >	to_thrift (const std::vector< ExtArgumentType > &v)
table_functions::OutputBufferSizeType	from_thrift (const TOutputBufferSizeType::type &t)
TOutputBufferSizeType::type	to_thrift (const table_functions::OutputBufferSizeType &t)
TUserDefinedTableFunction	to_thrift (const table_functions::TableFunction &func)
std::vector < TUserDefinedTableFunction >	to_thrift (const std::vector< table_functions::TableFunction > &v)

Function Documentation

SQLAgg ThriftSerializers::agg_kind_from_thrift ( const TAggKind::type  agg )

inline

Definition at line 103 of file ThriftSerializers.h.

References AVG, CHECK, COUNT, MAX, MIN, SUM, and UNTHRIFT_AGGKIND_CASE.

Referenced by target_info_from_thrift().

                                                           {
  switch (agg) {
    UNTHRIFT_AGGKIND_CASE(AVG)
    UNTHRIFT_AGGKIND_CASE(COUNT)
    UNTHRIFT_AGGKIND_CASE(MAX)
    UNTHRIFT_AGGKIND_CASE(MIN)
    UNTHRIFT_AGGKIND_CASE(SUM)
    UNTHRIFT_AGGKIND_CASE(APPROX_COUNT_DISTINCT)
    UNTHRIFT_AGGKIND_CASE(SAMPLE)
    UNTHRIFT_AGGKIND_CASE(SINGLE_VALUE)
    default:
      CHECK(false) << static_cast<int>(agg);
  }
  abort();
}

Here is the caller graph for this function:

TAggKind::type ThriftSerializers::agg_kind_to_thrift ( const SQLAgg  agg )

inline

Definition at line 81 of file ThriftSerializers.h.

References AVG, CHECK, COUNT, MAX, MIN, SUM, and THRIFT_AGGKIND_CASE.

Referenced by target_info_to_thrift().

                                                         {
  switch (agg) {
    THRIFT_AGGKIND_CASE(AVG)
    THRIFT_AGGKIND_CASE(COUNT)
    THRIFT_AGGKIND_CASE(MAX)
    THRIFT_AGGKIND_CASE(MIN)
    THRIFT_AGGKIND_CASE(SUM)
    THRIFT_AGGKIND_CASE(APPROX_COUNT_DISTINCT)
    THRIFT_AGGKIND_CASE(SAMPLE)
    THRIFT_AGGKIND_CASE(SINGLE_VALUE)
    default:
      CHECK(false) << static_cast<int>(agg);
  }
  abort();
}

Here is the caller graph for this function:

AggregatedColRange ThriftSerializers::column_ranges_from_thrift ( const std::vector< TColumnRange > &  thrift_column_ranges )

inline

Definition at line 121 of file ThriftSerializers.h.

References CHECK, PhysicalInput::col_id, DOUBLE, FLOAT, INTEGER, ExpressionRange::makeDoubleRange(), ExpressionRange::makeFloatRange(), ExpressionRange::makeIntRange(), ExpressionRange::makeInvalidRange(), and AggregatedColRange::setColRange().

                                                         {
  AggregatedColRange column_ranges;
  for (const auto& thrift_column_range : thrift_column_ranges) {
    PhysicalInput phys_input{thrift_column_range.col_id, thrift_column_range.table_id};
    switch (thrift_column_range.type) {
      case TExpressionRangeType::INTEGER:
        column_ranges.setColRange(
            phys_input,
            ExpressionRange::makeIntRange(thrift_column_range.int_min,
                                          thrift_column_range.int_max,
                                          thrift_column_range.bucket,
                                          thrift_column_range.has_nulls));
        break;
      case TExpressionRangeType::FLOAT:
        column_ranges.setColRange(
            phys_input,
            ExpressionRange::makeFloatRange(thrift_column_range.fp_min,
                                            thrift_column_range.fp_max,
                                            thrift_column_range.has_nulls));
        break;
      case TExpressionRangeType::DOUBLE:
        column_ranges.setColRange(
            phys_input,
            ExpressionRange::makeDoubleRange(thrift_column_range.fp_min,
                                             thrift_column_range.fp_max,
                                             thrift_column_range.has_nulls));
        break;
      case TExpressionRangeType::INVALID:
        column_ranges.setColRange(phys_input, ExpressionRange::makeInvalidRange());
        break;
      default:
        CHECK(false);
    }
  }
  return column_ranges;
}

Here is the call graph for this function:

CountDistinctDescriptor ThriftSerializers::count_distinct_descriptor_from_thrift ( const TCountDistinctDescriptor &  thrift_count_distinct_descriptor )

inline

Definition at line 347 of file ThriftSerializers.h.

References CountDistinctDescriptor::approximate, CountDistinctDescriptor::bitmap_sz_bits, count_distinct_impl_type_from_thrift(), CPU, CountDistinctDescriptor::device_type, GPU, CountDistinctDescriptor::impl_type_, CountDistinctDescriptor::min_val, and CountDistinctDescriptor::sub_bitmap_count.

                                                                      {
  CountDistinctDescriptor count_distinct_descriptor;
  count_distinct_descriptor.impl_type_ =
      count_distinct_impl_type_from_thrift(thrift_count_distinct_descriptor.impl_type);
  count_distinct_descriptor.min_val = thrift_count_distinct_descriptor.min_val;
  count_distinct_descriptor.bitmap_sz_bits =
      thrift_count_distinct_descriptor.bitmap_sz_bits;
  count_distinct_descriptor.approximate = thrift_count_distinct_descriptor.approximate;
  count_distinct_descriptor.device_type =
      thrift_count_distinct_descriptor.device_type == TDeviceType::GPU
          ? ExecutorDeviceType::GPU
          : ExecutorDeviceType::CPU;
  count_distinct_descriptor.sub_bitmap_count =
      thrift_count_distinct_descriptor.sub_bitmap_count;
  return count_distinct_descriptor;
}

Here is the call graph for this function:

TCountDistinctDescriptor ThriftSerializers::count_distinct_descriptor_to_thrift ( const CountDistinctDescriptor &  count_distinct_descriptor )

inline

Definition at line 312 of file ThriftSerializers.h.

References CountDistinctDescriptor::approximate, CountDistinctDescriptor::bitmap_sz_bits, count_distinct_impl_type_to_thrift(), CountDistinctDescriptor::device_type, GPU, CountDistinctDescriptor::impl_type_, CountDistinctDescriptor::min_val, and CountDistinctDescriptor::sub_bitmap_count.

                                                              {
  TCountDistinctDescriptor thrift_count_distinct_descriptor;
  thrift_count_distinct_descriptor.impl_type =
      count_distinct_impl_type_to_thrift(count_distinct_descriptor.impl_type_);
  thrift_count_distinct_descriptor.min_val = count_distinct_descriptor.min_val;
  thrift_count_distinct_descriptor.bitmap_sz_bits =
      count_distinct_descriptor.bitmap_sz_bits;
  thrift_count_distinct_descriptor.approximate = count_distinct_descriptor.approximate;
  thrift_count_distinct_descriptor.device_type =
      count_distinct_descriptor.device_type == ExecutorDeviceType::GPU ? TDeviceType::GPU
                                                                       : TDeviceType::CPU;
  thrift_count_distinct_descriptor.sub_bitmap_count =
      count_distinct_descriptor.sub_bitmap_count;
  return thrift_count_distinct_descriptor;
}

Here is the call graph for this function:

CountDistinctImplType ThriftSerializers::count_distinct_impl_type_from_thrift ( const TCountDistinctImplType::type  impl_type )

inline

Definition at line 333 of file ThriftSerializers.h.

References Bitmap, CHECK, Invalid, StdSet, and UNTHRIFT_COUNTDESCRIPTORIMPL_CASE.

Referenced by count_distinct_descriptor_from_thrift().

                                                {
  switch (impl_type) {
    UNTHRIFT_COUNTDESCRIPTORIMPL_CASE(Invalid)
    UNTHRIFT_COUNTDESCRIPTORIMPL_CASE(Bitmap)
    UNTHRIFT_COUNTDESCRIPTORIMPL_CASE(StdSet)
    default:
      CHECK(false);
  }
  abort();
}

Here is the caller graph for this function:

TCountDistinctImplType::type ThriftSerializers::count_distinct_impl_type_to_thrift ( const CountDistinctImplType  impl_type )

inline

Definition at line 298 of file ThriftSerializers.h.

References Bitmap, CHECK, Invalid, StdSet, and THRIFT_COUNTDESCRIPTORIMPL_CASE.

Referenced by count_distinct_descriptor_to_thrift().

                                           {
  switch (impl_type) {
    THRIFT_COUNTDESCRIPTORIMPL_CASE(Invalid)
    THRIFT_COUNTDESCRIPTORIMPL_CASE(Bitmap)
    THRIFT_COUNTDESCRIPTORIMPL_CASE(StdSet)
    default:
      CHECK(false);
  }
  abort();
}

Here is the caller graph for this function:

void ThriftSerializers::fixup_geo_column_descriptor ( TColumnType &  col_type, const SQLTypes  subtype, const int  output_srid  )

inline

Definition at line 203 of file ThriftSerializers.h.

Referenced by DBHandler::populateThriftColumnType(), and target_meta_info_to_thrift().

                                                               {
  col_type.col_type.precision = static_cast<int>(subtype);
  col_type.col_type.scale = output_srid;
}

Here is the caller graph for this function:

ExtArgumentType ThriftSerializers::from_thrift ( const TExtArgumentType::type &  t )

inline

Definition at line 365 of file ThriftSerializers.h.

References ArrayBool, ArrayDouble, ArrayFloat, ArrayInt16, ArrayInt32, ArrayInt64, ArrayInt8, Bool, ColumnBool, ColumnDouble, ColumnFloat, ColumnInt16, ColumnInt32, ColumnInt64, ColumnInt8, ColumnListBool, ColumnListDouble, ColumnListFloat, ColumnListInt16, ColumnListInt32, ColumnListInt64, ColumnListInt8, ColumnListTextEncodingDict, ColumnTextEncodingDict, Cursor, Double, Float, GeoLineString, GeoMultiPolygon, GeoPoint, GeoPolygon, Int16, Int32, Int64, Int8, PBool, PDouble, PFloat, PInt16, PInt32, PInt64, PInt8, TextEncodingDict, TextEncodingNone, UNREACHABLE, and Void.

Referenced by from_thrift(), and DBHandler::register_runtime_extension_functions().

                                                                  {
  switch (t) {
    case TExtArgumentType::Int8:
      return ExtArgumentType::Int8;
    case TExtArgumentType::Int16:
      return ExtArgumentType::Int16;
    case TExtArgumentType::Int32:
      return ExtArgumentType::Int32;
    case TExtArgumentType::Int64:
      return ExtArgumentType::Int64;
    case TExtArgumentType::Float:
      return ExtArgumentType::Float;
    case TExtArgumentType::Double:
      return ExtArgumentType::Double;
    case TExtArgumentType::Void:
      return ExtArgumentType::Void;
    case TExtArgumentType::PInt8:
      return ExtArgumentType::PInt8;
    case TExtArgumentType::PInt16:
      return ExtArgumentType::PInt16;
    case TExtArgumentType::PInt32:
      return ExtArgumentType::PInt32;
    case TExtArgumentType::PInt64:
      return ExtArgumentType::PInt64;
    case TExtArgumentType::PFloat:
      return ExtArgumentType::PFloat;
    case TExtArgumentType::PDouble:
      return ExtArgumentType::PDouble;
    case TExtArgumentType::PBool:
      return ExtArgumentType::PBool;
    case TExtArgumentType::Bool:
      return ExtArgumentType::Bool;
    case TExtArgumentType::ArrayInt8:
      return ExtArgumentType::ArrayInt8;
    case TExtArgumentType::ArrayInt16:
      return ExtArgumentType::ArrayInt16;
    case TExtArgumentType::ArrayInt32:
      return ExtArgumentType::ArrayInt32;
    case TExtArgumentType::ArrayInt64:
      return ExtArgumentType::ArrayInt64;
    case TExtArgumentType::ArrayFloat:
      return ExtArgumentType::ArrayFloat;
    case TExtArgumentType::ArrayDouble:
      return ExtArgumentType::ArrayDouble;
    case TExtArgumentType::ArrayBool:
      return ExtArgumentType::ArrayBool;
    case TExtArgumentType::GeoPoint:
      return ExtArgumentType::GeoPoint;
    case TExtArgumentType::GeoLineString:
      return ExtArgumentType::GeoLineString;
    case TExtArgumentType::Cursor:
      return ExtArgumentType::Cursor;
    case TExtArgumentType::GeoPolygon:
      return ExtArgumentType::GeoPolygon;
    case TExtArgumentType::GeoMultiPolygon:
      return ExtArgumentType::GeoMultiPolygon;
    case TExtArgumentType::ColumnInt8:
      return ExtArgumentType::ColumnInt8;
    case TExtArgumentType::ColumnInt16:
      return ExtArgumentType::ColumnInt16;
    case TExtArgumentType::ColumnInt32:
      return ExtArgumentType::ColumnInt32;
    case TExtArgumentType::ColumnInt64:
      return ExtArgumentType::ColumnInt64;
    case TExtArgumentType::ColumnFloat:
      return ExtArgumentType::ColumnFloat;
    case TExtArgumentType::ColumnDouble:
      return ExtArgumentType::ColumnDouble;
    case TExtArgumentType::ColumnBool:
      return ExtArgumentType::ColumnBool;
    case TExtArgumentType::ColumnTextEncodingDict:
      return ExtArgumentType::ColumnTextEncodingDict;
    case TExtArgumentType::TextEncodingNone:
      return ExtArgumentType::TextEncodingNone;
    case TExtArgumentType::TextEncodingDict:
      return ExtArgumentType::TextEncodingDict;
    case TExtArgumentType::ColumnListInt8:
      return ExtArgumentType::ColumnListInt8;
    case TExtArgumentType::ColumnListInt16:
      return ExtArgumentType::ColumnListInt16;
    case TExtArgumentType::ColumnListInt32:
      return ExtArgumentType::ColumnListInt32;
    case TExtArgumentType::ColumnListInt64:
      return ExtArgumentType::ColumnListInt64;
    case TExtArgumentType::ColumnListFloat:
      return ExtArgumentType::ColumnListFloat;
    case TExtArgumentType::ColumnListDouble:
      return ExtArgumentType::ColumnListDouble;
    case TExtArgumentType::ColumnListBool:
      return ExtArgumentType::ColumnListBool;
    case TExtArgumentType::ColumnListTextEncodingDict:
      return ExtArgumentType::ColumnListTextEncodingDict;
  }
  UNREACHABLE();
  return ExtArgumentType{};
}

Here is the caller graph for this function:

std::vector<ExtArgumentType> ThriftSerializers::from_thrift ( const std::vector< TExtArgumentType::type > &  v )

inline

Definition at line 559 of file ThriftSerializers.h.

References from_thrift(), run_benchmark_import::result, and run_benchmark_import::type.

                                              {
  std::vector<ExtArgumentType> result;
  std::transform(
      v.begin(),
      v.end(),
      std::back_inserter(result),
      [](TExtArgumentType::type c) -> ExtArgumentType { return from_thrift(c); });
  return result;
}

Here is the call graph for this function:

table_functions::OutputBufferSizeType ThriftSerializers::from_thrift ( const TOutputBufferSizeType::type &  t )

inline

Definition at line 581 of file ThriftSerializers.h.

References table_functions::kConstant, table_functions::kTableFunctionSpecifiedParameter, table_functions::kUserSpecifiedConstantParameter, table_functions::kUserSpecifiedRowMultiplier, and UNREACHABLE.

                                        {
  switch (t) {
    case TOutputBufferSizeType::kConstant:
      return table_functions::OutputBufferSizeType::kConstant;
    case TOutputBufferSizeType::kUserSpecifiedConstantParameter:
      return table_functions::OutputBufferSizeType::kUserSpecifiedConstantParameter;
    case TOutputBufferSizeType::kUserSpecifiedRowMultiplier:
      return table_functions::OutputBufferSizeType::kUserSpecifiedRowMultiplier;
    case TOutputBufferSizeType::kTableFunctionSpecifiedParameter:
      return table_functions::OutputBufferSizeType::kTableFunctionSpecifiedParameter;
  }
  UNREACHABLE();
  return table_functions::OutputBufferSizeType{};
}

QueryDescriptionType ThriftSerializers::layout_from_thrift ( const TResultSetLayout::type  layout )

inline

Definition at line 63 of file ThriftSerializers.h.

References CHECK, GroupByBaselineHash, GroupByPerfectHash, NonGroupedAggregate, Projection, and UNTHRIFT_LAYOUT_CASE.

                                                                                  {
  switch (layout) {
    UNTHRIFT_LAYOUT_CASE(GroupByPerfectHash)
    UNTHRIFT_LAYOUT_CASE(GroupByBaselineHash)
    UNTHRIFT_LAYOUT_CASE(Projection)
    UNTHRIFT_LAYOUT_CASE(NonGroupedAggregate)
    default:
      CHECK(false) << static_cast<int>(layout);
  }
  abort();
}

TResultSetLayout::type ThriftSerializers::layout_to_thrift ( const QueryDescriptionType  layout )

inline

Definition at line 45 of file ThriftSerializers.h.

References CHECK, GroupByBaselineHash, GroupByPerfectHash, NonGroupedAggregate, Projection, and THRIFT_LAYOUT_CASE.

                                                                                {
  switch (layout) {
    THRIFT_LAYOUT_CASE(GroupByPerfectHash)
    THRIFT_LAYOUT_CASE(GroupByBaselineHash)
    THRIFT_LAYOUT_CASE(Projection)
    THRIFT_LAYOUT_CASE(NonGroupedAggregate)
    default:
      CHECK(false) << static_cast<int>(layout);
  }
  abort();
}

StringDictionaryGenerations ThriftSerializers::string_dictionary_generations_from_thrift ( const std::vector< TDictionaryGeneration > &  thrift_string_dictionary_generations )

inline

Definition at line 159 of file ThriftSerializers.h.

References StringDictionaryGenerations::setGeneration().

                                                                                  {
  StringDictionaryGenerations string_dictionary_generations;
  for (const auto& thrift_string_dictionary_generation :
       thrift_string_dictionary_generations) {
    string_dictionary_generations.setGeneration(
        thrift_string_dictionary_generation.dict_id,
        thrift_string_dictionary_generation.entry_count);
  }
  return string_dictionary_generations;
}

Here is the call graph for this function:

bool ThriftSerializers::takes_arg ( const TargetInfo &  target_info )

inline

Definition at line 189 of file ThriftSerializers.h.

References TargetInfo::agg_kind, TargetInfo::is_agg, is_distinct_target(), and kCOUNT.

Referenced by target_info_from_thrift(), target_info_to_thrift(), and RelAlgTranslator::translateAggregateRex().

                                                     {
  return target_info.is_agg &&
         (target_info.agg_kind != kCOUNT || is_distinct_target(target_info));
}

Here is the call graph for this function:

Here is the caller graph for this function:

TargetInfo ThriftSerializers::target_info_from_thrift ( const TTargetInfo &  thrift_target_info )

inline

Definition at line 263 of file ThriftSerializers.h.

References TargetInfo::agg_arg_type, TargetInfo::agg_kind, agg_kind_from_thrift(), TargetInfo::is_agg, TargetInfo::is_distinct, kNULLT, TargetInfo::skip_null_val, TargetInfo::sql_type, takes_arg(), and type_info_from_thrift().

Referenced by target_infos_from_thrift().

                                                                                 {
  TargetInfo target_info;
  target_info.is_agg = thrift_target_info.is_agg;
  target_info.agg_kind = agg_kind_from_thrift(thrift_target_info.kind);
  target_info.sql_type = type_info_from_thrift(thrift_target_info.type);
  target_info.is_distinct = thrift_target_info.is_distinct;
  target_info.agg_arg_type = takes_arg(target_info)
                                 ? type_info_from_thrift(thrift_target_info.arg_type)
                                 : SQLTypeInfo(kNULLT, false);
  target_info.skip_null_val = thrift_target_info.skip_nulls;
  return target_info;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TTargetInfo ThriftSerializers::target_info_to_thrift ( const TargetInfo &  target_info )

inline

Definition at line 250 of file ThriftSerializers.h.

References TargetInfo::agg_arg_type, TargetInfo::agg_kind, agg_kind_to_thrift(), TargetInfo::is_agg, TargetInfo::is_distinct, TargetInfo::skip_null_val, TargetInfo::sql_type, takes_arg(), and type_info_to_thrift().

Referenced by target_infos_to_thrift().

                                                                        {
  TTargetInfo thrift_target_info;
  thrift_target_info.is_agg = target_info.is_agg;
  thrift_target_info.kind = agg_kind_to_thrift(target_info.agg_kind);
  thrift_target_info.type = type_info_to_thrift(target_info.sql_type);
  thrift_target_info.arg_type = takes_arg(target_info)
                                    ? type_info_to_thrift(target_info.agg_arg_type)
                                    : thrift_target_info.type;
  thrift_target_info.skip_nulls = target_info.skip_null_val;
  thrift_target_info.is_distinct = target_info.is_distinct;
  return thrift_target_info;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<TargetInfo> ThriftSerializers::target_infos_from_thrift ( const std::vector< TTargetInfo > &  thrift_targets )

inline

Definition at line 285 of file ThriftSerializers.h.

References target_info_from_thrift().

                                                  {
  std::vector<TargetInfo> targets;
  for (const auto& thrift_target_info : thrift_targets) {
    targets.push_back(target_info_from_thrift(thrift_target_info));
  }
  return targets;
}

Here is the call graph for this function:

std::vector<TTargetInfo> ThriftSerializers::target_infos_to_thrift ( const std::vector< TargetInfo > &  targets )

inline

Definition at line 276 of file ThriftSerializers.h.

References target_info_to_thrift().

                                          {
  std::vector<TTargetInfo> thrift_targets;
  for (const auto& target_info : targets) {
    thrift_targets.push_back(target_info_to_thrift(target_info));
  }
  return thrift_targets;
}

Here is the call graph for this function:

TColumnType ThriftSerializers::target_meta_info_to_thrift ( const TargetMetaInfo &  target, const size_t  idx  )

inline

Definition at line 210 of file ThriftSerializers.h.

References encoding_to_thrift(), fixup_geo_column_descriptor(), TargetMetaInfo::get_resname(), TargetMetaInfo::get_type_info(), IS_GEO, kARRAY, kDATE, to_string(), SQLTypeInfo::type, and type_to_thrift().

Referenced by target_meta_infos_to_thrift().

                                                                {
  TColumnType proj_info;
  proj_info.col_name = target.get_resname();
  if (proj_info.col_name.empty()) {
    proj_info.col_name = "result_" + std::to_string(idx + 1);
  }
  const auto& target_ti = target.get_type_info();
  proj_info.col_type.type = type_to_thrift(target_ti);
  proj_info.col_type.encoding = encoding_to_thrift(target_ti);
  proj_info.col_type.nullable = !target_ti.get_notnull();
  proj_info.col_type.is_array = target_ti.get_type() == kARRAY;
  if (IS_GEO(target_ti.get_type())) {
    fixup_geo_column_descriptor(
        proj_info, target_ti.get_subtype(), target_ti.get_output_srid());
  } else {
    proj_info.col_type.precision = target_ti.get_precision();
    proj_info.col_type.scale = target_ti.get_scale();
  }
  if (target_ti.get_type() == kDATE) {
    proj_info.col_type.size = target_ti.get_size();
  }
  proj_info.col_type.comp_param =
      (target_ti.is_date_in_days() && target_ti.get_comp_param() == 0)
          ? 32
          : target_ti.get_comp_param();
  return proj_info;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<TargetMetaInfo> ThriftSerializers::target_meta_infos_from_thrift ( const TRowDescriptor &  row_desc )

inline

Definition at line 194 of file ThriftSerializers.h.

References type_info_from_thrift().

                                    {
  std::vector<TargetMetaInfo> target_meta_infos;
  for (const auto& col : row_desc) {
    target_meta_infos.emplace_back(col.col_name, type_info_from_thrift(col.col_type));
  }
  return target_meta_infos;
}

Here is the call graph for this function:

TRowDescriptor ThriftSerializers::target_meta_infos_to_thrift ( const std::vector< TargetMetaInfo > &  targets )

inline

Definition at line 239 of file ThriftSerializers.h.

References i, and target_meta_info_to_thrift().

Referenced by DBHandler::convertRows().

                                              {
  TRowDescriptor row_desc;
  size_t i = 0;
  for (const auto& target : targets) {
    row_desc.push_back(target_meta_info_to_thrift(target, i));
    ++i;
  }
  return row_desc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TExtArgumentType::type ThriftSerializers::to_thrift ( const ExtArgumentType &  t )

inline

Definition at line 462 of file ThriftSerializers.h.

References ArrayBool, ArrayDouble, ArrayFloat, ArrayInt16, ArrayInt32, ArrayInt64, ArrayInt8, Bool, ColumnBool, ColumnDouble, ColumnFloat, ColumnInt16, ColumnInt32, ColumnInt64, ColumnInt8, ColumnListBool, ColumnListDouble, ColumnListFloat, ColumnListInt16, ColumnListInt32, ColumnListInt64, ColumnListInt8, ColumnListTextEncodingDict, ColumnTextEncodingDict, Cursor, Double, Float, GeoLineString, GeoMultiPolygon, GeoPoint, GeoPolygon, Int16, Int32, Int64, Int8, PBool, PDouble, PFloat, PInt16, PInt32, PInt64, PInt8, TextEncodingDict, TextEncodingNone, run_benchmark_import::type, UNREACHABLE, and Void.

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

                                                                {
  switch (t) {
    case ExtArgumentType::Int8:
      return TExtArgumentType::Int8;
    case ExtArgumentType::Int16:
      return TExtArgumentType::Int16;
    case ExtArgumentType::Int32:
      return TExtArgumentType::Int32;
    case ExtArgumentType::Int64:
      return TExtArgumentType::Int64;
    case ExtArgumentType::Float:
      return TExtArgumentType::Float;
    case ExtArgumentType::Double:
      return TExtArgumentType::Double;
    case ExtArgumentType::Void:
      return TExtArgumentType::Void;
    case ExtArgumentType::PInt8:
      return TExtArgumentType::PInt8;
    case ExtArgumentType::PInt16:
      return TExtArgumentType::PInt16;
    case ExtArgumentType::PInt32:
      return TExtArgumentType::PInt32;
    case ExtArgumentType::PInt64:
      return TExtArgumentType::PInt64;
    case ExtArgumentType::PFloat:
      return TExtArgumentType::PFloat;
    case ExtArgumentType::PDouble:
      return TExtArgumentType::PDouble;
    case ExtArgumentType::PBool:
      return TExtArgumentType::PBool;
    case ExtArgumentType::Bool:
      return TExtArgumentType::Bool;
    case ExtArgumentType::ArrayInt8:
      return TExtArgumentType::ArrayInt8;
    case ExtArgumentType::ArrayInt16:
      return TExtArgumentType::ArrayInt16;
    case ExtArgumentType::ArrayInt32:
      return TExtArgumentType::ArrayInt32;
    case ExtArgumentType::ArrayInt64:
      return TExtArgumentType::ArrayInt64;
    case ExtArgumentType::ArrayFloat:
      return TExtArgumentType::ArrayFloat;
    case ExtArgumentType::ArrayDouble:
      return TExtArgumentType::ArrayDouble;
    case ExtArgumentType::ArrayBool:
      return TExtArgumentType::ArrayBool;
    case ExtArgumentType::GeoPoint:
      return TExtArgumentType::GeoPoint;
    case ExtArgumentType::GeoLineString:
      return TExtArgumentType::GeoLineString;
    case ExtArgumentType::Cursor:
      return TExtArgumentType::Cursor;
    case ExtArgumentType::GeoPolygon:
      return TExtArgumentType::GeoPolygon;
    case ExtArgumentType::GeoMultiPolygon:
      return TExtArgumentType::GeoMultiPolygon;
    case ExtArgumentType::ColumnInt8:
      return TExtArgumentType::ColumnInt8;
    case ExtArgumentType::ColumnInt16:
      return TExtArgumentType::ColumnInt16;
    case ExtArgumentType::ColumnInt32:
      return TExtArgumentType::ColumnInt32;
    case ExtArgumentType::ColumnInt64:
      return TExtArgumentType::ColumnInt64;
    case ExtArgumentType::ColumnFloat:
      return TExtArgumentType::ColumnFloat;
    case ExtArgumentType::ColumnDouble:
      return TExtArgumentType::ColumnDouble;
    case ExtArgumentType::ColumnBool:
      return TExtArgumentType::ColumnBool;
    case ExtArgumentType::ColumnTextEncodingDict:
      return TExtArgumentType::ColumnTextEncodingDict;
    case ExtArgumentType::TextEncodingNone:
      return TExtArgumentType::TextEncodingNone;
    case ExtArgumentType::TextEncodingDict:
      return TExtArgumentType::TextEncodingDict;
    case ExtArgumentType::ColumnListInt8:
      return TExtArgumentType::ColumnListInt8;
    case ExtArgumentType::ColumnListInt16:
      return TExtArgumentType::ColumnListInt16;
    case ExtArgumentType::ColumnListInt32:
      return TExtArgumentType::ColumnListInt32;
    case ExtArgumentType::ColumnListInt64:
      return TExtArgumentType::ColumnListInt64;
    case ExtArgumentType::ColumnListFloat:
      return TExtArgumentType::ColumnListFloat;
    case ExtArgumentType::ColumnListDouble:
      return TExtArgumentType::ColumnListDouble;
    case ExtArgumentType::ColumnListBool:
      return TExtArgumentType::ColumnListBool;
    case ExtArgumentType::ColumnListTextEncodingDict:
      return TExtArgumentType::ColumnListTextEncodingDict;
  }
  UNREACHABLE();
  return TExtArgumentType::type{};
}

Here is the caller graph for this function:

std::vector<TExtArgumentType::type> ThriftSerializers::to_thrift ( const std::vector< ExtArgumentType > &  v )

inline

Definition at line 570 of file ThriftSerializers.h.

References run_benchmark_import::result, to_thrift(), and run_benchmark_import::type.

                                         {
  std::vector<TExtArgumentType::type> result;
  std::transform(
      v.begin(),
      v.end(),
      std::back_inserter(result),
      [](ExtArgumentType c) -> TExtArgumentType::type { return to_thrift(c); });
  return result;
}

Here is the call graph for this function:

TOutputBufferSizeType::type ThriftSerializers::to_thrift ( const table_functions::OutputBufferSizeType &  t )

inline

Definition at line 597 of file ThriftSerializers.h.

References table_functions::kConstant, table_functions::kTableFunctionSpecifiedParameter, table_functions::kUserSpecifiedConstantParameter, table_functions::kUserSpecifiedRowMultiplier, run_benchmark_import::type, and UNREACHABLE.

                                                  {
  switch (t) {
    case table_functions::OutputBufferSizeType::kConstant:
      return TOutputBufferSizeType::kConstant;
    case table_functions::OutputBufferSizeType::kUserSpecifiedConstantParameter:
      return TOutputBufferSizeType::kUserSpecifiedConstantParameter;
    case table_functions::OutputBufferSizeType::kUserSpecifiedRowMultiplier:
      return TOutputBufferSizeType::kUserSpecifiedRowMultiplier;
    case table_functions::OutputBufferSizeType::kTableFunctionSpecifiedParameter:
      return TOutputBufferSizeType::kTableFunctionSpecifiedParameter;
  }
  UNREACHABLE();
  return TOutputBufferSizeType::type{};
}

TUserDefinedTableFunction ThriftSerializers::to_thrift ( const table_functions::TableFunction &  func )

inline

Definition at line 613 of file ThriftSerializers.h.

References table_functions::TableFunction::getAnnotations(), table_functions::TableFunction::getInputArgs(), table_functions::TableFunction::getName(), table_functions::TableFunction::getOutputArgs(), table_functions::TableFunction::getOutputRowSizeParameter(), table_functions::TableFunction::getOutputRowSizeType(), table_functions::TableFunction::getSqlArgs(), and to_thrift().

                                                                                     {
  TUserDefinedTableFunction tfunc;
  tfunc.name = func.getName();
  tfunc.sizerType = to_thrift(func.getOutputRowSizeType());
  tfunc.sizerArgPos = func.getOutputRowSizeParameter();
  tfunc.inputArgTypes = to_thrift(func.getInputArgs());
  tfunc.outputArgTypes = to_thrift(func.getOutputArgs());
  tfunc.sqlArgTypes = to_thrift(func.getSqlArgs());
  tfunc.annotations = func.getAnnotations();
  return tfunc;
}

Here is the call graph for this function:

std::vector<TUserDefinedTableFunction> ThriftSerializers::to_thrift ( const std::vector< table_functions::TableFunction > &  v )

inline

Definition at line 625 of file ThriftSerializers.h.

References run_benchmark_import::result, and to_thrift().

                                                      {
  std::vector<TUserDefinedTableFunction> result;
  std::transform(v.begin(),
                 v.end(),
                 std::back_inserter(result),
                 [](table_functions::TableFunction c) -> TUserDefinedTableFunction {
                   return to_thrift(c);
                 });
  return result;
}

Here is the call graph for this function:

TTypeInfo ThriftSerializers::type_info_to_thrift ( const SQLTypeInfo &  ti )

inline

Definition at line 171 of file ThriftSerializers.h.

References encoding_to_thrift(), SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_elem_type(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_precision(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_size(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), SQLTypeInfo::is_array(), IS_GEO, and type_to_thrift().

Referenced by DBHandler::get_tables_meta_impl(), and target_info_to_thrift().

                                                            {
  TTypeInfo thrift_ti;
  thrift_ti.type =
      ti.is_array() ? type_to_thrift(ti.get_elem_type()) : type_to_thrift(ti);
  thrift_ti.encoding = encoding_to_thrift(ti);
  thrift_ti.nullable = !ti.get_notnull();
  thrift_ti.is_array = ti.is_array();
  // TODO: Properly serialize geospatial subtype. For now, the value in precision is the
  // same as the value in scale; overload the precision field with the subtype of the
  // geospatial type (currently kGEOMETRY or kGEOGRAPHY)
  thrift_ti.precision =
      IS_GEO(ti.get_type()) ? static_cast<int32_t>(ti.get_subtype()) : ti.get_precision();
  thrift_ti.scale = ti.get_scale();
  thrift_ti.comp_param = ti.get_comp_param();
  thrift_ti.size = ti.get_size();
  return thrift_ti;
}

Here is the call graph for this function:

Here is the caller graph for this function: