Method GetColumnPageReader

cpp/src/parquet/file_reader.cc:239–291

  const ReaderProperties* properties() const override { return &properties_; }

  std::unique_ptr<PageReader> GetColumnPageReader(int i) override {
    // Read column chunk from the file
    auto col = row_group_metadata_->ColumnChunk(i);
    const ColumnDescriptor* descr = row_group_metadata_->schema()->Column(i);

    ::arrow::io::ReadRange col_range =
        ComputeColumnChunkRange(file_metadata_, source_size_, row_group_ordinal_, i);
    std::shared_ptr<ArrowInputStream> stream;
    if (cached_source_ && prebuffered_column_chunks_bitmap_ != nullptr &&
        ::arrow::bit_util::GetBit(prebuffered_column_chunks_bitmap_->data(), i)) {
      // PARQUET-1698: if read coalescing is enabled, read from pre-buffered
      // segments.
      PARQUET_ASSIGN_OR_THROW(auto buffer, cached_source_->Read(col_range));
      stream = std::make_shared<::arrow::io::BufferReader>(buffer);
    } else {
      stream = properties_.GetStream(source_, col_range.offset, col_range.length);
    }

    std::unique_ptr<ColumnCryptoMetaData> crypto_metadata = col->crypto_metadata();

    // Prior to Arrow 3.0.0, is_compressed was always set to false in column headers,
    // even if compression was used. See ARROW-17100.
    bool always_compressed = file_metadata_->writer_version().VersionLt(
        ApplicationVersion::PARQUET_CPP_10353_FIXED_VERSION());

    // Column is encrypted only if crypto_metadata exists.
    if (!crypto_metadata) {
      return PageReader::Open(stream, col->num_values(), col->compression(), properties_,
                              *descr, always_compressed);
    }

    // The column is encrypted
    auto* file_decryptor = file_metadata_->file_decryptor().get();
    auto meta_decryptor_factory = InternalFileDecryptor::GetColumnMetaDecryptorFactory(
        file_decryptor, crypto_metadata.get());
    auto data_decryptor_factory = InternalFileDecryptor::GetColumnDataDecryptorFactory(
        file_decryptor, crypto_metadata.get());

    constexpr auto kEncryptedOrdinalLimit = 32767;
    if (ARROW_PREDICT_FALSE(row_group_ordinal_ > kEncryptedOrdinalLimit)) {
      throw ParquetException("Encrypted files cannot contain more than 32767 row groups");
    }
    if (ARROW_PREDICT_FALSE(i > kEncryptedOrdinalLimit)) {
      throw ParquetException("Encrypted files cannot contain more than 32767 columns");
    }

    CryptoContext ctx{col->has_dictionary_page(),
                      static_cast<int16_t>(row_group_ordinal_), static_cast<int16_t>(i),
                      std::move(meta_decryptor_factory),
                      std::move(data_decryptor_factory)};
    return PageReader::Open(stream, col->num_values(), col->compression(), properties_,
                            *descr, always_compressed, &ctx);
  }

 private:
  std::shared_ptr<ArrowInputFile> source_;