Require type in FlatVector constructor (#4073)

Summary: Pull Request resolved: #4073

Reviewed By: xiaoxmeng, KarthikTunga, pedroerp

Differential Revision: D43394821

Pulled By: mbasmanova

fbshipit-source-id: 296db54f78c80c59a942cba4aca6bdf14b1b4a3e

velox/dwio/common/FlatMapHelper.h

@@ -67,6 +67,7 @@ void initializeFlatVector(
   if (!vector) {
     vector = std::make_shared<FlatVector<T>>(
         &pool,
+        CppToType<T>::create(),
         hasNulls ? AlignedBuffer::allocate<bool>(size, &pool) : nullptr,
         0 /*length*/,
         AlignedBuffer::allocate<T>(size, &pool),

velox/dwio/common/tests/utils/BatchMaker.cpp

@@ -453,7 +453,12 @@ VectorPtr createScalarMapKeys(
   }
 
   return std::make_shared<FlatVector<T>>(
-      &pool, BufferPtr(nullptr), totalKeys, values, std::vector<BufferPtr>{});
+      &pool,
+      CppToType<T>::create(),
+      BufferPtr(nullptr),
+      totalKeys,
+      values,
+      std::vector<BufferPtr>{});
 }
 
 VectorPtr createBinaryMapKeys(

velox/dwio/common/tests/utils/MapBuilder.h

@@ -29,26 +29,22 @@ class MapBuilder {
   using rows = std::vector<std::optional<row>>;
 
   static VectorPtr create(memory::MemoryPool& pool, rows rows) {
-    const std::shared_ptr<const Type> type =
-        CppToType<Map<TKEY, TVALUE>>::create();
+    const auto type = CppToType<Map<TKEY, TVALUE>>::create();
     auto items = 0;
     for (auto& row : rows) {
       if (row.has_value()) {
         items += row->size();
       }
     }
 
-    BufferPtr nulls =
-        AlignedBuffer::allocate<char>(bits::nbytes(rows.size()), &pool);
+    BufferPtr nulls = allocateNulls(rows.size(), &pool);
     auto* nullsPtr = nulls->asMutable<uint64_t>();
     size_t nullCount = 0;
 
-    BufferPtr offsets =
-        AlignedBuffer::allocate<vector_size_t>(rows.size(), &pool);
+    BufferPtr offsets = allocateOffsets(rows.size(), &pool);
     auto* offsetsPtr = offsets->asMutable<vector_size_t>();
 
-    BufferPtr lengths =
-        AlignedBuffer::allocate<vector_size_t>(rows.size(), &pool);
+    BufferPtr lengths = allocateSizes(rows.size(), &pool);
     auto* lengthsPtr = lengths->asMutable<vector_size_t>();
 
     BufferPtr keys = AlignedBuffer::allocate<TKEY>(items, &pool);
@@ -57,8 +53,7 @@ class MapBuilder {
     BufferPtr values = AlignedBuffer::allocate<TVALUE>(items, &pool);
     auto* valuesPtr = values->asMutable<TVALUE>();
 
-    BufferPtr valueNulls =
-        AlignedBuffer::allocate<char>(bits::nbytes(items), &pool);
+    BufferPtr valueNulls = allocateNulls(items, &pool);
     auto* valueNullsPtr = valueNulls->asMutable<uint64_t>();
     size_t valueNullCount = 0;
 
@@ -103,12 +98,14 @@ class MapBuilder {
         lengths,
         std::make_shared<FlatVector<TKEY>>(
             &pool,
+            type->childAt(0),
             BufferPtr(nullptr),
             items /*length*/,
             keys,
             std::vector<BufferPtr>()),
         std::make_shared<FlatVector<TVALUE>>(
             &pool,
+            type->childAt(1),
             valueNulls,
             items /*length*/,
             values,

velox/dwio/dwrf/reader/ColumnReader.cpp

@@ -234,7 +234,12 @@ VectorPtr makeFlatVector(
     size_t length,
     BufferPtr values) {
   auto flatVector = std::make_shared<FlatVector<T>>(
-      pool, nulls, length, values, std::vector<BufferPtr>());
+      pool,
+      CppToType<T>::create(),
+      nulls,
+      length,
+      values,
+      std::vector<BufferPtr>());
   flatVector->setNullCount(nullCount);
   return flatVector;
 }
@@ -1344,6 +1349,7 @@ void StringDictionaryColumnReader::readFlatVector(
   } else {
     result = std::make_shared<FlatVector<StringView>>(
         &memoryPool_,
+        VARCHAR(),
         nulls,
         numValues,
         data,

velox/dwio/dwrf/test/ColumnWriterIndexTests.cpp

@@ -92,7 +92,12 @@ VectorPtr prepBatchImpl(
   }
 
   auto batch = std::make_shared<FlatVector<T>>(
-      pool, nulls, size, values, std::vector<BufferPtr>());
+      pool,
+      CppToType<T>::create(),
+      nulls,
+      size,
+      values,
+      std::vector<BufferPtr>());
   batch->setNullCount(nullCount);
   return batch;
 }
@@ -102,7 +107,7 @@ VectorPtr prepStringBatchImpl(
     MemoryPool* pool,
     std::function<std::string(size_t, size_t)> genData,
     std::function<bool(size_t, size_t)> genNulls) {
-  BufferPtr nulls = AlignedBuffer::allocate<char>(bits::nbytes(size), pool);
+  BufferPtr nulls = allocateNulls(size, pool);
   auto* nullsPtr = nulls->asMutable<uint64_t>();
   size_t nullCount = 0;
 
@@ -138,7 +143,7 @@ VectorPtr prepStringBatchImpl(
   }
 
   auto batch = std::make_shared<FlatVector<StringView>>(
-      pool, nulls, size, values, std::move(dataChunks));
+      pool, VARCHAR(), nulls, size, values, std::move(dataChunks));
   batch->setNullCount(nullCount);
   return batch;
 }
@@ -564,7 +569,7 @@ class BinaryColumnWriterEncodingIndexTest
 
  protected:
   VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    BufferPtr nulls = AlignedBuffer::allocate<char>(bits::nbytes(size), pool);
+    BufferPtr nulls = allocateNulls(size, pool);
     auto* nullsPtr = nulls->asMutable<uint64_t>();
     size_t nullCount = 0;
 
@@ -589,7 +594,7 @@ class BinaryColumnWriterEncodingIndexTest
     }
 
     auto batch = std::make_shared<FlatVector<StringView>>(
-        pool, nulls, size, values, std::vector<BufferPtr>{data});
+        pool, VARCHAR(), nulls, size, values, std::vector<BufferPtr>{data});
     batch->setNullCount(nullCount);
     return batch;
   }
@@ -1152,14 +1157,14 @@ class ListColumnWriterEncodingIndexTest
 
  protected:
   VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    auto nulls = AlignedBuffer::allocate<char>(bits::nbytes(size), pool);
+    auto nulls = allocateNulls(size, pool);
     auto* nullsPtr = nulls->asMutable<uint64_t>();
     size_t nullCount = 0;
 
-    auto offsets = AlignedBuffer::allocate<vector_size_t>(size, pool);
+    auto offsets = allocateOffsets(size, pool);
     auto* offsetsPtr = offsets->asMutable<vector_size_t>();
 
-    auto lengths = AlignedBuffer::allocate<vector_size_t>(size, pool);
+    auto lengths = allocateSizes(size, pool);
     auto* lengthsPtr = lengths->asMutable<vector_size_t>();
 
     size_t value = 0;
@@ -1218,14 +1223,14 @@ class MapColumnWriterEncodingIndexTest
 
  protected:
   VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    auto nulls = AlignedBuffer::allocate<char>(bits::nbytes(size), pool);
+    auto nulls = allocateNulls(size, pool);
     auto* nullsPtr = nulls->asMutable<uint64_t>();
     size_t nullCount = 0;
 
-    auto offsets = AlignedBuffer::allocate<vector_size_t>(size, pool);
+    auto offsets = allocateOffsets(size, pool);
     auto* offsetsPtr = offsets->asMutable<vector_size_t>();
 
-    auto lengths = AlignedBuffer::allocate<vector_size_t>(size, pool);
+    auto lengths = allocateSizes(size, pool);
     auto* lengthsPtr = lengths->asMutable<vector_size_t>();
 
     size_t value = 0;
@@ -1289,12 +1294,12 @@ class FlatMapColumnWriterEncodingIndexTest
 
  protected:
   VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    auto offsets = AlignedBuffer::allocate<vector_size_t>(size, pool);
+    auto offsets = allocateOffsets(size, pool);
     auto* offsetsPtr = offsets->asMutable<vector_size_t>();
     auto offsets2 = AlignedBuffer::allocate<vector_size_t>(size, pool);
     auto* offsets2Ptr = offsets2->asMutable<vector_size_t>();
 
-    auto lengths = AlignedBuffer::allocate<vector_size_t>(size, pool);
+    auto lengths = allocateSizes(size, pool);
     auto* lengthsPtr = lengths->asMutable<vector_size_t>();
     auto lengths2 = AlignedBuffer::allocate<vector_size_t>(size, pool);
     auto* lengths2Ptr = lengths2->asMutable<vector_size_t>();
@@ -1384,7 +1389,7 @@ class StructColumnWriterEncodingIndexTest
   }
 
   VectorPtr prepBatch(size_t size, MemoryPool* pool, bool isRoot) override {
-    auto nulls = AlignedBuffer::allocate<char>(bits::nbytes(size), pool);
+    auto nulls = allocateNulls(size, pool);
     auto* nullsPtr = nulls->asMutable<uint64_t>();
     size_t nullCount = 0;