Method append

bolt/serializers/ArrowSerializer.cpp:271–368

  }

  void append(
      const RowVectorPtr& vector,
      const folly::Range<const IndexRange*>& ranges,
      Scratch& scratch) override {
    vector_size_t total = 0;
    for (const auto& rg : ranges)
      total += rg.size;
    if (!vector || vector->size() == 0 || total == 0)
      return;

    if (arrowBridgeOptions_.exportToView) {
      heldVectors_.push_back(vector);
    }

    ArrowArray cArray{};
    ArrowSchema cSchema{};
    ArrowArrayReleaser arrayRel(&cArray);
    ArrowSchemaReleaser schemaRel(&cSchema);

    VectorPtr useVec = vector;
    if (ranges.size() == 1) {
      const auto& rg = ranges[0];
      const bool identity = (rg.begin == 0 && rg.size == vector->size());
      if (!identity) {
        useVec = vector->slice(rg.begin, rg.size);
      }
    } else {
      auto idx = AlignedBuffer::allocate<vector_size_t>(total, vector->pool());
      auto* raw = idx->asMutable<vector_size_t>();
      size_t p = 0;
      for (const auto& rg : ranges) {
        for (vector_size_t i = 0; i < rg.size; ++i) {
          raw[p++] = rg.begin + i;
        }
      }
      useVec = BaseVector::wrapInDictionary(nullptr, idx, total, vector);
    }

    // for lazy
    SelectivityVector sv(useVec->size(), true);
    LazyVector::ensureLoadedRows(useVec, sv);

    // Vector → Arrow C-Data
    exportToArrow(useVec, cArray, vector->pool(), arrowBridgeOptions_);
    exportToArrow(useVec, cSchema, arrowBridgeOptions_, {});

    // C-Data → Arrow C++
    auto schRes = ::arrow::ImportSchema(&cSchema);
    BOLT_USER_CHECK(
        schRes.ok(), "ImportSchema failed: {}", schRes.status().ToString());
    auto schema = *schRes;

    auto rbRes = ::arrow::ImportRecordBatch(&cArray, schema);
    BOLT_USER_CHECK(
        rbRes.ok(), "ImportRecordBatch failed: {}", rbRes.status().ToString());
    auto rb = *rbRes;

    schemaRel.disarm();