Method Write

cpp/src/parquet/arrow/writer.cc:159–203

Writes out all leaf parquet columns to the RowGroupWriter that this object was constructed with. Each leaf column is written fully before the next column is written (i.e. no buffering is assumed). Columns are written in DFS order.

  //
  // Columns are written in DFS order.
  Status Write(ArrowWriteContext* ctx) {
    for (int leaf_idx = 0; leaf_idx < leaf_count_; leaf_idx++) {
      ColumnWriter* column_writer;
      if (row_group_writer_->buffered()) {
        const int column_index = start_leaf_column_index_ + leaf_idx;
        PARQUET_CATCH_NOT_OK(column_writer = row_group_writer_->column(column_index));
      } else {
        PARQUET_CATCH_NOT_OK(column_writer = row_group_writer_->NextColumn());
      }
      for (auto& level_builder : level_builders_) {
        RETURN_NOT_OK(level_builder->Write(
            leaf_idx, ctx, [&](const MultipathLevelBuilderResult& result) {
              size_t visited_component_size = result.post_list_visited_elements.size();
              DCHECK_GT(visited_component_size, 0);
              std::shared_ptr<Array> values_array;
              if (visited_component_size == 1) {
                const ElementRange& range = result.post_list_visited_elements[0];
                values_array = result.leaf_array->Slice(range.start, range.Size());
              } else {
                // Multiple leaf ranges can be produced when child values are
                // skipped, such as null fixed-size-list slots, or when
                // list-view ranges are non-contiguous. Concatenate the slices
                // in logical write order.
                ::arrow::ArrayVector arrays;
                arrays.reserve(visited_component_size);
                for (const auto& range : result.post_list_visited_elements) {
                  DCHECK(!range.Empty());
                  arrays.push_back(result.leaf_array->Slice(range.start, range.Size()));
                }
                ARROW_ASSIGN_OR_RAISE(values_array,
                                      ::arrow::Concatenate(arrays, ctx->memory_pool));
              }

              return column_writer->WriteArrow(result.def_levels, result.rep_levels,
                                               result.def_rep_level_count, *values_array,
                                               ctx, result.leaf_is_nullable);
            }));
      }

      if (!row_group_writer_->buffered()) {
        PARQUET_CATCH_NOT_OK(column_writer->Close());
      }
    }
    return Status::OK();
  }

  // Make a new object by converting each chunk in |data| to a MultipathLevelBuilder.
  //