Function readColumns

bolt/serializers/PrestoSerializer.cpp:1105–1179

}

void readColumns(
    ByteInputStream* source,
    bolt::memory::MemoryPool* pool,
    const std::vector<TypePtr>& types,
    std::vector<VectorPtr>& results,
    vector_size_t resultOffset,
    bool useLosslessTimestamp) {
  static const std::unordered_map<
      TypeKind,
      std::function<void(
          ByteInputStream * source,
          const TypePtr& type,
          bolt::memory::MemoryPool* pool,
          VectorPtr& result,
          vector_size_t resultOffset,
          bool useLosslessTimestamp)>>
      readers = {
          {TypeKind::BOOLEAN, &read<bool>},
          {TypeKind::TINYINT, &read<int8_t>},
          {TypeKind::SMALLINT, &read<int16_t>},
          {TypeKind::INTEGER, &read<int32_t>},
          {TypeKind::BIGINT, &read<int64_t>},
          {TypeKind::HUGEINT, &read<int128_t>},
          {TypeKind::REAL, &read<float>},
          {TypeKind::DOUBLE, &read<double>},
          {TypeKind::TIMESTAMP, &read<Timestamp>},
          {TypeKind::VARCHAR, &read<StringView>},
          {TypeKind::VARBINARY, &read<StringView>},
          {TypeKind::ARRAY, &readArrayVector},
          {TypeKind::MAP, &readMapVector},
          {TypeKind::ROW, &readRowVector},
          {TypeKind::VARIANT, &readRowVector},
          {TypeKind::UNKNOWN, &read<UnknownValue>}};

  BOLT_CHECK_EQ(types.size(), results.size());

  for (int32_t i = 0; i < types.size(); ++i) {
    const auto& columnType = types[i];
    auto& columnResult = results[i];

    const auto encoding = readLengthPrefixedString(source);
    if (encoding == kRLE) {
      readConstantVector(
          source,
          columnType,
          pool,
          columnResult,
          resultOffset,
          useLosslessTimestamp);
    } else if (encoding == kDictionary) {
      readDictionaryVector(
          source,
          columnType,
          pool,
          columnResult,
          resultOffset,
          useLosslessTimestamp);
    } else {