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

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,43 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/storage_extension.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/enums/access_mode.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);
+
+class StorageExtension {
+public:
+	attach_function_t attach;
+	create_transaction_manager_t create_transaction_manager;
+
+	//! 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_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

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

@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/transaction/duck_transaction_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/transaction/transaction_manager.hpp"
+
+namespace duckdb {
+class DuckTransaction;
+
+//! The Transaction Manager is responsible for creating and managing
+//! transactions
+class DuckTransactionManager : public TransactionManager {
+	friend struct CheckpointLock;
+
+public:
+	explicit DuckTransactionManager(AttachedDatabase &db);
+	~DuckTransactionManager();
+
+public:
+	static DuckTransactionManager &Get(AttachedDatabase &db);
+
+	//! Start a new transaction
+	Transaction *StartTransaction(ClientContext &context) override;
+	//! Commit the given transaction
+	string CommitTransaction(ClientContext &context, Transaction *transaction) override;
+	//! Rollback the given transaction
+	void RollbackTransaction(Transaction *transaction) override;
+
+	void Checkpoint(ClientContext &context, bool force = false) override;
+
+	transaction_t LowestActiveId() {
+		return lowest_active_id;
+	}
+	transaction_t LowestActiveStart() {
+		return lowest_active_start;
+	}
+
+	bool IsDuckTransactionManager() override {
+		return true;
+	}
+
+private:
+	bool CanCheckpoint(DuckTransaction *current = nullptr);
+	//! Remove the given transaction from the list of active transactions
+	void RemoveTransaction(DuckTransaction *transaction) noexcept;
+	void LockClients(vector<ClientLockWrapper> &client_locks, ClientContext &context);
+
+private:
+	//! The current start timestamp used by transactions
+	transaction_t current_start_timestamp;
+	//! The current transaction ID used by transactions
+	transaction_t current_transaction_id;
+	//! The lowest active transaction id
+	atomic<transaction_t> lowest_active_id;
+	//! The lowest active transaction timestamp
+	atomic<transaction_t> lowest_active_start;
+	//! Set of currently running transactions
+	vector<unique_ptr<DuckTransaction>> active_transactions;
+	//! Set of recently committed transactions
+	vector<unique_ptr<DuckTransaction>> recently_committed_transactions;
+	//! Transactions awaiting GC
+	vector<unique_ptr<DuckTransaction>> old_transactions;
+	//! The lock used for transaction operations
+	mutex transaction_lock;
+
+	bool thread_is_checkpointing;
+};
+
+} // namespace duckdb

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

@@ -16,6 +16,7 @@
 namespace duckdb {
 class AttachedDatabase;
 class DataTable;
+class Transaction;
 class WriteAheadLog;
 struct TableAppendState;
 
@@ -85,9 +86,9 @@ public:
 	void Rollback();
 	idx_t EstimatedSize();
 
-	void AppendToIndexes(Transaction &transaction, TableAppendState &append_state, idx_t append_count,
+	void AppendToIndexes(DuckTransaction &transaction, TableAppendState &append_state, idx_t append_count,
 	                     bool append_to_table);
-	bool AppendToIndexes(Transaction &transaction, RowGroupCollection &source, TableIndexList &index_list,
+	bool AppendToIndexes(DuckTransaction &transaction, RowGroupCollection &source, TableIndexList &index_list,
 	                     const vector<LogicalType> &table_types, row_t &start_row);
 
 	//! Creates an optimistic writer for this table
@@ -121,9 +122,9 @@ public:
 	};
 
 public:
-	explicit LocalStorage(ClientContext &context, Transaction &transaction);
+	explicit LocalStorage(ClientContext &context, DuckTransaction &transaction);
 
-	static LocalStorage &Get(Transaction &transaction);
+	static LocalStorage &Get(DuckTransaction &transaction);
 	static LocalStorage &Get(ClientContext &context, AttachedDatabase &db);
 	static LocalStorage &Get(ClientContext &context, Catalog &catalog);
 
@@ -153,7 +154,7 @@ public:
 	void Update(DataTable *table, Vector &row_ids, const vector<PhysicalIndex> &column_ids, DataChunk &data);
 
 	//! Commits the local storage, writing it to the WAL and completing the commit
-	void Commit(LocalStorage::CommitState &commit_state, Transaction &transaction);
+	void Commit(LocalStorage::CommitState &commit_state, DuckTransaction &transaction);
 	//! Rollback the local storage
 	void Rollback();
 
@@ -170,14 +171,15 @@ public:
 	                const vector<column_t> &bound_columns, Expression &cast_expr);
 
 	void MoveStorage(DataTable *old_dt, DataTable *new_dt);
-	void FetchChunk(DataTable *table, Vector &row_ids, idx_t count, DataChunk &chunk);
+	void FetchChunk(DataTable *table, Vector &row_ids, idx_t count, const vector<column_t> &col_ids, DataChunk &chunk,
+	                ColumnFetchState &fetch_state);
 	TableIndexList &GetIndexes(DataTable *table);
 
 	void VerifyNewConstraint(DataTable &parent, const BoundConstraint &constraint);
 
 private:
 	ClientContext &context;
-	Transaction &transaction;
+	DuckTransaction &transaction;
 	LocalTableManager table_manager;
 
 	void Flush(DataTable &table, LocalTableStorage &storage);

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

@@ -51,6 +51,9 @@ public:
 	void SetActiveQuery(transaction_t query_number);
 
 	void ModifyDatabase(AttachedDatabase *db);
+	AttachedDatabase *ModifiedDatabase() {
+		return modified_database;
+	}
 
 private:
 	//! The set of active transactions for each database

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

@@ -38,58 +38,25 @@ struct UpdateInfo;
 //! transaction
 class Transaction {
 public:
-	Transaction(TransactionManager &manager, ClientContext &context, transaction_t start_time,
-	            transaction_t transaction_id);
-	~Transaction();
+	DUCKDB_API Transaction(TransactionManager &manager, ClientContext &context);
+	DUCKDB_API virtual ~Transaction();
 
 	TransactionManager &manager;
 	weak_ptr<ClientContext> context;
-	//! 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;
 	//! The current active query for the transaction. Set to MAXIMUM_QUERY_ID if
 	//! no query is active.
 	atomic<transaction_t> active_query;
-	//! Highest active query when the transaction finished, used for cleaning up
-	transaction_t highest_active_query;
 
 public:
-	static Transaction &Get(ClientContext &context, AttachedDatabase &db);
-	static Transaction &Get(ClientContext &context, Catalog &catalog);
-	LocalStorage &GetLocalStorage();
+	DUCKDB_API static Transaction &Get(ClientContext &context, AttachedDatabase &db);
+	DUCKDB_API static Transaction &Get(ClientContext &context, Catalog &catalog);
 
-	void PushCatalogEntry(CatalogEntry *entry, data_ptr_t extra_data = nullptr, idx_t extra_data_size = 0);
+	//! Whether or not the transaction has made any modifications to the database so far
+	DUCKDB_API bool IsReadOnly();
 
-	//! 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);
-
-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;
-
-	Transaction(const Transaction &) = delete;
+	virtual bool IsDuckTransaction() const {
+		return false;
+	}
 };
 
 } // namespace duckdb

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

@@ -11,13 +11,14 @@
 #include "duckdb/common/common.hpp"
 
 namespace duckdb {
+class DuckTransaction;
 class Transaction;
 
 struct TransactionData {
-	TransactionData(Transaction &transaction_p);
+	TransactionData(DuckTransaction &transaction_p);
 	TransactionData(transaction_t transaction_id_p, transaction_t start_time_p);
 
-	Transaction *transaction;
+	DuckTransaction *transaction;
 	transaction_t transaction_id;
 	transaction_t start_time;
 };