duckdb 0.10.3-dev0.0 → 0.10.3-dev13.0

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

@@ -40,10 +40,17 @@ public:
 	virtual void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size) = 0;
 	virtual BufferHandle Pin(shared_ptr<BlockHandle> &handle) = 0;
 	virtual void Unpin(shared_ptr<BlockHandle> &handle) = 0;
+
 	//! Returns the currently allocated memory
 	virtual idx_t GetUsedMemory() const = 0;
 	//! Returns the maximum available memory
 	virtual idx_t GetMaxMemory() const = 0;
+	//! Returns the currently used swap space
+	virtual idx_t GetUsedSwap() = 0;
+	//! Returns the maximum swap space that can be used
+	virtual optional_idx GetMaxSwap() const = 0;
+
+	//! Returns a new block of memory that is smaller than Storage::BLOCK_SIZE
 	virtual shared_ptr<BlockHandle> RegisterSmallMemory(idx_t block_size);
 	virtual DUCKDB_API Allocator &GetBufferAllocator();
 	virtual DUCKDB_API void ReserveMemory(idx_t size);
@@ -51,19 +58,21 @@ public:
 	virtual vector<MemoryInformation> GetMemoryUsageInfo() const = 0;
 	//! Set a new memory limit to the buffer manager, throws an exception if the new limit is too low and not enough
 	//! blocks can be evicted
-	virtual void SetLimit(idx_t limit = (idx_t)-1);
+	virtual void SetMemoryLimit(idx_t limit = (idx_t)-1);
+	virtual void SetSwapLimit(optional_idx limit = optional_idx());
+
 	virtual vector<TemporaryFileInformation> GetTemporaryFiles();
 	virtual const string &GetTemporaryDirectory() const;
 	virtual void SetTemporaryDirectory(const string &new_dir);
 	virtual bool HasTemporaryDirectory() const;
+
 	//! Construct a managed buffer.
 	virtual unique_ptr<FileBuffer> ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
 	                                                      FileBufferType type = FileBufferType::MANAGED_BUFFER);
 	//! Get the underlying buffer pool responsible for managing the buffers
 	virtual BufferPool &GetBufferPool() const;
-	//! Get the manager that assigns reservations for temporary memory, e.g., for query intermediates
-	virtual TemporaryMemoryManager &GetTemporaryMemoryManager();
 
+	virtual DatabaseInstance &GetDatabase() = 0;
 	// Static methods
 	DUCKDB_API static BufferManager &GetBufferManager(DatabaseInstance &db);
 	DUCKDB_API static const BufferManager &GetBufferManager(const DatabaseInstance &db);
@@ -77,6 +86,9 @@ public:
 	//! Returns the maximum available memory for a given query
 	idx_t GetQueryMaxMemory() const;
 
+	//! Get the manager that assigns reservations for temporary memory, e.g., for query intermediates
+	virtual TemporaryMemoryManager &GetTemporaryMemoryManager();
+
 protected:
 	virtual void PurgeQueue() = 0;
 	virtual void AddToEvictionQueue(shared_ptr<BlockHandle> &handle);

package/src/duckdb/src/include/duckdb/storage/checkpoint/row_group_writer.hpp

@@ -32,6 +32,7 @@ public:
 
 	virtual void WriteColumnDataPointers(ColumnCheckpointState &column_checkpoint_state, Serializer &serializer) = 0;
 
+	virtual CheckpointType GetCheckpointType() const = 0;
 	virtual MetadataWriter &GetPayloadWriter() = 0;
 
 	PartialBlockManager &GetPartialBlockManager() {
@@ -47,18 +48,20 @@ protected:
 class SingleFileRowGroupWriter : public RowGroupWriter {
 public:
 	SingleFileRowGroupWriter(TableCatalogEntry &table, PartialBlockManager &partial_block_manager,
-	                         MetadataWriter &table_data_writer)
-	    : RowGroupWriter(table, partial_block_manager), table_data_writer(table_data_writer) {
-	}
-
-	//! MetadataWriter is a cursor on a given BlockManager. This returns the
-	//! cursor against which we should write payload data for the specified RowGroup.
-	MetadataWriter &table_data_writer;
+	                         TableDataWriter &writer, MetadataWriter &table_data_writer);
 
 public:
 	void WriteColumnDataPointers(ColumnCheckpointState &column_checkpoint_state, Serializer &serializer) override;
 
+	CheckpointType GetCheckpointType() const override;
 	MetadataWriter &GetPayloadWriter() override;
+
+private:
+	//! Underlying writer object
+	TableDataWriter &writer;
+	//! MetadataWriter is a cursor on a given BlockManager. This returns the
+	//! cursor against which we should write payload data for the specified RowGroup.
+	MetadataWriter &table_data_writer;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/checkpoint/table_data_writer.hpp

@@ -35,6 +35,7 @@ public:
 	virtual unique_ptr<RowGroupWriter> GetRowGroupWriter(RowGroup &row_group) = 0;
 
 	virtual void AddRowGroup(RowGroupPointer &&row_group_pointer, unique_ptr<RowGroupWriter> writer);
+	virtual CheckpointType GetCheckpointType() const = 0;
 
 	TaskScheduler &GetScheduler();
 
@@ -52,6 +53,7 @@ public:
 public:
 	void FinalizeTable(const TableStatistics &global_stats, DataTableInfo *info, Serializer &serializer) override;
 	unique_ptr<RowGroupWriter> GetRowGroupWriter(RowGroup &row_group) override;
+	CheckpointType GetCheckpointType() const override;
 
 private:
 	SingleFileCheckpointWriter &checkpoint_manager;

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

@@ -40,7 +40,7 @@ public:
 protected:
 	virtual void WriteEntry(CatalogEntry &entry, Serializer &serializer);
 	virtual void WriteSchema(SchemaCatalogEntry &schema, Serializer &serializer);
-	virtual void WriteTable(TableCatalogEntry &table, Serializer &serializer);
+	virtual void WriteTable(TableCatalogEntry &table, Serializer &serializer) = 0;
 	virtual void WriteView(ViewCatalogEntry &table, Serializer &serializer);
 	virtual void WriteSequence(SequenceCatalogEntry &table, Serializer &serializer);
 	virtual void WriteMacro(ScalarMacroCatalogEntry &table, Serializer &serializer);
@@ -60,18 +60,19 @@ protected:
 	Catalog &catalog;
 
 protected:
-	virtual void LoadCheckpoint(ClientContext &context, MetadataReader &reader);
-	virtual void ReadEntry(ClientContext &context, Deserializer &deserializer);
-	virtual void ReadSchema(ClientContext &context, Deserializer &deserializer);
-	virtual void ReadTable(ClientContext &context, Deserializer &deserializer);
-	virtual void ReadView(ClientContext &context, Deserializer &deserializer);
-	virtual void ReadSequence(ClientContext &context, Deserializer &deserializer);
-	virtual void ReadMacro(ClientContext &context, Deserializer &deserializer);
-	virtual void ReadTableMacro(ClientContext &context, Deserializer &deserializer);
-	virtual void ReadIndex(ClientContext &context, Deserializer &deserializer);
-	virtual void ReadType(ClientContext &context, Deserializer &deserializer);
-
-	virtual void ReadTableData(ClientContext &context, Deserializer &deserializer, BoundCreateTableInfo &bound_info);
+	virtual void LoadCheckpoint(CatalogTransaction transaction, MetadataReader &reader);
+	virtual void ReadEntry(CatalogTransaction transaction, Deserializer &deserializer);
+	virtual void ReadSchema(CatalogTransaction transaction, Deserializer &deserializer);
+	virtual void ReadTable(CatalogTransaction transaction, Deserializer &deserializer);
+	virtual void ReadView(CatalogTransaction transaction, Deserializer &deserializer);
+	virtual void ReadSequence(CatalogTransaction transaction, Deserializer &deserializer);
+	virtual void ReadMacro(CatalogTransaction transaction, Deserializer &deserializer);
+	virtual void ReadTableMacro(CatalogTransaction transaction, Deserializer &deserializer);
+	virtual void ReadIndex(CatalogTransaction transaction, Deserializer &deserializer);
+	virtual void ReadType(CatalogTransaction transaction, Deserializer &deserializer);
+
+	virtual void ReadTableData(CatalogTransaction transaction, Deserializer &deserializer,
+	                           BoundCreateTableInfo &bound_info);
 };
 
 class SingleFileCheckpointReader final : public CheckpointReader {
@@ -80,7 +81,7 @@ public:
 	    : CheckpointReader(Catalog::GetCatalog(storage.GetAttached())), storage(storage) {
 	}
 
-	void LoadFromStorage(optional_ptr<ClientContext> context = nullptr);
+	void LoadFromStorage();
 	MetadataManager &GetMetadataManager();
 
 	//! The database
@@ -96,7 +97,7 @@ class SingleFileCheckpointWriter final : public CheckpointWriter {
 	friend class SingleFileTableDataWriter;
 
 public:
-	SingleFileCheckpointWriter(AttachedDatabase &db, BlockManager &block_manager);
+	SingleFileCheckpointWriter(AttachedDatabase &db, BlockManager &block_manager, CheckpointType checkpoint_type);
 
 	//! Checkpoint the current state of the WAL and flush it to the main storage. This should be called BEFORE any
 	//! connection is available because right now the checkpointing cannot be done online. (TODO)
@@ -107,6 +108,12 @@ public:
 	unique_ptr<TableDataWriter> GetTableDataWriter(TableCatalogEntry &table) override;
 
 	BlockManager &GetBlockManager();
+	CheckpointType GetCheckpointType() const {
+		return checkpoint_type;
+	}
+
+public:
+	void WriteTable(TableCatalogEntry &table, Serializer &serializer) override;
 
 private:
 	//! The metadata writer is responsible for writing schema information
@@ -116,6 +123,8 @@ private:
 	//! Because this is single-file storage, we can share partial blocks across
 	//! an entire checkpoint.
 	PartialBlockManager partial_block_manager;
+	//! Checkpoint type
+	CheckpointType checkpoint_type;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/compression/alp/algorithm/alp.hpp

@@ -107,10 +107,10 @@ struct AlpCompression {
 	 */
 	static int64_t NumberToInt64(T n) {
 		if (IsImpossibleToEncode(n)) {
-			return AlpConstants::ENCODING_UPPER_LIMIT;
+			return NumericCast<int64_t>(AlpConstants::ENCODING_UPPER_LIMIT);
 		}
 		n = n + AlpTypedConstants<T>::MAGIC_NUMBER - AlpTypedConstants<T>::MAGIC_NUMBER;
-		return static_cast<int64_t>(n);
+		return NumericCast<int64_t>(n);
 	}
 
 	/*
@@ -185,7 +185,7 @@ struct AlpCompression {
 
 		// Evaluate factor/exponent compression size (we optimize for FOR)
 		uint64_t delta = (static_cast<uint64_t>(max_encoded_value) - static_cast<uint64_t>(min_encoded_value));
-		estimated_bits_per_value = std::ceil(std::log2(delta + 1));
+		estimated_bits_per_value = NumericCast<uint32_t>(std::ceil(std::log2(delta + 1)));
 		estimated_compression_size += n_values * estimated_bits_per_value;
 		estimated_compression_size +=
 		    exceptions_count * (EXACT_TYPE_BITSIZE + (AlpConstants::EXCEPTION_POSITION_SIZE * 8));
@@ -254,7 +254,8 @@ struct AlpCompression {
 	static void FindBestFactorAndExponent(const T *input_vector, idx_t n_values, State &state) {
 		//! We sample equidistant values within a vector; to do this we skip a fixed number of values
 		vector<T> vector_sample;
-		uint32_t idx_increments = MaxValue(1, (int32_t)std::ceil((double)n_values / AlpConstants::SAMPLES_PER_VECTOR));
+		auto idx_increments = MaxValue<uint32_t>(
+		    1, UnsafeNumericCast<uint32_t>(std::ceil((double)n_values / AlpConstants::SAMPLES_PER_VECTOR)));
 		for (idx_t i = 0; i < n_values; i += idx_increments) {
 			vector_sample.push_back(input_vector[i]);
 		}
@@ -358,9 +359,9 @@ struct AlpCompression {
 			BitpackingPrimitives::PackBuffer<uint64_t, false>(state.values_encoded, u_encoded_integers, n_values,
 			                                                  bit_width);
 		}
-		state.bit_width = bit_width; // in bits
-		state.bp_size = bp_size;     // in bytes
-		state.frame_of_reference = min_value;
+		state.bit_width = bit_width;                                 // in bits
+		state.bp_size = bp_size;                                     // in bytes
+		state.frame_of_reference = static_cast<uint64_t>(min_value); // understood this can be negative
 	}
 
 	/*

package/src/duckdb/src/include/duckdb/storage/compression/alp/alp_compress.hpp

@@ -183,10 +183,10 @@ public:
 		// Verify that the metadata_ptr is not smaller than the space used by the data
 		D_ASSERT(dataptr + metadata_offset <= metadata_ptr);
 
-		idx_t bytes_used_by_metadata = dataptr + Storage::BLOCK_SIZE - metadata_ptr;
+		auto bytes_used_by_metadata = UnsafeNumericCast<idx_t>(dataptr + Storage::BLOCK_SIZE - metadata_ptr);
 
 		// Initially the total segment size is the size of the block
-		idx_t total_segment_size = Storage::BLOCK_SIZE;
+		auto total_segment_size = Storage::BLOCK_SIZE;
 
 		//! We compact the block if the space used is less than a threshold
 		const auto used_space_percentage =

package/src/duckdb/src/include/duckdb/storage/compression/alp/alp_constants.hpp

@@ -70,11 +70,12 @@ struct AlpTypedConstants<float> {
 	static constexpr float MAGIC_NUMBER = 12582912.0; //! 2^22 + 2^23
 	static constexpr uint8_t MAX_EXPONENT = 10;
 
-	static constexpr const float EXP_ARR[] = {1.0,       10.0,       100.0,       1000.0,       10000.0,      100000.0,
-	                                          1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0};
+	static constexpr const float EXP_ARR[] = {1.0F,         10.0F,         100.0F,        1000.0F,
+	                                          10000.0F,     100000.0F,     1000000.0F,    10000000.0F,
+	                                          100000000.0F, 1000000000.0F, 10000000000.0F};
 
-	static constexpr float FRAC_ARR[] = {1.0,      0.1,       0.01,       0.001,       0.0001,      0.00001,
-	                                     0.000001, 0.0000001, 0.00000001, 0.000000001, 0.0000000001};
+	static constexpr float FRAC_ARR[] = {1.0F,      0.1F,       0.01F,       0.001F,       0.0001F,      0.00001F,
+	                                     0.000001F, 0.0000001F, 0.00000001F, 0.000000001F, 0.0000000001F};
 };
 
 template <>

package/src/duckdb/src/include/duckdb/storage/compression/alp/alp_fetch.hpp

@@ -28,7 +28,7 @@ void AlpFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id,
 	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
 	AlpScanState<T> scan_state(segment);
-	scan_state.Skip(segment, row_id);
+	scan_state.Skip(segment, UnsafeNumericCast<idx_t>(row_id));
 	auto result_data = FlatVector::GetData<EXACT_TYPE>(result);
 	result_data[result_idx] = (EXACT_TYPE)0;
 

package/src/duckdb/src/include/duckdb/storage/compression/alp/alp_utils.hpp

@@ -40,9 +40,9 @@ public:
 		auto n_lookup_values =
 		    NumericCast<uint32_t>(MinValue(current_vector_n_values, (idx_t)AlpConstants::ALP_VECTOR_SIZE));
 		//! We sample equidistant values within a vector; to do this we jump a fixed number of values
-		uint32_t n_sampled_increments =
-		    MaxValue(1, (int32_t)std::ceil((double)n_lookup_values / AlpConstants::SAMPLES_PER_VECTOR));
-		uint32_t n_sampled_values = std::ceil((double)n_lookup_values / n_sampled_increments);
+		uint32_t n_sampled_increments = MaxValue<uint32_t>(
+		    1, UnsafeNumericCast<uint32_t>(std::ceil((double)n_lookup_values / AlpConstants::SAMPLES_PER_VECTOR)));
+		uint32_t n_sampled_values = NumericCast<uint32_t>(std::ceil((double)n_lookup_values / n_sampled_increments));
 		D_ASSERT(n_sampled_values < AlpConstants::ALP_VECTOR_SIZE);
 
 		AlpSamplingParameters sampling_params = {n_lookup_values, n_sampled_increments, n_sampled_values};

package/src/duckdb/src/include/duckdb/storage/compression/alprd/algorithm/alprd.hpp

@@ -105,7 +105,8 @@ struct AlpRDCompression {
 		// The left parts bit width after compression is determined by how many elements are in the dictionary
 		uint64_t actual_dictionary_size =
 		    MinValue<uint64_t>(AlpRDConstants::MAX_DICTIONARY_SIZE, left_parts_sorted_repetitions.size());
-		uint8_t left_bit_width = MaxValue<uint8_t>(1, std::ceil(std::log2(actual_dictionary_size)));
+		uint8_t left_bit_width =
+		    MaxValue<uint8_t>(1, NumericCast<uint8_t>(std::ceil(std::log2(actual_dictionary_size))));
 
 		if (PERSIST_DICT) {
 			for (idx_t dict_idx = 0; dict_idx < actual_dictionary_size; dict_idx++) {

package/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_analyze.hpp

@@ -126,13 +126,15 @@ idx_t AlpRDFinalAnalyze(AnalyzeState &state) {
 	//! Overhead per vector: Pointer to data + Exceptions count
 	double per_vector_overhead = AlpRDConstants::METADATA_POINTER_SIZE + AlpRDConstants::EXCEPTIONS_COUNT_SIZE;
 
-	uint32_t n_vectors = std::ceil((double)analyze_state.total_values_count / AlpRDConstants::ALP_VECTOR_SIZE);
+	uint32_t n_vectors =
+	    NumericCast<uint32_t>(std::ceil((double)analyze_state.total_values_count / AlpRDConstants::ALP_VECTOR_SIZE));
 
 	auto estimated_size = (estimed_compressed_bytes * factor_of_sampling) + (n_vectors * per_vector_overhead);
-	uint32_t estimated_n_blocks = std::ceil(estimated_size / (Storage::BLOCK_SIZE - per_segment_overhead));
+	uint32_t estimated_n_blocks =
+	    NumericCast<uint32_t>(std::ceil(estimated_size / (Storage::BLOCK_SIZE - per_segment_overhead)));
 
 	auto final_analyze_size = estimated_size + (estimated_n_blocks * per_segment_overhead);
-	return final_analyze_size;
+	return NumericCast<idx_t>(final_analyze_size);
 }
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_compress.hpp

@@ -185,10 +185,10 @@ public:
 		// Verify that the metadata_ptr is not smaller than the space used by the data
 		D_ASSERT(dataptr + metadata_offset <= metadata_ptr);
 
-		idx_t bytes_used_by_metadata = dataptr + Storage::BLOCK_SIZE - metadata_ptr;
+		auto bytes_used_by_metadata = UnsafeNumericCast<idx_t>(dataptr + Storage::BLOCK_SIZE - metadata_ptr);
 
 		// Initially the total segment size is the size of the block
-		idx_t total_segment_size = Storage::BLOCK_SIZE;
+		auto total_segment_size = Storage::BLOCK_SIZE;
 
 		//! We compact the block if the space used is less than a threshold
 		const auto used_space_percentage =

package/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_fetch.hpp

@@ -27,7 +27,7 @@ template <class T>
 void AlpRDFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
 	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 	AlpRDScanState<T> scan_state(segment);
-	scan_state.Skip(segment, row_id);
+	scan_state.Skip(segment, UnsafeNumericCast<idx_t>(row_id));
 	auto result_data = FlatVector::GetData<EXACT_TYPE>(result);
 	result_data[result_idx] = (EXACT_TYPE)0;
 

package/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/bit_reader.hpp

@@ -150,7 +150,7 @@ public:
 			result = result << 8 | InnerReadByte(i);
 		}
 		result = result << remainder | InnerRead(remainder, bytes);
-		index += (bytes << 3) + remainder;
+		index += static_cast<uint32_t>(bytes << 3) + remainder;
 		return result;
 	}
 

package/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_fetch.hpp

@@ -29,7 +29,7 @@ void ChimpFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id
 	using INTERNAL_TYPE = typename ChimpType<T>::TYPE;
 
 	ChimpScanState<T> scan_state(segment);
-	scan_state.Skip(segment, row_id);
+	scan_state.Skip(segment, UnsafeNumericCast<idx_t>(row_id));
 	auto result_data = FlatVector::GetData<INTERNAL_TYPE>(result);
 
 	if (scan_state.GroupFinished() && scan_state.total_value_count < scan_state.segment_count) {

package/src/duckdb/src/include/duckdb/storage/compression/patas/patas_fetch.hpp

@@ -29,7 +29,7 @@ void PatasFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id
 	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
 	PatasScanState<T> scan_state(segment);
-	scan_state.Skip(segment, row_id);
+	scan_state.Skip(segment, UnsafeNumericCast<idx_t>(row_id));
 	auto result_data = FlatVector::GetData<EXACT_TYPE>(result);
 	result_data[result_idx] = (EXACT_TYPE)0;
 

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

@@ -41,6 +41,9 @@ class WriteAheadLog;
 class TableDataWriter;
 class ConflictManager;
 class TableScanState;
+struct TableDeleteState;
+struct ConstraintState;
+struct TableUpdateState;
 enum class VerifyExistenceType : uint8_t;
 
 //! DataTable represents a physical table on disk
@@ -60,16 +63,18 @@ public:
 	//! Constructs a DataTable as a delta on an existing data table but with one column added new constraint
 	explicit DataTable(ClientContext &context, DataTable &parent, unique_ptr<BoundConstraint> constraint);
 
-	//! The table info
-	shared_ptr<DataTableInfo> info;
-	//! The set of physical columns stored by this DataTable
-	vector<ColumnDefinition> column_definitions;
 	//! A reference to the database instance
 	AttachedDatabase &db;
 
 public:
+	AttachedDatabase &GetAttached();
+	TableIOManager &GetTableIOManager();
+
+	bool IsTemporary() const;
+
 	//! Returns a list of types of the table
 	vector<LogicalType> GetTypes();
+	const vector<ColumnDefinition> &Columns() const;
 
 	void InitializeScan(TableScanState &state, const vector<column_t> &column_ids,
 	                    TableFilterSet *table_filter = nullptr);
@@ -92,26 +97,34 @@ public:
 	           const Vector &row_ids, idx_t fetch_count, ColumnFetchState &state);
 
 	//! Initializes an append to transaction-local storage
-	void InitializeLocalAppend(LocalAppendState &state, ClientContext &context);
+	void InitializeLocalAppend(LocalAppendState &state, TableCatalogEntry &table, ClientContext &context,
+	                           const vector<unique_ptr<BoundConstraint>> &bound_constraints);
 	//! Append a DataChunk to the transaction-local storage of the table.
 	void LocalAppend(LocalAppendState &state, TableCatalogEntry &table, ClientContext &context, DataChunk &chunk,
 	                 bool unsafe = false);
 	//! Finalizes a transaction-local append
 	void FinalizeLocalAppend(LocalAppendState &state);
 	//! Append a chunk to the transaction-local storage of this table
-	void LocalAppend(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk);
+	void LocalAppend(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk,
+	                 const vector<unique_ptr<BoundConstraint>> &bound_constraints);
 	//! Append a column data collection to the transaction-local storage of this table
-	void LocalAppend(TableCatalogEntry &table, ClientContext &context, ColumnDataCollection &collection);
+	void LocalAppend(TableCatalogEntry &table, ClientContext &context, ColumnDataCollection &collection,
+	                 const vector<unique_ptr<BoundConstraint>> &bound_constraints);
 	//! Merge a row group collection into the transaction-local storage
 	void LocalMerge(ClientContext &context, RowGroupCollection &collection);
 	//! Creates an optimistic writer for this table - used for optimistically writing parallel appends
 	OptimisticDataWriter &CreateOptimisticWriter(ClientContext &context);
 	void FinalizeOptimisticWriter(ClientContext &context, OptimisticDataWriter &writer);
 
+	unique_ptr<TableDeleteState> InitializeDelete(TableCatalogEntry &table, ClientContext &context,
+	                                              const vector<unique_ptr<BoundConstraint>> &bound_constraints);
 	//! Delete the entries with the specified row identifier from the table
-	idx_t Delete(TableCatalogEntry &table, ClientContext &context, Vector &row_ids, idx_t count);
+	idx_t Delete(TableDeleteState &state, ClientContext &context, Vector &row_ids, idx_t count);
+
+	unique_ptr<TableUpdateState> InitializeUpdate(TableCatalogEntry &table, ClientContext &context,
+	                                              const vector<unique_ptr<BoundConstraint>> &bound_constraints);
 	//! Update the entries with the specified row identifier from the table
-	void Update(TableCatalogEntry &table, ClientContext &context, Vector &row_ids,
+	void Update(TableUpdateState &state, ClientContext &context, Vector &row_ids,
 	            const vector<PhysicalIndex> &column_ids, DataChunk &data);
 	//! Update a single (sub-)column along a column path
 	//! The column_path vector is a *path* towards a column within the table
@@ -170,12 +183,17 @@ public:
 	//! Sets statistics of a physical column within the table
 	void SetDistinct(column_t column_id, unique_ptr<DistinctStatistics> distinct_stats);
 
+	//! Obtains a shared lock to prevent checkpointing while operations are running
+	unique_ptr<StorageLockKey> GetSharedCheckpointLock();
+	//! Obtains a lock during a checkpoint operation that prevents other threads from reading this table
+	unique_ptr<StorageLockKey> GetCheckpointLock();
 	//! Checkpoint the table to the specified table data writer
 	void Checkpoint(TableDataWriter &writer, Serializer &serializer);
 	void CommitDropTable();
 	void CommitDropColumn(idx_t index);
 
-	idx_t GetTotalRows();
+	idx_t ColumnCount() const;
+	idx_t GetTotalRows() const;
 
 	vector<ColumnSegmentInfo> GetColumnSegmentInfo();
 	static bool IsForeignKeyIndex(const vector<PhysicalIndex> &fk_keys, Index &index, ForeignKeyType fk_type);
@@ -186,22 +204,39 @@ public:
 	//! FIXME: This is only necessary until we treat all indexes as catalog entries, allowing to alter constraints
 	bool IndexNameIsUnique(const string &name);
 
+	//! Initialize constraint verification state
+	unique_ptr<ConstraintState> InitializeConstraintState(TableCatalogEntry &table,
+	                                                      const vector<unique_ptr<BoundConstraint>> &bound_constraints);
 	//! Verify constraints with a chunk from the Append containing all columns of the table
-	void VerifyAppendConstraints(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk,
-	                             ConflictManager *conflict_manager = nullptr);
+	void VerifyAppendConstraints(ConstraintState &state, ClientContext &context, DataChunk &chunk,
+	                             optional_ptr<ConflictManager> conflict_manager = nullptr);
+
+	shared_ptr<DataTableInfo> &GetDataTableInfo();
+
+	void InitializeIndexes(ClientContext &context);
+	bool HasIndexes() const;
+	void AddIndex(unique_ptr<Index> index);
+	bool HasForeignKeyIndex(const vector<PhysicalIndex> &keys, ForeignKeyType type);
+	void SetIndexStorageInfo(vector<IndexStorageInfo> index_storage_info);
+	void VacuumIndexes();
+
+	string GetTableName() const;
+	void SetTableName(string new_name);
+
+	TableStorageInfo GetStorageInfo();
 
 public:
 	static void VerifyUniqueIndexes(TableIndexList &indexes, ClientContext &context, DataChunk &chunk,
-	                                ConflictManager *conflict_manager);
+	                                optional_ptr<ConflictManager> conflict_manager);
 
 private:
 	//! Verify the new added constraints against current persistent&local data
-	void VerifyNewConstraint(ClientContext &context, DataTable &parent, const BoundConstraint *constraint);
+	void VerifyNewConstraint(LocalStorage &local_storage, DataTable &parent, const BoundConstraint &constraint);
 	//! Verify constraints with a chunk from the Update containing only the specified column_ids
-	void VerifyUpdateConstraints(ClientContext &context, TableCatalogEntry &table, DataChunk &chunk,
+	void VerifyUpdateConstraints(ConstraintState &state, ClientContext &context, DataChunk &chunk,
 	                             const vector<PhysicalIndex> &column_ids);
 	//! Verify constraints with a chunk from the Delete containing all columns of the table
-	void VerifyDeleteConstraints(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk);
+	void VerifyDeleteConstraints(TableDeleteState &state, ClientContext &context, DataChunk &chunk);
 
 	void InitializeScanWithOffset(TableScanState &state, const vector<column_t> &column_ids, idx_t start_row,
 	                              idx_t end_row);
@@ -214,6 +249,10 @@ private:
 	                                      DataChunk &chunk);
 
 private:
+	//! The table info
+	shared_ptr<DataTableInfo> info;
+	//! The set of physical columns stored by this DataTable
+	vector<ColumnDefinition> column_definitions;
 	//! Lock for appending entries to the table
 	mutex append_lock;
 	//! The row groups of the table