Function writeSampleData

c++/test/TestReader.cc:941–978

  namespace {

    uint64_t writeSampleData(MemoryOutputStream& memStream, uint64_t stripeSize = 1024,
                             uint64_t rowsPerStripe = 1000) {
      auto type = Type::buildTypeFromString("struct<id:int,name:string,value:double>");
      WriterOptions options;
      options.setStripeSize(stripeSize)
          .setCompressionBlockSize(1024)
          .setMemoryBlockSize(64)
          .setCompression(CompressionKind_NONE)
          .setRowIndexStride(100);
      auto writer = createWriter(*type, &memStream, options);

      uint64_t totalRows = rowsPerStripe * 3;
      uint64_t batchSize = 100;
      std::vector<std::string> names(totalRows, "");

      for (uint64_t startRow = 0; startRow < totalRows; startRow += batchSize) {
        uint64_t currentBatchSize = std::min(batchSize, totalRows - startRow);
        auto batch = writer->createRowBatch(currentBatchSize);
        auto& structBatch = static_cast<StructVectorBatch&>(*batch);
        auto& idBatch = static_cast<LongVectorBatch&>(*structBatch.fields[0]);
        auto& nameBatch = static_cast<StringVectorBatch&>(*structBatch.fields[1]);
        auto& valueBatch = static_cast<DoubleVectorBatch&>(*structBatch.fields[2]);

        for (uint64_t i = 0; i < currentBatchSize; ++i) {
          idBatch.data[i] = static_cast<int64_t>(startRow + i);
          names[startRow + i] = "name_" + std::to_string(startRow + i);
          nameBatch.data[i] = const_cast<char*>(names[startRow + i].c_str());
          nameBatch.length[i] = static_cast<int64_t>(names[startRow + i].length());
          valueBatch.data[i] = static_cast<double>(startRow + i) * 1.5;
        }

        structBatch.numElements = currentBatchSize;
        writer->add(*batch);
      }

      writer->close();
      return totalRows;
    }

    uint64_t readAllRows(RowReader& rowReader, uint64_t batchSize = 1000) {
      auto batch = rowReader.createRowBatch(batchSize);