duckdb 1.4.1 → 1.4.2

package/src/duckdb/src/storage/table/row_group.cpp

@@ -26,14 +26,14 @@
 namespace duckdb {
 
 RowGroup::RowGroup(RowGroupCollection &collection_p, idx_t start, idx_t count)
-    : SegmentBase<RowGroup>(start, count), collection(collection_p), version_info(nullptr), allocation_size(0),
-      row_id_is_loaded(false), has_changes(false) {
+    : SegmentBase<RowGroup>(start, count), collection(collection_p), version_info(nullptr), deletes_is_loaded(false),
+      allocation_size(0), row_id_is_loaded(false), has_changes(false) {
 	Verify();
 }
 
 RowGroup::RowGroup(RowGroupCollection &collection_p, RowGroupPointer pointer)
     : SegmentBase<RowGroup>(pointer.row_start, pointer.tuple_count), collection(collection_p), version_info(nullptr),
-      allocation_size(0), row_id_is_loaded(false), has_changes(false) {
+      deletes_is_loaded(false), allocation_size(0), row_id_is_loaded(false), has_changes(false) {
 	// deserialize the columns
 	if (pointer.data_pointers.size() != collection_p.GetTypes().size()) {
 		throw IOException("Row group column count is unaligned with table column count. Corrupt file?");
@@ -45,7 +45,6 @@ RowGroup::RowGroup(RowGroupCollection &collection_p, RowGroupPointer pointer)
 		this->is_loaded[c] = false;
 	}
 	this->deletes_pointers = std::move(pointer.deletes_pointers);
-	this->deletes_is_loaded = false;
 	this->has_metadata_blocks = pointer.has_metadata_blocks;
 	this->extra_metadata_blocks = std::move(pointer.extra_metadata_blocks);
 
@@ -54,7 +53,7 @@ RowGroup::RowGroup(RowGroupCollection &collection_p, RowGroupPointer pointer)
 
 RowGroup::RowGroup(RowGroupCollection &collection_p, PersistentRowGroupData &data)
     : SegmentBase<RowGroup>(data.start, data.count), collection(collection_p), version_info(nullptr),
-      allocation_size(0), row_id_is_loaded(false), has_changes(false) {
+      deletes_is_loaded(false), allocation_size(0), row_id_is_loaded(false), has_changes(false) {
 	auto &block_manager = GetBlockManager();
 	auto &info = GetTableInfo();
 	auto &types = collection.get().GetTypes();
@@ -974,21 +973,15 @@ bool RowGroup::HasUnloadedDeletes() const {
 	return !deletes_is_loaded;
 }
 
-vector<MetaBlockPointer> RowGroup::GetColumnPointers() {
-	if (has_metadata_blocks) {
-		// we have the column metadata from the file itself - no need to deserialize metadata to fetch it
-		// read if from "column_pointers" and "extra_metadata_blocks"
-		auto result = column_pointers;
-		for (auto &block_pointer : extra_metadata_blocks) {
-			result.emplace_back(block_pointer, 0);
-		}
-		return result;
+vector<idx_t> RowGroup::GetOrComputeExtraMetadataBlocks(bool force_compute) {
+	if (has_metadata_blocks && !force_compute) {
+		return extra_metadata_blocks;
 	}
-	vector<MetaBlockPointer> result;
 	if (column_pointers.empty()) {
 		// no pointers
-		return result;
+		return {};
 	}
+	vector<MetaBlockPointer> read_pointers;
 	// column_pointers stores the beginning of each column
 	// if columns are big - they may span multiple metadata blocks
 	// we need to figure out all blocks that this row group points to
@@ -999,13 +992,25 @@ vector<MetaBlockPointer> RowGroup::GetColumnPointers() {
 		// for all but the last column pointer - we can just follow the linked list until we reach the last column
 		MetadataReader reader(metadata_manager, column_pointers[0]);
 		auto last_pointer = column_pointers[last_idx];
-		result = reader.GetRemainingBlocks(last_pointer);
+		read_pointers = reader.GetRemainingBlocks(last_pointer);
 	}
 	// for the last column we need to deserialize the column - because we don't know where it stops
 	auto &types = GetCollection().GetTypes();
-	MetadataReader reader(metadata_manager, column_pointers[last_idx], &result);
+	MetadataReader reader(metadata_manager, column_pointers[last_idx], &read_pointers);
 	ColumnData::Deserialize(GetBlockManager(), GetTableInfo(), last_idx, start, reader, types[last_idx]);
-	return result;
+
+	unordered_set<idx_t> result_as_set;
+	for (auto &ptr : read_pointers) {
+		result_as_set.emplace(ptr.block_pointer);
+	}
+	for (auto &ptr : column_pointers) {
+		result_as_set.erase(ptr.block_pointer);
+	}
+	return {result_as_set.begin(), result_as_set.end()};
+}
+
+const vector<MetaBlockPointer> &RowGroup::GetColumnStartPointers() const {
+	return column_pointers;
 }
 
 RowGroupWriteData RowGroup::WriteToDisk(RowGroupWriter &writer) {
@@ -1014,7 +1019,8 @@ RowGroupWriteData RowGroup::WriteToDisk(RowGroupWriter &writer) {
 		// we have existing metadata and the row group has not been changed
 		// re-use previous metadata
 		RowGroupWriteData result;
-		result.existing_pointers = GetColumnPointers();
+		result.reuse_existing_metadata_blocks = true;
+		result.existing_extra_metadata_blocks = GetOrComputeExtraMetadataBlocks();
 		return result;
 	}
 	auto &compression_types = writer.GetCompressionTypes();
@@ -1042,14 +1048,23 @@ RowGroupPointer RowGroup::Checkpoint(RowGroupWriteData write_data, RowGroupWrite
 	// construct the row group pointer and write the column meta data to disk
 	row_group_pointer.row_start = start;
 	row_group_pointer.tuple_count = count;
-	if (!write_data.existing_pointers.empty()) {
+	if (write_data.reuse_existing_metadata_blocks) {
 		// we are re-using the previous metadata
 		row_group_pointer.data_pointers = column_pointers;
-		row_group_pointer.has_metadata_blocks = has_metadata_blocks;
-		row_group_pointer.extra_metadata_blocks = extra_metadata_blocks;
+		row_group_pointer.has_metadata_blocks = true;
+		row_group_pointer.extra_metadata_blocks = write_data.existing_extra_metadata_blocks;
 		row_group_pointer.deletes_pointers = deletes_pointers;
-		metadata_manager->ClearModifiedBlocks(write_data.existing_pointers);
+		vector<MetaBlockPointer> extra_metadata_block_pointers;
+		extra_metadata_block_pointers.reserve(write_data.existing_extra_metadata_blocks.size());
+		for (auto &block_pointer : write_data.existing_extra_metadata_blocks) {
+			extra_metadata_block_pointers.emplace_back(block_pointer, 0);
+		}
+		metadata_manager->ClearModifiedBlocks(column_pointers);
+		metadata_manager->ClearModifiedBlocks(extra_metadata_block_pointers);
 		metadata_manager->ClearModifiedBlocks(deletes_pointers);
+		// remember metadata_blocks to avoid loading them on future checkpoints
+		has_metadata_blocks = true;
+		extra_metadata_blocks = row_group_pointer.extra_metadata_blocks;
 		return row_group_pointer;
 	}
 	D_ASSERT(write_data.states.size() == columns.size());
@@ -1092,6 +1107,7 @@ RowGroupPointer RowGroup::Checkpoint(RowGroupWriteData write_data, RowGroupWrite
 		}
 		// this metadata block is not stored - add it to the extra metadata blocks
 		row_group_pointer.extra_metadata_blocks.push_back(column_pointer.block_pointer);
+		metadata_blocks.insert(column_pointer.block_pointer);
 	}
 	// set up the pointers correctly within this row group for future operations
 	column_pointers = row_group_pointer.data_pointers;
@@ -1113,6 +1129,7 @@ bool RowGroup::HasChanges() const {
 		// we have deletes
 		return true;
 	}
+	D_ASSERT(!deletes_is_loaded.load());
 	// check if any of the columns have changes
 	// avoid loading unloaded columns - unloaded columns can never have changes
 	for (idx_t c = 0; c < columns.size(); c++) {

package/src/duckdb/src/storage/table/row_group_collection.cpp

@@ -665,14 +665,16 @@ void RowGroupCollection::Update(TransactionData transaction, DataTable &data_tab
 void RowGroupCollection::RemoveFromIndexes(TableIndexList &indexes, Vector &row_identifiers, idx_t count) {
 	auto row_ids = FlatVector::GetData<row_t>(row_identifiers);
 
-	// Collect all indexed columns.
+	// Collect all Indexed columns on the table.
 	unordered_set<column_t> indexed_column_id_set;
 	indexes.Scan([&](Index &index) {
-		D_ASSERT(index.IsBound());
 		auto &set = index.GetColumnIdSet();
 		indexed_column_id_set.insert(set.begin(), set.end());
 		return false;
 	});
+
+	// If we are in WAL replay, delete data will be buffered, and so we sort the column_ids
+	// since the sorted form will be the mapping used to get back physical IDs from the buffered index chunk.
 	vector<StorageIndex> column_ids;
 	for (auto &col : indexed_column_id_set) {
 		column_ids.emplace_back(col);
@@ -686,10 +688,10 @@ void RowGroupCollection::RemoveFromIndexes(TableIndexList &indexes, Vector &row_
 
 	// Initialize the fetch state. Only use indexed columns.
 	TableScanState state;
-	state.Initialize(std::move(column_ids));
+	auto column_ids_copy = column_ids;
+	state.Initialize(std::move(column_ids_copy));
 	state.table_state.max_row = row_start + total_rows;
 
-	// Used for scanning data. Only contains the indexed columns.
 	DataChunk fetch_chunk;
 	fetch_chunk.Initialize(GetAllocator(), column_types);
 
@@ -749,17 +751,24 @@ void RowGroupCollection::RemoveFromIndexes(TableIndexList &indexes, Vector &row_
 		result_chunk.SetCardinality(fetch_chunk);
 
 		// Slice the vector with all rows that are present in this vector.
-		// Then, erase all values from the indexes.
+		// If the index is bound, delete the data. If unbound, buffer into unbound_index.
 		result_chunk.Slice(sel, sel_count);
 		indexes.Scan([&](Index &index) {
 			if (index.IsBound()) {
 				index.Cast<BoundIndex>().Delete(result_chunk, row_identifiers);
 				return false;
 			}
-			throw MissingExtensionException(
-			    "Cannot delete from index '%s', unknown index type '%s'. You need to load the "
-			    "extension that provides this index type before table '%s' can be modified.",
-			    index.GetIndexName(), index.GetIndexType(), info->GetTableName());
+			// Buffering takes only the indexed columns in ordering of the column_ids mapping.
+			DataChunk index_column_chunk;
+			index_column_chunk.InitializeEmpty(column_types);
+			for (idx_t i = 0; i < column_types.size(); i++) {
+				auto col_id = column_ids[i].GetPrimaryIndex();
+				index_column_chunk.data[i].Reference(result_chunk.data[col_id]);
+			}
+			index_column_chunk.SetCardinality(result_chunk.size());
+			auto &unbound_index = index.Cast<UnboundIndex>();
+			unbound_index.BufferChunk(index_column_chunk, row_identifiers, column_ids, BufferedIndexReplay::DEL_ENTRY);
+			return false;
 		});
 	}
 }
@@ -1136,7 +1145,7 @@ void RowGroupCollection::Checkpoint(TableDataWriter &writer, TableStatistics &gl
 				break;
 			}
 			auto &write_state = checkpoint_state.write_data[segment_idx];
-			if (write_state.existing_pointers.empty()) {
+			if (!write_state.reuse_existing_metadata_blocks) {
 				table_has_changes = true;
 				break;
 			}
@@ -1150,7 +1159,14 @@ void RowGroupCollection::Checkpoint(TableDataWriter &writer, TableStatistics &gl
 				auto &entry = segments[segment_idx];
 				auto &row_group = *entry.node;
 				auto &write_state = checkpoint_state.write_data[segment_idx];
-				metadata_manager.ClearModifiedBlocks(write_state.existing_pointers);
+				metadata_manager.ClearModifiedBlocks(row_group.GetColumnStartPointers());
+				D_ASSERT(write_state.reuse_existing_metadata_blocks);
+				vector<MetaBlockPointer> extra_metadata_block_pointers;
+				extra_metadata_block_pointers.reserve(write_state.existing_extra_metadata_blocks.size());
+				for (auto &block_pointer : write_state.existing_extra_metadata_blocks) {
+					extra_metadata_block_pointers.emplace_back(block_pointer, 0);
+				}
+				metadata_manager.ClearModifiedBlocks(extra_metadata_block_pointers);
 				metadata_manager.ClearModifiedBlocks(row_group.GetDeletesPointers());
 				row_groups->AppendSegment(l, std::move(entry.node));
 			}
@@ -1178,11 +1194,98 @@ void RowGroupCollection::Checkpoint(TableDataWriter &writer, TableStatistics &gl
 		if (!row_group_writer) {
 			throw InternalException("Missing row group writer for index %llu", segment_idx);
 		}
+		bool metadata_reuse = checkpoint_state.write_data[segment_idx].reuse_existing_metadata_blocks;
 		auto pointer =
 		    row_group.Checkpoint(std::move(checkpoint_state.write_data[segment_idx]), *row_group_writer, global_stats);
+
+		auto debug_verify_blocks = DBConfig::GetSetting<DebugVerifyBlocksSetting>(GetAttached().GetDatabase()) &&
+		                           dynamic_cast<SingleFileTableDataWriter *>(&checkpoint_state.writer) != nullptr;
+		RowGroupPointer pointer_copy;
+		if (debug_verify_blocks) {
+			pointer_copy = pointer;
+		}
 		writer.AddRowGroup(std::move(pointer), std::move(row_group_writer));
 		row_groups->AppendSegment(l, std::move(entry.node));
 		new_total_rows += row_group.count;
+
+		if (debug_verify_blocks) {
+			if (!pointer_copy.has_metadata_blocks) {
+				throw InternalException("Checkpointing should always remember metadata blocks");
+			}
+			if (metadata_reuse && pointer_copy.data_pointers != row_group.GetColumnStartPointers()) {
+				throw InternalException("Colum start pointers changed during metadata reuse");
+			}
+
+			// Capture blocks that have been written
+			vector<MetaBlockPointer> all_written_blocks = pointer_copy.data_pointers;
+			vector<MetaBlockPointer> all_metadata_blocks;
+			for (auto &block : pointer_copy.extra_metadata_blocks) {
+				all_written_blocks.emplace_back(block, 0);
+				all_metadata_blocks.emplace_back(block, 0);
+			}
+
+			// Verify that we can load the metadata correctly again
+			vector<MetaBlockPointer> all_quick_read_blocks;
+			for (auto &ptr : row_group.GetColumnStartPointers()) {
+				all_quick_read_blocks.emplace_back(ptr);
+				if (metadata_reuse && !block_manager.GetMetadataManager().BlockHasBeenCleared(ptr)) {
+					throw InternalException("Found column start block that was not cleared");
+				}
+			}
+			auto extra_metadata_blocks = row_group.GetOrComputeExtraMetadataBlocks(/* force_compute: */ true);
+			for (auto &ptr : extra_metadata_blocks) {
+				auto block_pointer = MetaBlockPointer(ptr, 0);
+				all_quick_read_blocks.emplace_back(block_pointer);
+				if (metadata_reuse && !block_manager.GetMetadataManager().BlockHasBeenCleared(block_pointer)) {
+					throw InternalException("Found extra metadata block that was not cleared");
+				}
+			}
+
+			// Deserialize all columns to check if the quick read via GetOrComputeExtraMetadataBlocks was correct
+			vector<MetaBlockPointer> all_full_read_blocks;
+			auto column_start_pointers = row_group.GetColumnStartPointers();
+			auto &types = row_group.GetCollection().GetTypes();
+			auto &metadata_manager = row_group.GetCollection().GetMetadataManager();
+			for (idx_t i = 0; i < column_start_pointers.size(); i++) {
+				MetadataReader reader(metadata_manager, column_start_pointers[i], &all_full_read_blocks);
+				ColumnData::Deserialize(GetBlockManager(), GetTableInfo(), i, row_group.start, reader, types[i]);
+			}
+
+			// Derive sets of blocks to compare
+			set<idx_t> all_written_block_ids;
+			for (auto &ptr : all_written_blocks) {
+				all_written_block_ids.insert(ptr.block_pointer);
+			}
+			set<idx_t> all_quick_read_block_ids;
+			for (auto &ptr : all_quick_read_blocks) {
+				all_quick_read_block_ids.insert(ptr.block_pointer);
+			}
+			set<idx_t> all_full_read_block_ids;
+			for (auto &ptr : all_full_read_blocks) {
+				all_full_read_block_ids.insert(ptr.block_pointer);
+			}
+			if (all_written_block_ids != all_quick_read_block_ids ||
+			    all_quick_read_block_ids != all_full_read_block_ids) {
+				std::stringstream oss;
+				oss << "Written: ";
+				for (auto &block : all_written_blocks) {
+					oss << block << ", ";
+				}
+				oss << "\n";
+				oss << "Quick read: ";
+				for (auto &block : all_quick_read_blocks) {
+					oss << block << ", ";
+				}
+				oss << "\n";
+				oss << "Full read: ";
+				for (auto &block : all_full_read_blocks) {
+					oss << block << ", ";
+				}
+				oss << "\n";
+
+				throw InternalException("Reloading blocks just written does not yield same blocks: " + oss.str());
+			}
+		}
 	}
 	total_rows = new_total_rows;
 	l.Release();

package/src/duckdb/src/storage/table_index_list.cpp

@@ -147,11 +147,17 @@ void TableIndexList::Bind(ClientContext &context, DataTableInfo &table_info, con
 		// Create an IndexBinder to bind the index
 		IndexBinder idx_binder(*binder, context);
 
-		// Apply any outstanding appends and replace the unbound index with a bound index.
+		// Apply any outstanding buffered replays and replace the unbound index with a bound index.
 		auto &unbound_index = index_entry->index->Cast<UnboundIndex>();
 		auto bound_idx = idx_binder.BindIndex(unbound_index);
-		if (unbound_index.HasBufferedAppends()) {
-			bound_idx->ApplyBufferedAppends(column_types, unbound_index.GetBufferedAppends(),
+		if (unbound_index.HasBufferedReplays()) {
+			// For replaying buffered index operations, we only want the physical column types (skip over
+			// generated column types).
+			vector<LogicalType> physical_column_types;
+			for (auto &col : table.GetColumns().Physical()) {
+				physical_column_types.push_back(col.Type());
+			}
+			bound_idx->ApplyBufferedReplays(physical_column_types, unbound_index.GetBufferedReplays(),
 			                                unbound_index.GetMappedColumnIds());
 		}
 
@@ -255,11 +261,18 @@ void TableIndexList::InitializeIndexChunk(DataChunk &index_chunk, const vector<L
 	auto &index_list = data_table_info.GetIndexes();
 	auto indexed_columns = index_list.GetRequiredColumns();
 
-	vector<LogicalType> index_types;
+	// Store the mapped_column_ids and index_types in sorted canonical form, needed for
+	// buffering WAL index operations during replay (see notes in unbound_index.hpp).
+	// First sort mapped_column_ids, then populate index_types according to the sorted order.
 	for (auto &col : indexed_columns) {
-		index_types.push_back(table_types[col]);
 		mapped_column_ids.emplace_back(col);
 	}
+	std::sort(mapped_column_ids.begin(), mapped_column_ids.end());
+
+	vector<LogicalType> index_types;
+	for (auto &col : mapped_column_ids) {
+		index_types.push_back(table_types[col.GetPrimaryIndex()]);
+	}
 
 	index_chunk.InitializeEmpty(index_types);
 }

package/src/duckdb/src/transaction/cleanup_state.cpp

@@ -95,10 +95,15 @@ void CleanupState::Flush() {
 	// set up the row identifiers vector
 	Vector row_identifiers(LogicalType::ROW_TYPE, data_ptr_cast(row_numbers));
 
-	// delete the tuples from all the indexes
+	// delete the tuples from all the indexes.
+	// If there is any issue with removal, a FatalException must be thrown since there may be a corruption of
+	// data, hence the transaction cannot be guaranteed.
 	try {
 		current_table->RemoveFromIndexes(row_identifiers, count);
-	} catch (...) { // NOLINT: ignore errors here
+	} catch (std::exception &ex) {
+		throw FatalException(ErrorData(ex).Message());
+	} catch (...) {
+		throw FatalException("unknown failure in CleanupState::Flush");
 	}
 
 	count = 0;

package/src/duckdb/third_party/mbedtls/include/mbedtls_wrapper.hpp

@@ -81,6 +81,7 @@ class AESStateMBEDTLS : public duckdb::EncryptionState {
 		DUCKDB_API void GenerateRandomData(duckdb::data_ptr_t data, duckdb::idx_t len) override;
 		DUCKDB_API void FinalizeGCM(duckdb::data_ptr_t tag, duckdb::idx_t tag_len);
 		DUCKDB_API const mbedtls_cipher_info_t *GetCipher(size_t key_len);
+		DUCKDB_API static void SecureClearData(duckdb::data_ptr_t data, duckdb::idx_t len);
 
 	private:
 		DUCKDB_API void InitializeInternal(duckdb::const_data_ptr_t iv, duckdb::idx_t iv_len, duckdb::const_data_ptr_t aad, duckdb::idx_t aad_len);
@@ -98,6 +99,10 @@ class AESStateMBEDTLS : public duckdb::EncryptionState {
 		}
 
 		~AESStateMBEDTLSFactory() override {} //
+
+		DUCKDB_API bool SupportsEncryption() override {
+			return false;
+		}
 	};
 };
 

package/src/duckdb/third_party/mbedtls/mbedtls_wrapper.cpp

@@ -271,6 +271,10 @@ const mbedtls_cipher_info_t *MbedTlsWrapper::AESStateMBEDTLS::GetCipher(size_t k
 	}
 }
 
+void MbedTlsWrapper::AESStateMBEDTLS::SecureClearData(duckdb::data_ptr_t data, duckdb::idx_t len) {
+	mbedtls_platform_zeroize(data, len);
+}
+
 MbedTlsWrapper::AESStateMBEDTLS::AESStateMBEDTLS(duckdb::EncryptionTypes::CipherType cipher_p, duckdb::idx_t key_len) : EncryptionState(cipher_p, key_len), context(duckdb::make_uniq<mbedtls_cipher_context_t>()) {
 	mbedtls_cipher_init(context.get());
 
@@ -296,20 +300,12 @@ MbedTlsWrapper::AESStateMBEDTLS::~AESStateMBEDTLS() {
 	}
 }
 
-void MbedTlsWrapper::AESStateMBEDTLS::GenerateRandomDataStatic(duckdb::data_ptr_t data, duckdb::idx_t len) {
-	duckdb::RandomEngine random_engine;
-
-	while (len) {
-		const auto random_integer = random_engine.NextRandomInteger();
-		const auto next = duckdb::MinValue<duckdb::idx_t>(len, sizeof(random_integer));
-		memcpy(data, duckdb::const_data_ptr_cast(&random_integer), next);
-		data += next;
-		len -= next;
-	}
+static void ThrowInsecureRNG() {
+	throw duckdb::InvalidConfigurationException("DuckDB requires a secure random engine to be loaded to enable secure crypto. Normally, this will be handled automatically by DuckDB by autoloading the `httpfs` Extension, but that seems to have failed. Please ensure the httpfs extension is loaded manually using `LOAD httpfs`.");
 }
 
 void MbedTlsWrapper::AESStateMBEDTLS::GenerateRandomData(duckdb::data_ptr_t data, duckdb::idx_t len) {
-	GenerateRandomDataStatic(data, len);
+	ThrowInsecureRNG();
 }
 
 void MbedTlsWrapper::AESStateMBEDTLS::InitializeInternal(duckdb::const_data_ptr_t iv, duckdb::idx_t iv_len, duckdb::const_data_ptr_t aad, duckdb::idx_t aad_len){
@@ -325,16 +321,7 @@ void MbedTlsWrapper::AESStateMBEDTLS::InitializeInternal(duckdb::const_data_ptr_
 }
 
 void MbedTlsWrapper::AESStateMBEDTLS::InitializeEncryption(duckdb::const_data_ptr_t iv, duckdb::idx_t iv_len, duckdb::const_data_ptr_t key, duckdb::idx_t key_len_p, duckdb::const_data_ptr_t aad, duckdb::idx_t aad_len) {
-	mode = duckdb::EncryptionTypes::ENCRYPT;
-
-	if (key_len_p != key_len) {
-		throw duckdb::InternalException("Invalid encryption key length, expected %llu, got %llu", key_len, key_len_p);
-	}
-	if (mbedtls_cipher_setkey(context.get(), key, key_len * 8, MBEDTLS_ENCRYPT)) {
-		throw runtime_error("Failed to set AES key for encryption");
-	}
-
-	InitializeInternal(iv, iv_len, aad, aad_len);
+	ThrowInsecureRNG();
 }
 
 void MbedTlsWrapper::AESStateMBEDTLS::InitializeDecryption(duckdb::const_data_ptr_t iv, duckdb::idx_t iv_len, duckdb::const_data_ptr_t key, duckdb::idx_t key_len_p, duckdb::const_data_ptr_t aad, duckdb::idx_t aad_len) {