duckdb 1.3.3-dev4.0 → 1.3.3

package/src/duckdb/src/include/duckdb/storage/storage_manager.hpp

@@ -58,10 +58,11 @@ struct CheckpointOptions {
 	CheckpointType type;
 };
 
-//! StorageManager is responsible for managing the physical storage of a persistent database.
+//! StorageManager is responsible for managing the physical storage of the
+//! database on disk
 class StorageManager {
 public:
-	StorageManager(AttachedDatabase &db, string path, const AttachOptions &options);
+	StorageManager(AttachedDatabase &db, string path, bool read_only);
 	virtual ~StorageManager();
 
 public:
@@ -71,10 +72,10 @@ public:
 	//! Initialize a database or load an existing database from the database file path. The block_alloc_size is
 	//! either set, or invalid. If invalid, then DuckDB defaults to the default_block_alloc_size (DBConfig),
 	//! or the file's block allocation size, if it is an existing database.
-	void Initialize(QueryContext context);
+	void Initialize(StorageOptions options);
 
 	DatabaseInstance &GetDatabase();
-	AttachedDatabase &GetAttached() const {
+	AttachedDatabase &GetAttached() {
 		return db;
 	}
 
@@ -93,13 +94,14 @@ public:
 		return load_complete;
 	}
 	//! The path to the WAL, derived from the database file path
-	string GetWALPath() const;
-	bool InMemory() const;
+	string GetWALPath();
+	bool InMemory();
 
 	virtual bool AutomaticCheckpoint(idx_t estimated_wal_bytes) = 0;
 	virtual unique_ptr<StorageCommitState> GenStorageCommitState(WriteAheadLog &wal) = 0;
 	virtual bool IsCheckpointClean(MetaBlockPointer checkpoint_id) = 0;
-	virtual void CreateCheckpoint(QueryContext context, CheckpointOptions options = CheckpointOptions()) = 0;
+	virtual void CreateCheckpoint(optional_ptr<ClientContext> client_context,
+	                              CheckpointOptions options = CheckpointOptions()) = 0;
 	virtual DatabaseSize GetDatabaseSize() = 0;
 	virtual vector<MetadataBlockInfo> GetMetadataInfo() = 0;
 	virtual shared_ptr<TableIOManager> GetTableIOManager(BoundCreateTableInfo *info) = 0;
@@ -115,34 +117,12 @@ public:
 		D_ASSERT(HasStorageVersion());
 		return storage_version.GetIndex();
 	}
-	void AddInMemoryChange(idx_t size) {
-		in_memory_change_size += size;
-	}
-	void ResetInMemoryChange() {
-		in_memory_change_size = 0;
-	}
-	bool CompressionIsEnabled() const {
-		return storage_options.compress_in_memory == CompressInMemory::COMPRESS;
-	}
-	EncryptionTypes::CipherType GetCipher() const {
-		return storage_options.encryption_cipher;
-	}
-	void SetCipher(EncryptionTypes::CipherType cipher_p) {
-		D_ASSERT(cipher_p != EncryptionTypes::INVALID);
-		if (cipher_p == EncryptionTypes::CBC) {
-			throw InvalidInputException("CBC cipher is disabled");
-		}
-		storage_options.encryption_cipher = cipher_p;
-	}
-	bool IsEncrypted() const {
-		return storage_options.encryption;
-	}
 
 protected:
-	virtual void LoadDatabase(QueryContext context) = 0;
+	virtual void LoadDatabase(StorageOptions options) = 0;
 
 protected:
-	//! The attached database managed by this storage manager.
+	//! The database this storage manager belongs to
 	AttachedDatabase &db;
 	//! The path of the database
 	string path;
@@ -155,10 +135,6 @@ protected:
 	bool load_complete = false;
 	//! The serialization compatibility version when reading and writing from this database
 	optional_idx storage_version;
-	//! Estimated size of changes for determining automatic checkpointing on in-memory databases
-	atomic<idx_t> in_memory_change_size;
-	//! Storage options passed in through configuration
-	StorageOptions storage_options;
 
 public:
 	template <class TARGET>
@@ -173,30 +149,28 @@ public:
 	}
 };
 
-//! Stores the database in a single file.
+//! Stores database in a single file.
 class SingleFileStorageManager : public StorageManager {
 public:
 	SingleFileStorageManager() = delete;
-	SingleFileStorageManager(AttachedDatabase &db, string path, const AttachOptions &options);
+	SingleFileStorageManager(AttachedDatabase &db, string path, bool read_only);
 
-	//! The BlockManager to read from and write to blocks (meta data and data).
+	//! The BlockManager to read/store meta information and data in blocks
 	unique_ptr<BlockManager> block_manager;
-	//! The table I/O manager.
+	//! TableIoManager
 	unique_ptr<TableIOManager> table_io_manager;
 
 public:
 	bool AutomaticCheckpoint(idx_t estimated_wal_bytes) override;
 	unique_ptr<StorageCommitState> GenStorageCommitState(WriteAheadLog &wal) override;
 	bool IsCheckpointClean(MetaBlockPointer checkpoint_id) override;
-	void CreateCheckpoint(QueryContext context, CheckpointOptions options) override;
+	void CreateCheckpoint(optional_ptr<ClientContext> client_context, CheckpointOptions options) override;
 	DatabaseSize GetDatabaseSize() override;
 	vector<MetadataBlockInfo> GetMetadataInfo() override;
 	shared_ptr<TableIOManager> GetTableIOManager(BoundCreateTableInfo *info) override;
 	BlockManager &GetBlockManager() override;
 
 protected:
-	void LoadDatabase(QueryContext context) override;
-
-	unique_ptr<CheckpointWriter> CreateCheckpointWriter(QueryContext context, CheckpointOptions options);
+	void LoadDatabase(StorageOptions options) override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/storage_options.hpp

@@ -10,13 +10,9 @@
 
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/optional_idx.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/encryption_state.hpp"
 
 namespace duckdb {
 
-enum class CompressInMemory { AUTOMATIC, COMPRESS, DO_NOT_COMPRESS };
-
 struct StorageOptions {
 	//! The allocation size of blocks for this attached database file (if any)
 	optional_idx block_alloc_size;
@@ -26,25 +22,8 @@ struct StorageOptions {
 	optional_idx storage_version;
 	//! Block header size (only used for encryption)
 	optional_idx block_header_size;
-
-	CompressInMemory compress_in_memory = CompressInMemory::AUTOMATIC;
-
 	//! Whether the database is encrypted
 	bool encryption = false;
-	//! Encryption algorithm
-	EncryptionTypes::CipherType encryption_cipher = EncryptionTypes::INVALID;
-	//! encryption key
-	//! FIXME: change to a unique_ptr in the future
-	shared_ptr<string> user_key;
-
-	void Initialize(const unordered_map<string, Value> &options);
 };
 
-inline void ClearUserKey(shared_ptr<string> const &encryption_key) {
-	if (encryption_key && !encryption_key->empty()) {
-		memset(&(*encryption_key)[0], 0, encryption_key->size());
-		encryption_key->clear();
-	}
-}
-
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/array_column_data.hpp

@@ -61,7 +61,6 @@ public:
 	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, ColumnCheckpointInfo &info) override;
 
 	bool IsPersistent() override;
-	bool HasAnyChanges() const override;
 	PersistentColumnData Serialize() override;
 	void InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) override;
 

package/src/duckdb/src/include/duckdb/storage/table/column_checkpoint_state.hpp

@@ -85,9 +85,9 @@ public:
 
 public:
 	bool IsFlushed();
-	void Flush(QueryContext context, const idx_t free_space_left) override;
+	void Flush(const idx_t free_space_left) override;
 	void Merge(PartialBlock &other, idx_t offset, idx_t other_size) override;
-	void AddSegmentToTail(ColumnData &data, ColumnSegment &segment, uint32_t offset_in_block) override;
+	void AddSegmentToTail(ColumnData &data, ColumnSegment &segment, uint32_t offset_in_block);
 	void Clear() override;
 };
 

package/src/duckdb/src/include/duckdb/storage/table/column_data.hpp

@@ -102,11 +102,6 @@ public:
 	//! Whether or not the column has any updates
 	bool HasUpdates() const;
 	bool HasChanges(idx_t start_row, idx_t end_row) const;
-	//! Whether or not the column has changes at this level
-	bool HasChanges() const;
-
-	//! Whether or not the column has ANY changes, including in child columns
-	virtual bool HasAnyChanges() const;
 	//! Whether or not we can scan an entire vector
 	virtual ScanVectorType GetVectorScanType(ColumnScanState &state, idx_t scan_count, Vector &result);
 
@@ -219,7 +214,6 @@ protected:
 	void FetchUpdateRow(TransactionData transaction, row_t row_id, Vector &result, idx_t result_idx);
 	void UpdateInternal(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
 	                    idx_t update_count, Vector &base_vector);
-	idx_t FetchUpdateData(ColumnScanState &state, row_t *row_ids, Vector &base_vector);
 
 	idx_t GetVectorCount(idx_t vector_index) const;
 
@@ -238,7 +232,7 @@ protected:
 	//! The stats of the root segment
 	unique_ptr<SegmentStatistics> stats;
 	//! Total transient allocation size
-	atomic<idx_t> allocation_size;
+	idx_t allocation_size;
 
 private:
 	//! The parent column (if any)

package/src/duckdb/src/include/duckdb/storage/table/column_data_checkpointer.hpp

@@ -22,10 +22,9 @@ public:
 	ColumnDataCheckpointData() {
 	}
 	ColumnDataCheckpointData(ColumnCheckpointState &checkpoint_state, ColumnData &col_data, DatabaseInstance &db,
-	                         RowGroup &row_group, ColumnCheckpointInfo &checkpoint_info,
-	                         StorageManager &storage_manager)
+	                         RowGroup &row_group, ColumnCheckpointInfo &checkpoint_info)
 	    : checkpoint_state(checkpoint_state), col_data(col_data), db(db), row_group(row_group),
-	      checkpoint_info(checkpoint_info), storage_manager(storage_manager) {
+	      checkpoint_info(checkpoint_info) {
 	}
 
 public:
@@ -35,7 +34,6 @@ public:
 	RowGroup &GetRowGroup();
 	ColumnCheckpointState &GetCheckpointState();
 	DatabaseInstance &GetDatabase();
-	StorageManager &GetStorageManager();
 
 private:
 	optional_ptr<ColumnCheckpointState> checkpoint_state;
@@ -43,7 +41,6 @@ private:
 	optional_ptr<DatabaseInstance> db;
 	optional_ptr<RowGroup> row_group;
 	optional_ptr<ColumnCheckpointInfo> checkpoint_info;
-	optional_ptr<StorageManager> storage_manager;
 };
 
 struct CheckpointAnalyzeResult {

package/src/duckdb/src/include/duckdb/storage/table/column_segment.hpp

@@ -20,21 +20,19 @@
 #include "duckdb/storage/table/segment_base.hpp"
 
 namespace duckdb {
-
-class BaseStatistics;
+class ColumnSegment;
 class BlockManager;
 class ColumnData;
-class ColumnSegment;
 class DatabaseInstance;
-class TableFilter;
 class Transaction;
+class BaseStatistics;
 class UpdateSegment;
-
-struct ColumnAppendState;
+class TableFilter;
+struct TableFilterState;
 struct ColumnFetchState;
 struct ColumnScanState;
+struct ColumnAppendState;
 struct PrefetchState;
-struct TableFilterState;
 
 enum class ColumnSegmentType : uint8_t { TRANSIENT, PERSISTENT };
 //! TableFilter represents a filter pushed down into the table scan.
@@ -99,13 +97,12 @@ public:
 	//! Revert an append made to this segment
 	void RevertAppend(idx_t start_row);
 
-	//! Convert a transient in-memory segment to a persistent segment backed by an on-disk block.
+	//! Convert a transient in-memory segment into a persistent segment blocked by an on-disk block.
 	//! Only used during checkpointing.
-	void ConvertToPersistent(QueryContext context, optional_ptr<BlockManager> block_manager, const block_id_t block_id);
+	void ConvertToPersistent(optional_ptr<BlockManager> block_manager, block_id_t block_id);
 	//! Updates pointers to refer to the given block and offset. This is only used
 	//! when sharing a block among segments. This is invoked only AFTER the block is written.
 	void MarkAsPersistent(shared_ptr<BlockHandle> block, uint32_t offset_in_block);
-	void SetBlock(shared_ptr<BlockHandle> block, uint32_t offset);
 	//! Gets a data pointer from a persistent column segment
 	DataPointer GetDataPointer();
 

package/src/duckdb/src/include/duckdb/storage/table/data_table_info.hpp

@@ -23,9 +23,9 @@ struct DataTableInfo {
 public:
 	DataTableInfo(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_manager_p, string schema, string table);
 
-	//! Bind unknown indexes throwing an exception if binding fails.
-	//! Only binds the specified index type, or all, if nullptr.
-	void BindIndexes(ClientContext &context, const char *index_type = nullptr);
+	//! Initialize any unknown indexes whose types might now be present after an extension load, optionally throwing an
+	//! exception if an index can't be initialized
+	void InitializeIndexes(ClientContext &context, const char *index_type = nullptr);
 
 	//! Whether or not the table is temporary
 	bool IsTemporary() const;

package/src/duckdb/src/include/duckdb/storage/table/list_column_data.hpp

@@ -59,7 +59,6 @@ public:
 	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, ColumnCheckpointInfo &info) override;
 
 	bool IsPersistent() override;
-	bool HasAnyChanges() const override;
 	PersistentColumnData Serialize() override;
 	void InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) override;
 

package/src/duckdb/src/include/duckdb/storage/table/persistent_table_data.hpp

@@ -22,7 +22,6 @@ public:
 	explicit PersistentTableData(idx_t column_count);
 	~PersistentTableData();
 
-	MetaBlockPointer base_table_pointer;
 	TableStatistics table_stats;
 	idx_t total_rows;
 	idx_t row_group_count;

package/src/duckdb/src/include/duckdb/storage/table/row_group.hpp

@@ -65,7 +65,6 @@ struct RowGroupWriteInfo {
 struct RowGroupWriteData {
 	vector<unique_ptr<ColumnCheckpointState>> states;
 	vector<BaseStatistics> statistics;
-	vector<MetaBlockPointer> existing_pointers;
 };
 
 class RowGroup : public SegmentBase<RowGroup> {
@@ -93,12 +92,6 @@ public:
 	RowGroupCollection &GetCollection() {
 		return collection.get();
 	}
-	//! Returns the list of meta block pointers used by the columns
-	vector<MetaBlockPointer> GetColumnPointers();
-	//! Returns the list of meta block pointers used by the deletes
-	const vector<MetaBlockPointer> &GetDeletesPointers() const {
-		return deletes_pointers;
-	}
 	BlockManager &GetBlockManager();
 	DataTableInfo &GetTableInfo();
 
@@ -113,7 +106,6 @@ public:
 	void CommitDropColumn(const idx_t column_index);
 
 	void InitializeEmpty(const vector<LogicalType> &types);
-	bool HasChanges() const;
 
 	//! Initialize a scan over this row_group
 	bool InitializeScan(CollectionScanState &state);
@@ -164,7 +156,7 @@ public:
 	            const vector<PhysicalIndex> &column_ids);
 	//! Update a single column; corresponds to DataTable::UpdateColumn
 	//! This method should only be called from the WAL
-	void UpdateColumn(TransactionData transaction, DataChunk &updates, Vector &row_ids, idx_t offset, idx_t count,
+	void UpdateColumn(TransactionData transaction, DataChunk &updates, Vector &row_ids,
 	                  const vector<column_t> &column_path);
 
 	void MergeStatistics(idx_t column_idx, const BaseStatistics &other);
@@ -204,8 +196,6 @@ private:
 	ColumnData &GetColumn(const StorageIndex &c);
 	idx_t GetColumnCount() const;
 	vector<shared_ptr<ColumnData>> &GetColumns();
-	ColumnData &GetRowIdColumnData();
-	void SetCount(idx_t count);
 
 	template <TableScanType TYPE>
 	void TemplatedScan(TransactionData transaction, CollectionScanState &state, DataChunk &result);
@@ -219,13 +209,8 @@ private:
 	vector<MetaBlockPointer> column_pointers;
 	unique_ptr<atomic<bool>[]> is_loaded;
 	vector<MetaBlockPointer> deletes_pointers;
-	bool has_metadata_blocks = false;
-	vector<idx_t> extra_metadata_blocks;
 	atomic<bool> deletes_is_loaded;
-	atomic<idx_t> allocation_size;
-	unique_ptr<ColumnData> row_id_column_data;
-	atomic<bool> row_id_is_loaded;
-	atomic<bool> has_changes;
+	idx_t allocation_size;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp

@@ -51,7 +51,6 @@ public:
 	void Initialize(PersistentCollectionData &data);
 	void Initialize(PersistentTableData &data);
 	void InitializeEmpty();
-	void FinalizeCheckpoint(MetaBlockPointer pointer);
 
 	bool IsEmpty() const;
 
@@ -76,8 +75,6 @@ public:
 
 	void Fetch(TransactionData transaction, DataChunk &result, const vector<StorageIndex> &column_ids,
 	           const Vector &row_identifiers, idx_t fetch_count, ColumnFetchState &state);
-	//! Returns true, if the row group can fetch the row id for the transaction.
-	bool CanFetch(TransactionData, const row_t row_id);
 
 	//! Initialize an append of a variable number of rows. FinalizeAppend must be called after appending is done.
 	void InitializeAppend(TableAppendState &state);
@@ -146,13 +143,10 @@ public:
 	idx_t GetRowGroupSize() const {
 		return row_group_size;
 	}
-	void SetAppendRequiresNewRowGroup();
 
 private:
 	bool IsEmpty(SegmentLock &) const;
 
-	optional_ptr<RowGroup> NextUpdateRowGroup(row_t *ids, idx_t &pos, idx_t count) const;
-
 private:
 	//! BlockManager
 	BlockManager &block_manager;
@@ -170,11 +164,7 @@ private:
 	//! Table statistics
 	TableStatistics stats;
 	//! Allocation size, only tracked for appends
-	atomic<idx_t> allocation_size;
-	//! Root metadata pointer, if the collection is loaded from disk
-	MetaBlockPointer metadata_pointer;
-	//! Whether or not we need to append a new row group prior to appending
-	bool requires_new_row_group;
+	idx_t allocation_size;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/row_group_segment_tree.hpp

@@ -23,10 +23,6 @@ public:
 
 	void Initialize(PersistentTableData &data);
 
-	MetaBlockPointer GetRootPointer() const {
-		return root_pointer;
-	}
-
 protected:
 	unique_ptr<RowGroup> LoadSegment() override;
 
@@ -34,7 +30,6 @@ protected:
 	idx_t current_row_group;
 	idx_t max_row_group;
 	unique_ptr<MetadataReader> reader;
-	MetaBlockPointer root_pointer;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/segment_lock.hpp

@@ -31,10 +31,6 @@ public:
 		return *this;
 	}
 
-	void Release() {
-		lock.unlock();
-	}
-
 private:
 	unique_lock<mutex> lock;
 };

package/src/duckdb/src/include/duckdb/storage/table/segment_tree.hpp

@@ -38,7 +38,7 @@ public:
 
 	//! Locks the segment tree. All methods to the segment tree either lock the segment tree, or take an already
 	//! obtained lock.
-	SegmentLock Lock() const {
+	SegmentLock Lock() {
 		return SegmentLock(node_lock);
 	}
 
@@ -76,15 +76,12 @@ public:
 		auto l = Lock();
 		return ReferenceSegments(l);
 	}
-	const vector<SegmentNode<T>> &ReferenceLoadedSegments(SegmentLock &l) const {
-		return nodes;
-	}
 
 	idx_t GetSegmentCount() {
 		auto l = Lock();
 		return GetSegmentCount(l);
 	}
-	idx_t GetSegmentCount(SegmentLock &l) const {
+	idx_t GetSegmentCount(SegmentLock &l) {
 		return nodes.size();
 	}
 	//! Gets a pointer to the nth segment. Negative numbers start from the back.
@@ -183,10 +180,10 @@ public:
 	//! Erase all segments after a specific segment
 	void EraseSegments(SegmentLock &l, idx_t segment_start) {
 		LoadAllSegments(l);
-		if (segment_start >= nodes.size()) {
+		if (segment_start >= nodes.size() - 1) {
 			return;
 		}
-		nodes.erase(nodes.begin() + UnsafeNumericCast<int64_t>(segment_start), nodes.end());
+		nodes.erase(nodes.begin() + UnsafeNumericCast<int64_t>(segment_start) + 1, nodes.end());
 	}
 
 	//! Get the segment index of the column segment for the given row
@@ -219,14 +216,7 @@ public:
 		// binary search to find the node
 		while (lower <= upper) {
 			idx_t index = (lower + upper) / 2;
-			if (index >= nodes.size()) {
-				string segments;
-				for (auto &entry : nodes) {
-					segments += StringUtil::Format("Start %d Count %d", entry.row_start, entry.node->count.load());
-				}
-				throw InternalException("Segment tree index not found for row number %d\nSegments:%s", row_number,
-				                        segments);
-			}
+			D_ASSERT(index < nodes.size());
 			auto &entry = nodes[index];
 			D_ASSERT(entry.row_start == entry.node->start);
 			if (row_number < entry.row_start) {
@@ -262,10 +252,6 @@ public:
 		return SegmentIterationHelper(*this);
 	}
 
-	SegmentIterationHelper Segments(SegmentLock &l) {
-		return SegmentIterationHelper(*this, l);
-	}
-
 	void Reinitialize() {
 		if (nodes.empty()) {
 			return;
@@ -288,42 +274,37 @@ protected:
 		return nullptr;
 	}
 
-	T *GetRootSegmentInternal() const {
-		return nodes.empty() ? nullptr : nodes[0].node.get();
-	}
-
 private:
 	//! The nodes in the tree, can be binary searched
 	vector<SegmentNode<T>> nodes;
 	//! Lock to access or modify the nodes
-	mutable mutex node_lock;
+	mutex node_lock;
 
 private:
+	T *GetRootSegmentInternal() {
+		return nodes.empty() ? nullptr : nodes[0].node.get();
+	}
+
 	class SegmentIterationHelper {
 	public:
 		explicit SegmentIterationHelper(SegmentTree &tree) : tree(tree) {
 		}
-		SegmentIterationHelper(SegmentTree &tree, SegmentLock &l) : tree(tree), lock(l) {
-		}
 
 	private:
 		SegmentTree &tree;
-		optional_ptr<SegmentLock> lock;
 
 	private:
 		class SegmentIterator {
 		public:
-			SegmentIterator(SegmentTree &tree_p, T *current_p, optional_ptr<SegmentLock> lock)
-			    : tree(tree_p), current(current_p), lock(lock) {
+			SegmentIterator(SegmentTree &tree_p, T *current_p) : tree(tree_p), current(current_p) {
 			}
 
 			SegmentTree &tree;
 			T *current;
-			optional_ptr<SegmentLock> lock;
 
 		public:
 			void Next() {
-				current = lock ? tree.GetNextSegment(*lock, current) : tree.GetNextSegment(current);
+				current = tree.GetNextSegment(current);
 			}
 
 			SegmentIterator &operator++() {
@@ -341,11 +322,10 @@ private:
 
 	public:
 		SegmentIterator begin() { // NOLINT: match stl API
-			auto root = lock ? tree.GetRootSegment(*lock) : tree.GetRootSegment();
-			return SegmentIterator(tree, root, lock);
+			return SegmentIterator(tree, tree.GetRootSegment());
 		}
 		SegmentIterator end() { // NOLINT: match stl API
-			return SegmentIterator(tree, nullptr, lock);
+			return SegmentIterator(tree, nullptr);
 		}
 	};
 

package/src/duckdb/src/include/duckdb/storage/table/standard_column_data.hpp

@@ -65,7 +65,6 @@ public:
 	                          vector<duckdb::ColumnSegmentInfo> &result) override;
 
 	bool IsPersistent() override;
-	bool HasAnyChanges() const override;
 	PersistentColumnData Serialize() override;
 	void InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) override;
 

package/src/duckdb/src/include/duckdb/storage/table/struct_column_data.hpp

@@ -59,7 +59,6 @@ public:
 	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, ColumnCheckpointInfo &info) override;
 
 	bool IsPersistent() override;
-	bool HasAnyChanges() const override;
 	PersistentColumnData Serialize() override;
 	void InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) override;