duckdb 0.6.2-dev971.0 → 0.7.1-dev100.0

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

@@ -17,20 +17,23 @@
 #include "duckdb/storage/table/scan_state.hpp"
 #include "duckdb/storage/meta_block_writer.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/common/types/constraint_conflict_info.hpp"
 
 namespace duckdb {
 
 class ClientContext;
 class TableIOManager;
 class Transaction;
+class ConflictManager;
 
 struct IndexLock;
 
 //! The index is an abstract base class that serves as the basis for indexes
 class Index {
 public:
-	Index(IndexType type, TableIOManager &table_io_manager, const vector<column_t> &column_ids,
-	      const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type);
+	Index(AttachedDatabase &db, IndexType type, TableIOManager &table_io_manager, const vector<column_t> &column_ids,
+	      const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type,
+	      bool track_memory);
 	virtual ~Index() = default;
 
 	//! The type of the index
@@ -39,7 +42,7 @@ public:
 	TableIOManager &table_io_manager;
 	//! Column identifiers to extract from the base table
 	vector<column_t> column_ids;
-	//! unordered_set of column_ids used by the index
+	//! Unordered_set of column_ids used by the index
 	unordered_set<column_t> column_id_set;
 	//! Unbound expressions used by the index
 	vector<unique_ptr<Expression>> unbound_expressions;
@@ -47,18 +50,29 @@ public:
 	vector<PhysicalType> types;
 	//! The logical types of the expressions
 	vector<LogicalType> logical_types;
-	//! constraint type
+	//! Index constraint type (primary key, foreign key, ...)
 	IndexConstraintType constraint_type;
 
+	//! Attached database instance
+	AttachedDatabase &db;
+	//! Buffer manager of the database instance
+	BufferManager &buffer_manager;
+	//! The size of the index in memory
+	//! This does not track the size of the index meta information, but only allocated nodes and leaves
+	idx_t memory_size;
+	//! Flag determining if this index's size is tracked by the buffer manager
+	bool track_memory;
+
 public:
 	//! Initialize a scan on the index with the given expression and column ids
 	//! to fetch from the base table when we only have one query predicate
-	virtual unique_ptr<IndexScanState> InitializeScanSinglePredicate(Transaction &transaction, Value value,
+	virtual unique_ptr<IndexScanState> InitializeScanSinglePredicate(const Transaction &transaction, const Value &value,
 	                                                                 ExpressionType expressionType) = 0;
 	//! Initialize a scan on the index with the given expression and column ids
 	//! to fetch from the base table for two query predicates
-	virtual unique_ptr<IndexScanState> InitializeScanTwoPredicates(Transaction &transaction, Value low_value,
-	                                                               ExpressionType low_expression_type, Value high_value,
+	virtual unique_ptr<IndexScanState> InitializeScanTwoPredicates(Transaction &transaction, const Value &low_value,
+	                                                               ExpressionType low_expression_type,
+	                                                               const Value &high_value,
 	                                                               ExpressionType high_expression_type) = 0;
 	//! Perform a lookup on the index, fetching up to max_count result ids. Returns true if all row ids were fetched,
 	//! and false otherwise.
@@ -72,10 +86,12 @@ public:
 	bool Append(DataChunk &entries, Vector &row_identifiers);
 	//! Verify that data can be appended to the index
 	virtual void VerifyAppend(DataChunk &chunk) = 0;
+	//! Verify that data can be appended to the index
+	virtual void VerifyAppend(DataChunk &chunk, ConflictManager &conflict_manager) = 0;
 	//! Verify that data can be appended to the index for foreign key constraint
-	virtual void VerifyAppendForeignKey(DataChunk &chunk, string *err_msg_ptr) = 0;
+	virtual void VerifyAppendForeignKey(DataChunk &chunk) = 0;
 	//! Verify that data can be delete from the index for foreign key constraint
-	virtual void VerifyDeleteForeignKey(DataChunk &chunk, string *err_msg_ptr) = 0;
+	virtual void VerifyDeleteForeignKey(DataChunk &chunk) = 0;
 
 	//! Called when data inside the index is Deleted
 	virtual void Delete(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
@@ -83,8 +99,6 @@ public:
 
 	//! Insert data into the index. Does not lock the index.
 	virtual bool Insert(IndexLock &lock, DataChunk &input, Vector &row_identifiers) = 0;
-	//! Construct an index from sorted chunks of keys.
-	virtual void ConstructAndMerge(IndexLock &lock, PayloadScanner &scanner, Allocator &allocator) = 0;
 
 	//! Merge other_index into this index.
 	virtual bool MergeIndexes(IndexLock &state, Index *other_index) = 0;
@@ -92,10 +106,16 @@ public:
 
 	//! Returns the string representation of an index
 	virtual string ToString() = 0;
+	//! Verifies that the memory_size value of the index matches its actual size
+	virtual void Verify() = 0;
 
 	//! Returns true if the index is affected by updates on the specified column ids, and false otherwise
 	bool IndexIsUpdated(const vector<PhysicalIndex> &column_ids) const;
 
+	//! Returns how many of the input values were found in the 'input' chunk, with the option to also record what those
+	//! matches were. For this purpose, nulls count as a match, and are returned in 'null_count'
+	virtual void LookupValues(DataChunk &input, ConflictManager &conflict_manager) = 0;
+
 	//! Returns unique flag
 	bool IsUnique() {
 		return (constraint_type == IndexConstraintType::UNIQUE || constraint_type == IndexConstraintType::PRIMARY);
@@ -110,6 +130,7 @@ public:
 	}
 	//! Serializes the index and returns the pair of block_id offset positions
 	virtual BlockPointer Serialize(duckdb::MetaBlockWriter &writer);
+	BlockPointer GetBlockPointer();
 
 	//! Returns block/offset of where index was most recently serialized.
 	BlockPointer GetSerializedDataPointer() const {

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

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/magic_bytes.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+class FileSystem;
+
+enum class DataFileType : uint8_t {
+	FILE_DOES_NOT_EXIST, // file does not exist
+	DUCKDB_FILE,         // duckdb database file
+	SQLITE_FILE,         // sqlite database file
+	PARQUET_FILE         // parquet file
+};
+
+class MagicBytes {
+public:
+	static DataFileType CheckMagicBytes(FileSystem *fs, const string &path);
+};
+
+} // namespace duckdb

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

@@ -49,7 +49,7 @@ public:
 
 	void Put(string key, shared_ptr<ObjectCacheEntry> value) {
 		lock_guard<mutex> glock(lock);
-		cache[key] = move(value);
+		cache[key] = std::move(value);
 	}
 
 	DUCKDB_API static ObjectCache &GetObjectCache(ClientContext &context);

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

@@ -36,7 +36,7 @@ struct PartialBlockState {
 };
 
 struct PartialBlock {
-	explicit PartialBlock(PartialBlockState state) : state(move(state)) {
+	explicit PartialBlock(PartialBlockState state) : state(std::move(state)) {
 	}
 	virtual ~PartialBlock() {
 	}
@@ -68,10 +68,10 @@ public:
 	// 20% free / 80% utilization
 	static constexpr const idx_t DEFAULT_MAX_PARTIAL_BLOCK_SIZE = Storage::BLOCK_SIZE / 5 * 4;
 	// Max number of shared references to a block. No effective limit by default.
-	static constexpr const idx_t DEFAULT_MAX_USE_COUNT = 1 << 20;
+	static constexpr const idx_t DEFAULT_MAX_USE_COUNT = 1u << 20;
 	// No point letting map size grow unbounded. We'll drop blocks with the
 	// least free space first.
-	static constexpr const idx_t MAX_BLOCK_MAP_SIZE = 1 << 31;
+	static constexpr const idx_t MAX_BLOCK_MAP_SIZE = 1u << 31;
 
 public:
 	PartialBlockManager(BlockManager &block_manager, uint32_t max_partial_block_size = DEFAULT_MAX_PARTIAL_BLOCK_SIZE,

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

@@ -17,6 +17,7 @@
 #include "duckdb/common/vector.hpp"
 
 namespace duckdb {
+
 class DatabaseInstance;
 
 //! SingleFileBlockManager is an implementation for a BlockManager which manages blocks in a single file
@@ -25,7 +26,11 @@ class SingleFileBlockManager : public BlockManager {
 	static constexpr uint64_t BLOCK_START = Storage::FILE_HEADER_SIZE * 3;
 
 public:
-	SingleFileBlockManager(AttachedDatabase &db, string path, bool read_only, bool create_new, bool use_direct_io);
+	SingleFileBlockManager(AttachedDatabase &db, string path, bool read_only, bool use_direct_io);
+
+	void GetFileFlags(uint8_t &flags, FileLockType &lock, bool create_new);
+	void CreateNewDatabase();
+	void LoadExistingDatabase();
 
 	//! Creates a new Block using the specified block_id and returns a pointer
 	unique_ptr<Block> CreateBlock(block_id_t block_id, FileBuffer *source_buffer) override;
@@ -59,6 +64,9 @@ private:
 
 	void Initialize(DatabaseHeader &header);
 
+	void ReadAndChecksum(FileBuffer &handle, uint64_t location) const;
+	void ChecksumAndWrite(FileBuffer &handle, uint64_t location) const;
+
 	//! Return the blocks to which we will write the free list and modified blocks
 	vector<block_id_t> GetFreeListBlocks();
 

package/src/duckdb/src/include/duckdb/storage/statistics/base_statistics.hpp

@@ -63,7 +63,7 @@ public:
 	virtual void Serialize(Serializer &serializer) const;
 	virtual void Serialize(FieldWriter &writer) const;
 
-	idx_t GetDistinctCount();
+	virtual idx_t GetDistinctCount();
 
 	static unique_ptr<BaseStatistics> Deserialize(Deserializer &source, LogicalType type);
 

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

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/storage_extension.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/enums/access_mode.hpp"
+#include "duckdb/parser/tableref/table_function_ref.hpp"
+
+namespace duckdb {
+class AttachedDatabase;
+struct AttachInfo;
+class Catalog;
+class TransactionManager;
+
+//! The StorageExtensionInfo holds static information relevant to the storage extension
+struct StorageExtensionInfo {
+	DUCKDB_API virtual ~StorageExtensionInfo() {
+	}
+};
+
+typedef unique_ptr<Catalog> (*attach_function_t)(StorageExtensionInfo *storage_info, AttachedDatabase &db,
+                                                 const string &name, AttachInfo &info, AccessMode access_mode);
+typedef unique_ptr<TransactionManager> (*create_transaction_manager_t)(StorageExtensionInfo *storage_info,
+                                                                       AttachedDatabase &db, Catalog &catalog);
+typedef unique_ptr<TableFunctionRef> (*create_database_t)(StorageExtensionInfo *info, ClientContext &context,
+                                                          const string &database_name, const string &source_path);
+typedef unique_ptr<TableFunctionRef> (*drop_database_t)(StorageExtensionInfo *storage_info, ClientContext &context,
+                                                        const string &database_name);
+
+class StorageExtension {
+public:
+	attach_function_t attach;
+	create_transaction_manager_t create_transaction_manager;
+	create_database_t create_database;
+	drop_database_t drop_database;
+
+	//! Additional info passed to the various storage functions
+	shared_ptr<StorageExtensionInfo> storage_info;
+
+	DUCKDB_API virtual ~StorageExtension() {
+	}
+};
+
+} // namespace duckdb

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

@@ -13,6 +13,7 @@
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/storage/table_io_manager.hpp"
 #include "duckdb/storage/write_ahead_log.hpp"
+#include "duckdb/storage/database_size.hpp"
 
 namespace duckdb {
 class BlockManager;
@@ -22,15 +23,6 @@ class DatabaseInstance;
 class TransactionManager;
 class TableCatalogEntry;
 
-struct DatabaseSize {
-	idx_t total_blocks = 0;
-	idx_t block_size = 0;
-	idx_t free_blocks = 0;
-	idx_t used_blocks = 0;
-	idx_t bytes = 0;
-	idx_t wal_size = 0;
-};
-
 class StorageCommitState {
 public:
 	// Destruction of this object, without prior call to FlushCommit,

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

@@ -61,7 +61,7 @@ public:
 	static unique_ptr<CompressionAppendState> StringInitAppend(ColumnSegment &segment) {
 		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
 		auto handle = buffer_manager.Pin(segment.block);
-		return make_unique<CompressionAppendState>(move(handle));
+		return make_unique<CompressionAppendState>(std::move(handle));
 	}
 
 	static idx_t StringAppend(CompressionAppendState &append_state, ColumnSegment &segment, SegmentStatistics &stats,

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

@@ -25,6 +25,7 @@ class DatabaseInstance;
 class RowGroup;
 class RowGroupWriter;
 class TableDataWriter;
+class TableStorageInfo;
 struct TransactionData;
 
 struct DataTableInfo;
@@ -123,7 +124,7 @@ public:
 	                                          idx_t start_row, Deserializer &source, const LogicalType &type,
 	                                          ColumnData *parent);
 
-	virtual void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result);
+	virtual void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result);
 	virtual void Verify(RowGroup &parent);
 
 	static shared_ptr<ColumnData> CreateColumn(BlockManager &block_manager, DataTableInfo &info, idx_t column_index,

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

@@ -58,7 +58,7 @@ public:
 
 	void DeserializeColumn(Deserializer &source) override;
 
-	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) override;
+	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) override;
 
 private:
 	list_entry_t FetchListEntry(idx_t row_idx);

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

@@ -29,6 +29,7 @@ struct DataTableInfo;
 class ExpressionExecutor;
 class RowGroupWriter;
 class UpdateSegment;
+class TableStorageInfo;
 class Vector;
 struct ColumnCheckpointState;
 struct RowGroupPointer;
@@ -149,7 +150,7 @@ public:
 	void MergeIntoStatistics(idx_t column_idx, BaseStatistics &other);
 	unique_ptr<BaseStatistics> GetStatistics(idx_t column_idx);
 
-	void GetStorageInfo(idx_t row_group_index, vector<vector<Value>> &result);
+	void GetStorageInfo(idx_t row_group_index, TableStorageInfo &result);
 
 	void Verify();
 

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

@@ -21,6 +21,8 @@ class TableDataWriter;
 class TableIndexList;
 class TableStatistics;
 
+class BoundConstraint;
+
 class RowGroupCollection {
 public:
 	RowGroupCollection(shared_ptr<DataTableInfo> info, BlockManager &block_manager, vector<LogicalType> types,
@@ -49,12 +51,12 @@ public:
 	void InitializeParallelScan(ParallelCollectionScanState &state);
 	bool NextParallelScan(ClientContext &context, ParallelCollectionScanState &state, CollectionScanState &scan_state);
 
-	bool Scan(Transaction &transaction, const vector<column_t> &column_ids,
+	bool Scan(DuckTransaction &transaction, const vector<column_t> &column_ids,
 	          const std::function<bool(DataChunk &chunk)> &fun);
-	bool Scan(Transaction &transaction, const std::function<bool(DataChunk &chunk)> &fun);
+	bool Scan(DuckTransaction &transaction, const std::function<bool(DataChunk &chunk)> &fun);
 
 	void Fetch(TransactionData transaction, DataChunk &result, const vector<column_t> &column_ids,
-	           Vector &row_identifiers, idx_t fetch_count, ColumnFetchState &state);
+	           const Vector &row_identifiers, idx_t fetch_count, ColumnFetchState &state);
 
 	//! Initialize an append of a variable number of rows. FinalizeAppend must be called after appending is done.
 	void InitializeAppend(TableAppendState &state);
@@ -81,7 +83,7 @@ public:
 	void CommitDropColumn(idx_t index);
 	void CommitDropTable();
 
-	vector<vector<Value>> GetStorageInfo();
+	void GetStorageInfo(TableStorageInfo &result);
 	const vector<LogicalType> &GetTypes() const;
 
 	shared_ptr<RowGroupCollection> AddColumn(ClientContext &context, ColumnDefinition &new_column,

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

@@ -28,6 +28,7 @@ class ColumnSegment;
 class ValiditySegment;
 class TableFilterSet;
 class ColumnData;
+class DuckTransaction;
 
 struct SegmentScanState {
 	virtual ~SegmentScanState() {
@@ -59,7 +60,7 @@ struct ColumnScanState {
 	//! The version of the column data that we are scanning.
 	//! This is used to detect if the ColumnData has been changed out from under us during a scan
 	//! If this is the case, we re-initialize the scan
-	idx_t version;
+	idx_t version = 0;
 	//! We initialize one SegmentScanState per segment, however, if scanning a DataChunk requires us to scan over more
 	//! than one Segment, we need to keep the scan states of the previous segments around
 	vector<unique_ptr<SegmentScanState>> previous_states;
@@ -124,7 +125,7 @@ public:
 	const vector<column_t> &GetColumnIds();
 	TableFilterSet *GetFilters();
 	AdaptiveFilter *GetAdaptiveFilter();
-	bool Scan(Transaction &transaction, DataChunk &result);
+	bool Scan(DuckTransaction &transaction, DataChunk &result);
 	bool ScanCommitted(DataChunk &result, TableScanType type);
 
 private:

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

@@ -19,9 +19,12 @@ public:
 	}
 	virtual ~SegmentBase() {
 	}
-
 	SegmentBase *Next() {
+#ifndef DUCKDB_R_BUILD
 		return next.load();
+#else
+		return next;
+#endif
 	}
 
 	//! The start row id of this chunk
@@ -29,7 +32,12 @@ public:
 	//! The amount of entries in this storage chunk
 	atomic<idx_t> count;
 	//! The next segment after this one
+
+#ifndef DUCKDB_R_BUILD
 	atomic<SegmentBase *> next;
+#else
+	SegmentBase *next;
+#endif
 };
 
 } // namespace duckdb

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

@@ -56,7 +56,7 @@ public:
 
 	void DeserializeColumn(Deserializer &source) override;
 
-	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) override;
+	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) override;
 
 	void Verify(RowGroup &parent) override;
 

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

@@ -59,7 +59,7 @@ public:
 
 	void DeserializeColumn(Deserializer &source) override;
 
-	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) override;
+	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) override;
 
 	void Verify(RowGroup &parent) override;
 };

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

@@ -12,6 +12,9 @@
 #include "duckdb/storage/index.hpp"
 
 namespace duckdb {
+
+class ConflictManager;
+
 class TableIndexList {
 public:
 	//! Scan the catalog set, invoking the callback method for every entry
@@ -26,6 +29,10 @@ public:
 		}
 	}
 
+	const vector<unique_ptr<Index>> &Indexes() const {
+		return indexes;
+	}
+
 	void AddIndex(unique_ptr<Index> index);
 
 	void RemoveIndex(Index *index);
@@ -37,8 +44,7 @@ public:
 	void Move(TableIndexList &other);
 
 	Index *FindForeignKeyIndex(const vector<PhysicalIndex> &fk_keys, ForeignKeyType fk_type);
-	void VerifyForeignKey(const vector<PhysicalIndex> &fk_keys, bool is_append, DataChunk &chunk,
-	                      vector<string> &err_msg);
+	void VerifyForeignKey(const vector<PhysicalIndex> &fk_keys, DataChunk &chunk, ConflictManager &conflict_manager);
 
 	//! Serialize all indexes owned by this table, returns a vector of block info of all indexes
 	vector<BlockPointer> SerializeIndexes(duckdb::MetaBlockWriter &writer);

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

@@ -23,6 +23,8 @@ struct UpdateNode;
 class UpdateSegment {
 public:
 	UpdateSegment(ColumnData &column_data);
+	// Construct a duplicate of 'other' with 'new_owner' as it's column data
+	UpdateSegment(UpdateSegment &other, ColumnData &new_owner);
 	~UpdateSegment();
 
 	ColumnData &column_data;

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

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table_storage_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/types/value.hpp"
+
+namespace duckdb {
+
+struct ColumnSegmentInfo {
+	idx_t row_group_index;
+	idx_t column_id;
+	string column_path;
+	idx_t segment_idx;
+	string segment_type;
+	idx_t segment_start;
+	idx_t segment_count;
+	string compression_type;
+	string segment_stats;
+	bool has_updates;
+	bool persistent;
+	block_id_t block_id;
+	idx_t block_offset;
+};
+
+struct IndexInfo {
+	bool is_unique;
+	bool is_primary;
+	bool is_foreign;
+	unordered_set<column_t> column_set;
+};
+
+class TableStorageInfo {
+public:
+	//! The (estimated) cardinality of the table
+	idx_t cardinality = DConstants::INVALID_INDEX;
+	//! Info of the indexes of a table
+	vector<IndexInfo> index_info;
+	//! Info of the column segments of the table
+	vector<ColumnSegmentInfo> column_segments;
+};
+
+} // namespace duckdb

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

@@ -12,11 +12,11 @@
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/enums/wal_type.hpp"
 #include "duckdb/common/serializer/buffered_file_writer.hpp"
-#include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
-#include "duckdb/storage/storage_info.hpp"
-
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp"
+#include "duckdb/main/attached_database.hpp"
+#include "duckdb/storage/storage_info.hpp"
 
 namespace duckdb {
 
@@ -38,8 +38,8 @@ class TransactionManager;
 class ReplayState {
 public:
 	ReplayState(AttachedDatabase &db, ClientContext &context, Deserializer &source)
-	    : db(db), context(context), catalog(Catalog::GetCatalog(context, INVALID_CATALOG)), source(source),
-	      current_table(nullptr), deserialize_only(false), checkpoint_id(INVALID_BLOCK) {
+	    : db(db), context(context), catalog(db.GetCatalog()), source(source), current_table(nullptr),
+	      deserialize_only(false), checkpoint_id(INVALID_BLOCK) {
 	}
 
 	AttachedDatabase &db;

package/src/duckdb/src/include/duckdb/transaction/duck_transaction.hpp

@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/transaction/duck_transaction.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/transaction/transaction.hpp"
+
+namespace duckdb {
+
+class DuckTransaction : public Transaction {
+public:
+	DuckTransaction(TransactionManager &manager, ClientContext &context, transaction_t start_time,
+	                transaction_t transaction_id);
+	~DuckTransaction();
+
+	//! The start timestamp of this transaction
+	transaction_t start_time;
+	//! The transaction id of this transaction
+	transaction_t transaction_id;
+	//! The commit id of this transaction, if it has successfully been committed
+	transaction_t commit_id;
+	//! Map of all sequences that were used during the transaction and the value they had in this transaction
+	unordered_map<SequenceCatalogEntry *, SequenceValue> sequence_usage;
+	//! Highest active query when the transaction finished, used for cleaning up
+	transaction_t highest_active_query;
+
+public:
+	static DuckTransaction &Get(ClientContext &context, AttachedDatabase &db);
+	static DuckTransaction &Get(ClientContext &context, Catalog &catalog);
+	LocalStorage &GetLocalStorage();
+
+	void PushCatalogEntry(CatalogEntry *entry, data_ptr_t extra_data = nullptr, idx_t extra_data_size = 0);
+
+	//! Commit the current transaction with the given commit identifier. Returns an error message if the transaction
+	//! commit failed, or an empty string if the commit was sucessful
+	string Commit(AttachedDatabase &db, transaction_t commit_id, bool checkpoint) noexcept;
+	//! Returns whether or not a commit of this transaction should trigger an automatic checkpoint
+	bool AutomaticCheckpoint(AttachedDatabase &db);
+
+	//! Rollback
+	void Rollback() noexcept;
+	//! Cleanup the undo buffer
+	void Cleanup();
+
+	bool ChangesMade();
+
+	void PushDelete(DataTable *table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row);
+	void PushAppend(DataTable *table, idx_t row_start, idx_t row_count);
+	UpdateInfo *CreateUpdateInfo(idx_t type_size, idx_t entries);
+
+	bool IsDuckTransaction() const override {
+		return true;
+	}
+
+private:
+	//! The undo buffer is used to store old versions of rows that are updated
+	//! or deleted
+	UndoBuffer undo_buffer;
+	//! The set of uncommitted appends for the transaction
+	unique_ptr<LocalStorage> storage;
+};
+
+} // namespace duckdb