Method CreateColumns

cpp/src/arrow/ipc/reader.cc:640–688

  }

  Result<ArrayDataVector> CreateColumns(ArrayDataVector columns,
                                        bool resolve_dictionaries = true) {
    if (resolve_dictionaries) {
      // Dictionary resolution needs to happen on the unfiltered columns,
      // because fields are mapped structurally (by path in the original schema).
      RETURN_NOT_OK(ResolveDictionaries(columns, *context_.dictionary_memo,
                                        context_.options.memory_pool));
    }

    ArrayDataVector filtered_columns;
    if (!inclusion_mask_.empty()) {
      FieldVector filtered_fields;
      for (int i = 0; i < schema_->num_fields(); ++i) {
        if (inclusion_mask_[i]) {
          DCHECK_NE(columns[i], nullptr);
          filtered_columns.push_back(std::move(columns[i]));
        }
      }
      columns.clear();
    } else {
      filtered_columns = std::move(columns);
    }

    if (context_.compression != Compression::UNCOMPRESSED) {
      RETURN_NOT_OK(
          DecompressBuffers(context_.compression, context_.options, &filtered_columns));
    }

    // Swap endian if necessary
    if (context_.swap_endian) {
      for (auto& column : filtered_columns) {
        ARROW_ASSIGN_OR_RAISE(
            column, arrow::internal::SwapEndianArrayData(std::move(column),
                                                         context_.options.memory_pool));
      }
    }
    if (context_.options.ensure_alignment != Alignment::kAnyAlignment) {
      for (auto& column : filtered_columns) {
        ARROW_ASSIGN_OR_RAISE(
            column,
            util::EnsureAlignment(
                std::move(column),
                // The numerical value of the enum is taken literally as byte alignment
                static_cast<int64_t>(context_.options.ensure_alignment),
                context_.options.memory_pool));
      }
    }
    return filtered_columns;
  }

  IpcReadContext context_;
  std::shared_ptr<Schema> schema_;