duckdb 1.3.4 → 1.4.0

package/src/duckdb/extension/parquet/include/reader/variant/variant_binary_decoder.hpp

@@ -0,0 +1,150 @@
+#pragma once
+
+#include "duckdb/common/types/string_type.hpp"
+#include "duckdb/common/types/value.hpp"
+#include "reader/variant/variant_value.hpp"
+
+using namespace duckdb_yyjson;
+
+namespace duckdb {
+
+//! ------------ Metadata ------------
+
+struct VariantMetadataHeader {
+public:
+	static VariantMetadataHeader FromHeaderByte(uint8_t byte);
+
+public:
+	//! The version of the protocol used (only '1' supported for now)
+	uint8_t version;
+	//! Number of bytes per dictionary size and offset field
+	uint8_t offset_size;
+	//! Whether dictionary strings are sorted and unique
+	bool sorted_strings = false;
+};
+
+struct VariantMetadata {
+public:
+	explicit VariantMetadata(const string_t &metadata);
+
+public:
+	const string_t &metadata;
+
+public:
+	VariantMetadataHeader header;
+	const_data_ptr_t offsets;
+	const_data_ptr_t bytes;
+
+	//! The json object keys have to be null-terminated
+	//! But we don't receive them null-terminated
+	vector<string> strings;
+};
+
+//! ------------ Value ------------
+
+enum class VariantBasicType : uint8_t { PRIMITIVE = 0, SHORT_STRING = 1, OBJECT = 2, ARRAY = 3, INVALID };
+
+enum class VariantPrimitiveType : uint8_t {
+	NULL_TYPE = 0,
+	BOOLEAN_TRUE = 1,
+	BOOLEAN_FALSE = 2,
+	INT8 = 3,
+	INT16 = 4,
+	INT32 = 5,
+	INT64 = 6,
+	DOUBLE = 7,
+	DECIMAL4 = 8,
+	DECIMAL8 = 9,
+	DECIMAL16 = 10,
+	DATE = 11,
+	TIMESTAMP_MICROS = 12,
+	TIMESTAMP_NTZ_MICROS = 13,
+	FLOAT = 14,
+	BINARY = 15,
+	STRING = 16,
+	TIME_NTZ_MICROS = 17,
+	TIMESTAMP_NANOS = 18,
+	TIMESTAMP_NTZ_NANOS = 19,
+	UUID = 20,
+	INVALID
+};
+
+struct VariantValueMetadata {
+public:
+	VariantValueMetadata() {
+	}
+
+public:
+	static VariantValueMetadata FromHeaderByte(uint8_t byte);
+	static VariantBasicType VariantBasicTypeFromByte(uint8_t byte) {
+		if (byte >= static_cast<uint8_t>(VariantBasicType::INVALID)) {
+			throw NotImplementedException("Variant BasicType (%d) is not supported", byte);
+		}
+		return static_cast<VariantBasicType>(byte);
+	}
+
+	static VariantPrimitiveType VariantPrimitiveTypeFromByte(uint8_t byte) {
+		if (byte >= static_cast<uint8_t>(VariantPrimitiveType::INVALID)) {
+			throw NotImplementedException("Variant PrimitiveType (%d) is not supported", byte);
+		}
+		return static_cast<VariantPrimitiveType>(byte);
+	}
+
+public:
+	VariantBasicType basic_type;
+
+public:
+	//! Primitive Type header
+	VariantPrimitiveType primitive_type;
+
+public:
+	//! Short String header
+	uint8_t string_size;
+
+public:
+	//! Object header | Array header
+
+	//! Size in bytes for each 'field_offset' entry
+	uint32_t field_offset_size;
+	//! Size in bytes for each 'field_id' entry
+	uint32_t field_id_size;
+	//! Whether the number of elements is encoded in 1 byte (false) or 4 bytes (true)
+	bool is_large;
+};
+
+struct VariantDecodeResult {
+public:
+	VariantDecodeResult() = default;
+	~VariantDecodeResult() {
+		if (doc) {
+			yyjson_mut_doc_free(doc);
+		}
+		if (data) {
+			free(data);
+		}
+	}
+
+public:
+	yyjson_mut_doc *doc = nullptr;
+	char *data = nullptr;
+};
+
+class VariantBinaryDecoder {
+public:
+	VariantBinaryDecoder() = delete;
+
+public:
+	static VariantValue Decode(const VariantMetadata &metadata, const_data_ptr_t data);
+
+public:
+	static VariantValue PrimitiveTypeDecode(const VariantMetadata &metadata, const VariantValueMetadata &value_metadata,
+	                                        const_data_ptr_t data);
+	static VariantValue ShortStringDecode(const VariantMetadata &metadata, const VariantValueMetadata &value_metadata,
+	                                      const_data_ptr_t data);
+	static VariantValue ObjectDecode(const VariantMetadata &metadata, const VariantValueMetadata &value_metadata,
+	                                 const_data_ptr_t data);
+	static VariantValue ArrayDecode(const VariantMetadata &metadata, const VariantValueMetadata &value_metadata,
+	                                const_data_ptr_t data);
+};
+
+} // namespace duckdb

package/src/duckdb/extension/parquet/include/reader/variant/variant_shredded_conversion.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "reader/variant/variant_value.hpp"
+#include "reader/variant/variant_binary_decoder.hpp"
+
+namespace duckdb {
+
+class VariantShreddedConversion {
+public:
+	VariantShreddedConversion() = delete;
+
+public:
+	static vector<VariantValue> Convert(Vector &metadata, Vector &group, idx_t offset, idx_t length, idx_t total_size,
+	                                    bool is_field = false);
+	static vector<VariantValue> ConvertShreddedLeaf(Vector &metadata, Vector &value, Vector &typed_value, idx_t offset,
+	                                                idx_t length, idx_t total_size);
+	static vector<VariantValue> ConvertShreddedArray(Vector &metadata, Vector &value, Vector &typed_value, idx_t offset,
+	                                                 idx_t length, idx_t total_size);
+	static vector<VariantValue> ConvertShreddedObject(Vector &metadata, Vector &value, Vector &typed_value,
+	                                                  idx_t offset, idx_t length, idx_t total_size);
+};
+
+} // namespace duckdb

package/src/duckdb/extension/parquet/include/reader/variant/variant_value.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "duckdb/common/map.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/common/types/value.hpp"
+
+#include "yyjson.hpp"
+
+using namespace duckdb_yyjson;
+
+namespace duckdb {
+
+enum class VariantValueType : uint8_t { PRIMITIVE, OBJECT, ARRAY, MISSING };
+
+struct VariantValue {
+public:
+	VariantValue() : value_type(VariantValueType::MISSING) {
+	}
+	explicit VariantValue(VariantValueType type) : value_type(type) {
+	}
+	explicit VariantValue(Value &&val) : value_type(VariantValueType::PRIMITIVE), primitive_value(std::move(val)) {
+	}
+	// Delete copy constructor and copy assignment operator
+	VariantValue(const VariantValue &) = delete;
+	VariantValue &operator=(const VariantValue &) = delete;
+
+	// Default move constructor and move assignment operator
+	VariantValue(VariantValue &&) noexcept = default;
+	VariantValue &operator=(VariantValue &&) noexcept = default;
+
+public:
+	bool IsNull() const {
+		return value_type == VariantValueType::PRIMITIVE && primitive_value.IsNull();
+	}
+	bool IsMissing() const {
+		return value_type == VariantValueType::MISSING;
+	}
+
+public:
+	void AddChild(const string &key, VariantValue &&val);
+	void AddItem(VariantValue &&val);
+
+public:
+	yyjson_mut_val *ToJSON(ClientContext &context, yyjson_mut_doc *doc) const;
+
+public:
+	VariantValueType value_type;
+	//! FIXME: how can we get a deterministic child order for a partially shredded object?
+	map<string, VariantValue> object_children;
+	vector<VariantValue> array_items;
+	Value primitive_value;
+};
+
+} // namespace duckdb

package/src/duckdb/extension/parquet/include/reader/variant_column_reader.hpp

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// reader/variant_column_reader.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "column_reader.hpp"
+#include "reader/templated_column_reader.hpp"
+
+namespace duckdb {
+
+class VariantColumnReader : public ColumnReader {
+public:
+	static constexpr const PhysicalType TYPE = PhysicalType::VARCHAR;
+
+public:
+	VariantColumnReader(ClientContext &context, ParquetReader &reader, const ParquetColumnSchema &schema,
+	                    vector<unique_ptr<ColumnReader>> child_readers_p);
+
+	ClientContext &context;
+	vector<unique_ptr<ColumnReader>> child_readers;
+
+public:
+	ColumnReader &GetChildReader(idx_t child_idx);
+
+	void InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns, TProtocol &protocol_p) override;
+
+	idx_t Read(uint64_t num_values, data_ptr_t define_out, data_ptr_t repeat_out, Vector &result) override;
+
+	void Skip(idx_t num_values) override;
+	idx_t GroupRowsAvailable() override;
+	uint64_t TotalCompressedSize() override;
+	void RegisterPrefetch(ThriftFileTransport &transport, bool allow_merge) override;
+
+protected:
+	idx_t metadata_reader_idx;
+	idx_t value_reader_idx;
+};
+
+} // namespace duckdb

package/src/duckdb/extension/parquet/include/resizable_buffer.hpp

@@ -9,9 +9,7 @@
 #pragma once
 
 #include "duckdb.hpp"
-#ifndef DUCKDB_AMALGAMATION
 #include "duckdb/common/allocator.hpp"
-#endif
 
 #include <exception>
 

package/src/duckdb/extension/parquet/include/thrift_tools.hpp

@@ -13,11 +13,9 @@
 #include "thrift/transport/TBufferTransports.h"
 
 #include "duckdb.hpp"
-#ifndef DUCKDB_AMALGAMATION
 #include "duckdb/storage/caching_file_system.hpp"
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/allocator.hpp"
-#endif
 
 namespace duckdb {
 
@@ -154,7 +152,7 @@ public:
 			memcpy(buf, prefetch_buffer_fallback->buffer_ptr + location - prefetch_buffer_fallback->location, len);
 		} else {
 			// No prefetch, do a regular (non-caching) read
-			file_handle.GetFileHandle().Read(buf, len, location);
+			file_handle.GetFileHandle().Read(context, buf, len, location);
 		}
 
 		location += len;
@@ -213,6 +211,8 @@ public:
 	}
 
 private:
+	QueryContext context;
+
 	CachingFileHandle &file_handle;
 	idx_t location;
 	idx_t size;

package/src/duckdb/extension/parquet/include/writer/array_column_writer.hpp

@@ -22,7 +22,8 @@ public:
 
 public:
 	void Analyze(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
-	void Prepare(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
+	void Prepare(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count,
+	             bool vector_can_span_multiple_pages) override;
 	void Write(ColumnWriterState &state, Vector &vector, idx_t count) override;
 };
 

package/src/duckdb/extension/parquet/include/writer/list_column_writer.hpp

@@ -40,7 +40,8 @@ public:
 	bool HasAnalyze() override;
 	void Analyze(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
 	void FinalizeAnalyze(ColumnWriterState &state) override;
-	void Prepare(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
+	void Prepare(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count,
+	             bool vector_can_span_multiple_pages) override;
 
 	void BeginWrite(ColumnWriterState &state) override;
 	void Write(ColumnWriterState &state, Vector &vector, idx_t count) override;

package/src/duckdb/extension/parquet/include/writer/parquet_write_operators.hpp

@@ -11,6 +11,7 @@
 #include "writer/parquet_write_stats.hpp"
 #include "zstd/common/xxhash.hpp"
 #include "duckdb/common/types/uhugeint.hpp"
+#include "duckdb/common/types/uuid.hpp"
 
 namespace duckdb {
 
@@ -108,6 +109,50 @@ struct ParquetTimestampSOperator : public ParquetCastOperator {
 	}
 };
 
+// We will need a different operator for GEOGRAPHY later, so we define a base geo operator
+struct ParquetBaseGeoOperator : public BaseParquetOperator {
+	template <class SRC, class TGT>
+	static TGT Operation(SRC input) {
+		return input;
+	}
+
+	template <class SRC, class TGT>
+	static void HandleStats(ColumnWriterStatistics *stats, TGT target_value) {
+		auto &geo_stats = stats->Cast<GeoStatisticsState>();
+		geo_stats.Update(target_value);
+	}
+
+	template <class SRC, class TGT>
+	static void WriteToStream(const TGT &target_value, WriteStream &ser) {
+		ser.Write<uint32_t>(target_value.GetSize());
+		ser.WriteData(const_data_ptr_cast(target_value.GetData()), target_value.GetSize());
+	}
+
+	template <class SRC, class TGT>
+	static idx_t WriteSize(const TGT &target_value) {
+		return sizeof(uint32_t) + target_value.GetSize();
+	}
+
+	template <class SRC, class TGT>
+	static uint64_t XXHash64(const TGT &target_value) {
+		return duckdb_zstd::XXH64(target_value.GetData(), target_value.GetSize(), 0);
+	}
+
+	template <class SRC, class TGT>
+	static idx_t GetRowSize(const Vector &vector, idx_t index) {
+		// This needs to add the 4 bytes (just like WriteSize) otherwise we underestimate and we have to realloc
+		// This seriously harms performance, mostly by making it very inconsistent (see internal issue #4990)
+		return sizeof(uint32_t) + FlatVector::GetData<string_t>(vector)[index].GetSize();
+	}
+};
+
+struct ParquetGeometryOperator : public ParquetBaseGeoOperator {
+	template <class SRC, class TGT>
+	static unique_ptr<ColumnWriterStatistics> InitializeStats() {
+		return make_uniq<GeoStatisticsState>();
+	}
+};
+
 struct ParquetBaseStringOperator : public BaseParquetOperator {
 	template <class SRC, class TGT>
 	static TGT Operation(SRC input) {
@@ -201,16 +246,8 @@ struct ParquetUUIDOperator : public BaseParquetOperator {
 	template <class SRC, class TGT>
 	static TGT Operation(SRC input) {
 		TGT result;
-		uint64_t high_bytes = input.upper ^ (int64_t(1) << 63);
-		uint64_t low_bytes = input.lower;
-		for (idx_t i = 0; i < sizeof(uint64_t); i++) {
-			auto shift_count = (sizeof(uint64_t) - i - 1) * 8;
-			result.bytes[i] = (high_bytes >> shift_count) & 0xFF;
-		}
-		for (idx_t i = 0; i < sizeof(uint64_t); i++) {
-			auto shift_count = (sizeof(uint64_t) - i - 1) * 8;
-			result.bytes[sizeof(uint64_t) + i] = (low_bytes >> shift_count) & 0xFF;
-		}
+		// Use the utility function from BaseUUID
+		BaseUUID::ToBlob(input, result.bytes);
 		return result;
 	}
 

package/src/duckdb/extension/parquet/include/writer/parquet_write_stats.hpp

@@ -9,7 +9,7 @@
 #pragma once
 
 #include "column_writer.hpp"
-#include "writer/parquet_write_stats.hpp"
+#include "geo_parquet.hpp"
 
 namespace duckdb {
 
@@ -27,6 +27,10 @@ public:
 	virtual bool MinIsExact();
 	virtual bool MaxIsExact();
 
+	virtual bool HasGeoStats();
+	virtual optional_ptr<GeometryStats> GetGeoStats();
+	virtual void WriteGeoStats(duckdb_parquet::GeospatialStatistics &stats);
+
 public:
 	template <class TARGET>
 	TARGET &Cast() {
@@ -248,4 +252,54 @@ public:
 	}
 };
 
+class GeoStatisticsState final : public ColumnWriterStatistics {
+public:
+	explicit GeoStatisticsState() : has_stats(false) {
+	}
+
+	bool has_stats;
+	GeometryStats geo_stats;
+
+public:
+	void Update(const string_t &val) {
+		geo_stats.Update(val);
+		has_stats = true;
+	}
+	bool HasGeoStats() override {
+		return has_stats;
+	}
+	optional_ptr<GeometryStats> GetGeoStats() override {
+		return geo_stats;
+	}
+	void WriteGeoStats(duckdb_parquet::GeospatialStatistics &stats) override {
+		const auto &types = geo_stats.types;
+		const auto &bbox = geo_stats.bbox;
+
+		if (bbox.IsSet()) {
+
+			stats.__isset.bbox = true;
+			stats.bbox.xmin = bbox.xmin;
+			stats.bbox.xmax = bbox.xmax;
+			stats.bbox.ymin = bbox.ymin;
+			stats.bbox.ymax = bbox.ymax;
+
+			if (bbox.HasZ()) {
+				stats.bbox.__isset.zmin = true;
+				stats.bbox.__isset.zmax = true;
+				stats.bbox.zmin = bbox.zmin;
+				stats.bbox.zmax = bbox.zmax;
+			}
+			if (bbox.HasM()) {
+				stats.bbox.__isset.mmin = true;
+				stats.bbox.__isset.mmax = true;
+				stats.bbox.mmin = bbox.mmin;
+				stats.bbox.mmax = bbox.mmax;
+			}
+		}
+
+		stats.__isset.geospatial_types = true;
+		stats.geospatial_types = types.ToList<int>();
+	}
+};
+
 } // namespace duckdb

package/src/duckdb/extension/parquet/include/writer/primitive_column_writer.hpp

@@ -70,14 +70,15 @@ public:
 
 public:
 	unique_ptr<ColumnWriterState> InitializeWriteState(duckdb_parquet::RowGroup &row_group) override;
-	void Prepare(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
+	void Prepare(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count,
+	             bool vector_can_span_multiple_pages) override;
 	void BeginWrite(ColumnWriterState &state) override;
 	void Write(ColumnWriterState &state, Vector &vector, idx_t count) override;
 	void FinalizeWrite(ColumnWriterState &state) override;
 
 protected:
-	static void WriteLevels(WriteStream &temp_writer, const unsafe_vector<uint16_t> &levels, idx_t max_value,
-	                        idx_t start_offset, idx_t count, optional_idx null_count = optional_idx());
+	static void WriteLevels(Allocator &allocator, WriteStream &temp_writer, const unsafe_vector<uint16_t> &levels,
+	                        idx_t max_value, idx_t start_offset, idx_t count, optional_idx null_count = optional_idx());
 
 	virtual duckdb_parquet::Encoding::type GetEncoding(PrimitiveColumnWriterState &state);
 

package/src/duckdb/extension/parquet/include/writer/struct_column_writer.hpp

@@ -28,7 +28,8 @@ public:
 	bool HasAnalyze() override;
 	void Analyze(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
 	void FinalizeAnalyze(ColumnWriterState &state) override;
-	void Prepare(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count) override;
+	void Prepare(ColumnWriterState &state, ColumnWriterState *parent, Vector &vector, idx_t count,
+	             bool vector_can_span_multiple_pages) override;
 
 	void BeginWrite(ColumnWriterState &state) override;
 	void Write(ColumnWriterState &state, Vector &vector, idx_t count) override;

package/src/duckdb/extension/parquet/include/writer/templated_column_writer.hpp

@@ -20,8 +20,9 @@ namespace duckdb {
 template <class SRC, class TGT, class OP = ParquetCastOperator, bool ALL_VALID>
 static void TemplatedWritePlain(Vector &col, ColumnWriterStatistics *stats, const idx_t chunk_start,
                                 const idx_t chunk_end, const ValidityMask &mask, WriteStream &ser) {
-	static constexpr bool COPY_DIRECTLY_FROM_VECTOR =
-	    ALL_VALID && std::is_same<SRC, TGT>::value && std::is_arithmetic<TGT>::value;
+	static constexpr bool COPY_DIRECTLY_FROM_VECTOR = ALL_VALID && std::is_same<SRC, TGT>::value &&
+	                                                  std::is_arithmetic<TGT>::value &&
+	                                                  std::is_same<OP, ParquetCastOperator>::value;
 
 	const auto *const ptr = FlatVector::GetData<SRC>(col);
 
@@ -67,7 +68,9 @@ class StandardColumnWriterState : public PrimitiveColumnWriterState {
 public:
 	StandardColumnWriterState(ParquetWriter &writer, duckdb_parquet::RowGroup &row_group, idx_t col_idx)
 	    : PrimitiveColumnWriterState(writer, row_group, col_idx),
-	      dictionary(BufferAllocator::Get(writer.GetContext()), writer.DictionarySizeLimit(),
+	      dictionary(BufferAllocator::Get(writer.GetContext()),
+	                 writer.DictionarySizeLimit().IsValid() ? writer.DictionarySizeLimit().GetIndex()
+	                                                        : NumericCast<idx_t>(row_group.num_rows) / 5,
 	                 writer.StringDictionaryPageSizeLimit()),
 	      encoding(duckdb_parquet::Encoding::PLAIN) {
 	}

package/src/duckdb/extension/parquet/include/zstd_file_system.hpp

@@ -9,15 +9,13 @@
 #pragma once
 
 #include "duckdb.hpp"
-#ifndef DUCKDB_AMALGAMATION
 #include "duckdb/common/compressed_file_system.hpp"
-#endif
 
 namespace duckdb {
 
 class ZStdFileSystem : public CompressedFileSystem {
 public:
-	unique_ptr<FileHandle> OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) override;
+	unique_ptr<FileHandle> OpenCompressedFile(QueryContext context, unique_ptr<FileHandle> handle, bool write) override;
 
 	std::string GetName() const override {
 		return "ZStdFileSystem";

package/src/duckdb/extension/parquet/parquet_crypto.cpp

@@ -3,12 +3,10 @@
 #include "mbedtls_wrapper.hpp"
 #include "thrift_tools.hpp"
 
-#ifndef DUCKDB_AMALGAMATION
 #include "duckdb/common/exception/conversion_exception.hpp"
 #include "duckdb/common/helper.hpp"
 #include "duckdb/common/types/blob.hpp"
 #include "duckdb/storage/arena_allocator.hpp"
-#endif
 
 namespace duckdb {
 
@@ -91,7 +89,8 @@ using duckdb_apache::thrift::transport::TTransport;
 class EncryptionTransport : public TTransport {
 public:
 	EncryptionTransport(TProtocol &prot_p, const string &key, const EncryptionUtil &encryption_util_p)
-	    : prot(prot_p), trans(*prot.getTransport()), aes(encryption_util_p.CreateEncryptionState(&key)),
+	    : prot(prot_p), trans(*prot.getTransport()),
+	      aes(encryption_util_p.CreateEncryptionState(EncryptionTypes::GCM, key.size())),
 	      allocator(Allocator::DefaultAllocator(), ParquetCrypto::CRYPTO_BLOCK_SIZE) {
 		Initialize(key);
 	}
@@ -150,7 +149,8 @@ private:
 		// Generate Nonce
 		aes->GenerateRandomData(nonce, ParquetCrypto::NONCE_BYTES);
 		// Initialize Encryption
-		aes->InitializeEncryption(nonce, ParquetCrypto::NONCE_BYTES, &key);
+		aes->InitializeEncryption(nonce, ParquetCrypto::NONCE_BYTES, reinterpret_cast<const_data_ptr_t>(key.data()),
+		                          key.size());
 	}
 
 private:
@@ -172,8 +172,9 @@ private:
 class DecryptionTransport : public TTransport {
 public:
 	DecryptionTransport(TProtocol &prot_p, const string &key, const EncryptionUtil &encryption_util_p)
-	    : prot(prot_p), trans(*prot.getTransport()), aes(encryption_util_p.CreateEncryptionState(&key)),
-	      read_buffer_size(0), read_buffer_offset(0) {
+	    : prot(prot_p), trans(*prot.getTransport()),
+	      aes(encryption_util_p.CreateEncryptionState(EncryptionTypes::GCM, key.size())), read_buffer_size(0),
+	      read_buffer_offset(0) {
 		Initialize(key);
 	}
 	uint32_t read_virt(uint8_t *buf, uint32_t len) override {
@@ -206,9 +207,7 @@ public:
 
 		data_t computed_tag[ParquetCrypto::TAG_BYTES];
 		transport_remaining -= trans.read(computed_tag, ParquetCrypto::TAG_BYTES);
-		if (aes->Finalize(read_buffer, 0, computed_tag, ParquetCrypto::TAG_BYTES) != 0) {
-			throw InternalException("DecryptionTransport::Finalize was called with bytes remaining in AES context out");
-		}
+		aes->Finalize(read_buffer, 0, computed_tag, ParquetCrypto::TAG_BYTES);
 
 		if (transport_remaining != 0) {
 			throw InvalidInputException("Encoded ciphertext length differs from actual ciphertext length");
@@ -235,7 +234,8 @@ private:
 		// Read nonce and initialize AES
 		transport_remaining -= trans.read(nonce, ParquetCrypto::NONCE_BYTES);
 		// check whether context is initialized
-		aes->InitializeDecryption(nonce, ParquetCrypto::NONCE_BYTES, &key);
+		aes->InitializeDecryption(nonce, ParquetCrypto::NONCE_BYTES, reinterpret_cast<const_data_ptr_t>(key.data()),
+		                          key.size());
 	}
 
 	void ReadBlock(uint8_t *buf) {
@@ -373,7 +373,7 @@ bool ParquetCrypto::ValidKey(const std::string &key) {
 	}
 }
 
-string Base64Decode(const string &key) {
+static string Base64Decode(const string &key) {
 	auto result_size = Blob::FromBase64Size(key);
 	auto output = duckdb::unique_ptr<unsigned char[]>(new unsigned char[result_size]);
 	Blob::FromBase64(key, output.get(), result_size);