duckdb 0.6.2-dev781.0 → 0.6.2-dev891.0

package/src/duckdb/src/include/duckdb/parser/query_error_context.hpp

@@ -27,9 +27,9 @@ public:
 	idx_t query_location;
 
 public:
-	static string Format(const string &query, const string &error_message, int error_location);
+	DUCKDB_API static string Format(const string &query, const string &error_message, int error_location);
 
-	string FormatErrorRecursive(const string &msg, vector<ExceptionFormatValue> &values);
+	DUCKDB_API string FormatErrorRecursive(const string &msg, vector<ExceptionFormatValue> &values);
 	template <class T, typename... Args>
 	string FormatErrorRecursive(const string &msg, vector<ExceptionFormatValue> &values, T param, Args... params) {
 		values.push_back(ExceptionFormatValue::CreateFormatValue<T>(param));

package/src/duckdb/src/include/duckdb/parser/statement/attach_statement.hpp

@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/statement/attach_statement.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/parsed_data/attach_info.hpp"
+#include "duckdb/parser/sql_statement.hpp"
+
+namespace duckdb {
+
+class AttachStatement : public SQLStatement {
+public:
+	AttachStatement();
+
+	unique_ptr<AttachInfo> info;
+
+protected:
+	AttachStatement(const AttachStatement &other);
+
+public:
+	unique_ptr<SQLStatement> Copy() const override;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/statement/export_statement.hpp

@@ -19,6 +19,7 @@ public:
 	explicit ExportStatement(unique_ptr<CopyInfo> info);
 
 	unique_ptr<CopyInfo> info;
+	string database;
 
 protected:
 	ExportStatement(const ExportStatement &other);

package/src/duckdb/src/include/duckdb/parser/statement/insert_statement.hpp

@@ -28,6 +28,8 @@ public:
 	string table;
 	//! Schema name to insert to
 	string schema;
+	//! The catalog name to insert to
+	string catalog;
 
 	//! keep track of optional returningList if statement contains a RETURNING keyword
 	vector<unique_ptr<ParsedExpression>> returning_list;

package/src/duckdb/src/include/duckdb/parser/statement/list.hpp

@@ -1,4 +1,5 @@
 #include "duckdb/parser/statement/alter_statement.hpp"
+#include "duckdb/parser/statement/attach_statement.hpp"
 #include "duckdb/parser/statement/call_statement.hpp"
 #include "duckdb/parser/statement/copy_statement.hpp"
 #include "duckdb/parser/statement/create_statement.hpp"

package/src/duckdb/src/include/duckdb/parser/tableref/basetableref.hpp

@@ -15,9 +15,12 @@ namespace duckdb {
 //! Represents a TableReference to a base table in the schema
 class BaseTableRef : public TableRef {
 public:
-	BaseTableRef() : TableRef(TableReferenceType::BASE_TABLE), schema_name(INVALID_SCHEMA) {
+	BaseTableRef()
+	    : TableRef(TableReferenceType::BASE_TABLE), catalog_name(INVALID_CATALOG), schema_name(INVALID_SCHEMA) {
 	}
 
+	//! The catalog name
+	string catalog_name;
 	//! Schema name
 	string schema_name;
 	//! Table name

package/src/duckdb/src/include/duckdb/parser/tokens.hpp

@@ -16,6 +16,7 @@ namespace duckdb {
 class SQLStatement;
 
 class AlterStatement;
+class AttachStatement;
 class CallStatement;
 class CopyStatement;
 class CreateStatement;

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -144,6 +144,8 @@ private:
 	unique_ptr<SQLStatement> TransformVacuum(duckdb_libpgquery::PGNode *node);
 	unique_ptr<SQLStatement> TransformShow(duckdb_libpgquery::PGNode *node);
 	unique_ptr<ShowStatement> TransformShowSelect(duckdb_libpgquery::PGNode *node);
+	unique_ptr<AttachStatement> TransformAttach(duckdb_libpgquery::PGNode *node);
+	unique_ptr<SetStatement> TransformUse(duckdb_libpgquery::PGNode *node);
 
 	unique_ptr<PrepareStatement> TransformPrepare(duckdb_libpgquery::PGNode *node);
 	unique_ptr<ExecuteStatement> TransformExecute(duckdb_libpgquery::PGNode *node);

package/src/duckdb/src/include/duckdb/planner/bind_context.hpp

@@ -63,6 +63,8 @@ public:
 	unique_ptr<ParsedExpression> CreateColumnReference(const string &table_name, const string &column_name);
 	unique_ptr<ParsedExpression> CreateColumnReference(const string &schema_name, const string &table_name,
 	                                                   const string &column_name);
+	unique_ptr<ParsedExpression> CreateColumnReference(const string &catalog_name, const string &schema_name,
+	                                                   const string &table_name, const string &column_name);
 
 	//! Generate column expressions for all columns that are present in the
 	//! referenced tables. This is used to resolve the * expression in a

package/src/duckdb/src/include/duckdb/planner/binder.hpp

@@ -100,6 +100,7 @@ public:
 	BoundStatement Bind(QueryNode &node);
 
 	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info);
+	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry *schema);
 	void BindCreateViewInfo(CreateViewInfo &base);
 	SchemaCatalogEntry *BindSchema(CreateInfo &info);
 	SchemaCatalogEntry *BindCreateFunctionInfo(CreateInfo &info);
@@ -153,11 +154,15 @@ public:
 		return FormatErrorRecursive(query_location, msg, values, params...);
 	}
 
-	static void BindLogicalType(ClientContext &context, LogicalType &type, const string &schema = "");
+	static void BindSchemaOrCatalog(ClientContext &context, string &catalog, string &schema);
+	static void BindLogicalType(ClientContext &context, LogicalType &type, const string &catalog = INVALID_CATALOG,
+	                            const string &schema = INVALID_SCHEMA);
 
 	bool HasMatchingBinding(const string &table_name, const string &column_name, string &error_message);
 	bool HasMatchingBinding(const string &schema_name, const string &table_name, const string &column_name,
 	                        string &error_message);
+	bool HasMatchingBinding(const string &catalog_name, const string &schema_name, const string &table_name,
+	                        const string &column_name, string &error_message);
 
 	void SetBindingMode(BindingMode mode);
 	BindingMode GetBindingMode();
@@ -227,6 +232,7 @@ private:
 	BoundStatement Bind(ResetVariableStatement &stmt);
 	BoundStatement Bind(LoadStatement &stmt);
 	BoundStatement Bind(LogicalPlanStatement &stmt);
+	BoundStatement Bind(AttachStatement &stmt);
 
 	BoundStatement BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
 	                             idx_t update_table_index, unique_ptr<LogicalOperator> child_operator,
@@ -314,6 +320,10 @@ private:
 	bool FindStarExpression(ParsedExpression &expr, StarExpression **star);
 	void ReplaceStarExpression(unique_ptr<ParsedExpression> &expr, unique_ptr<ParsedExpression> &replacement);
 
+	//! If only a schema name is provided (e.g. "a.b") then figure out if "a" is a schema or a catalog name
+	void BindSchemaOrCatalog(string &catalog_name, string &schema_name);
+	SchemaCatalogEntry *BindCreateSchema(CreateInfo &info);
+
 public:
 	// This should really be a private constructor, but make_shared does not allow it...
 	// If you are thinking about calling this, you should probably call Binder::CreateBinder

package/src/duckdb/src/include/duckdb/planner/parsed_data/bound_create_table_info.hpp

@@ -17,6 +17,7 @@
 #include "duckdb/catalog/catalog_entry/table_column_type.hpp"
 #include "duckdb/catalog/catalog_entry/column_dependency_manager.hpp"
 #include "duckdb/storage/table/table_index_list.hpp"
+#include "duckdb/catalog/dependency_list.hpp"
 
 namespace duckdb {
 class CatalogEntry;
@@ -39,7 +40,7 @@ struct BoundCreateTableInfo {
 	//! Bound default values
 	vector<unique_ptr<Expression>> bound_defaults;
 	//! Dependents of the table (in e.g. default values)
-	unordered_set<CatalogEntry *> dependencies;
+	DependencyList dependencies;
 	//! The existing table data on disk (if any)
 	unique_ptr<PersistentTableData> data;
 	//! CREATE TABLE from QUERY

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

@@ -59,6 +59,7 @@ public:
 
 	static BufferManager &GetBufferManager(ClientContext &context);
 	DUCKDB_API static BufferManager &GetBufferManager(DatabaseInstance &db);
+	DUCKDB_API static BufferManager &GetBufferManager(AttachedDatabase &db);
 
 	idx_t GetUsedMemory() {
 		return current_memory;

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

@@ -10,6 +10,7 @@
 
 #include "duckdb/storage/partial_block_manager.hpp"
 #include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
 
 namespace duckdb {
 class DatabaseInstance;
@@ -24,13 +25,15 @@ class TypeCatalogEntry;
 
 class CheckpointWriter {
 public:
-	explicit CheckpointWriter(DatabaseInstance &db) : db(db) {
+	explicit CheckpointWriter(AttachedDatabase &db) : db(db), catalog(Catalog::GetCatalog(db)) {
 	}
 	virtual ~CheckpointWriter() {
 	}
 
 	//! The database
-	DatabaseInstance &db;
+	AttachedDatabase &db;
+	//! The catalog
+	Catalog &catalog;
 
 	virtual MetaBlockWriter &GetMetaBlockWriter() = 0;
 	virtual unique_ptr<TableDataWriter> GetTableDataWriter(TableCatalogEntry &table) = 0;
@@ -48,9 +51,14 @@ protected:
 
 class CheckpointReader {
 public:
+	CheckpointReader(Catalog &catalog) : catalog(catalog) {
+	}
 	virtual ~CheckpointReader() {
 	}
 
+protected:
+	Catalog &catalog;
+
 protected:
 	virtual void LoadCheckpoint(ClientContext &context, MetaBlockReader &reader);
 	virtual void ReadSchema(ClientContext &context, MetaBlockReader &reader);
@@ -67,7 +75,8 @@ protected:
 
 class SingleFileCheckpointReader final : public CheckpointReader {
 public:
-	explicit SingleFileCheckpointReader(SingleFileStorageManager &storage) : storage(storage) {
+	explicit SingleFileCheckpointReader(SingleFileStorageManager &storage)
+	    : CheckpointReader(Catalog::GetCatalog(storage.GetAttached())), storage(storage) {
 	}
 
 	void LoadFromStorage();
@@ -85,9 +94,7 @@ class SingleFileCheckpointWriter final : public CheckpointWriter {
 	friend class SingleFileTableDataWriter;
 
 public:
-	explicit SingleFileCheckpointWriter(DatabaseInstance &db, BlockManager &block_manager)
-	    : CheckpointWriter(db), partial_block_manager(block_manager) {
-	}
+	SingleFileCheckpointWriter(AttachedDatabase &db, BlockManager &block_manager);
 
 	//! 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)

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

@@ -24,6 +24,7 @@
 #include "duckdb/storage/table/data_table_info.hpp"
 
 namespace duckdb {
+class BoundForeignKeyConstraint;
 class ClientContext;
 class ColumnDataCollection;
 class ColumnDefinition;
@@ -41,7 +42,7 @@ class TableDataWriter;
 class DataTable {
 public:
 	//! Constructs a new data table from an (optional) set of persistent segments
-	DataTable(DatabaseInstance &db, shared_ptr<TableIOManager> table_io_manager, const string &schema,
+	DataTable(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_manager, const string &schema,
 	          const string &table, vector<ColumnDefinition> column_definitions_p,
 	          unique_ptr<PersistentTableData> data = nullptr);
 	//! Constructs a DataTable as a delta on an existing data table with a newly added column
@@ -59,7 +60,7 @@ public:
 	//! The set of physical columns stored by this DataTable
 	vector<ColumnDefinition> column_definitions;
 	//! A reference to the database instance
-	DatabaseInstance &db;
+	AttachedDatabase &db;
 
 public:
 	//! Returns a list of types of the table
@@ -190,6 +191,13 @@ private:
 	void InitializeScanWithOffset(TableScanState &state, const vector<column_t> &column_ids, idx_t start_row,
 	                              idx_t end_row);
 
+	void VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context, DataChunk &chunk,
+	                                bool is_append);
+	void VerifyAppendForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
+	                                      DataChunk &chunk);
+	void VerifyDeleteForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
+	                                      DataChunk &chunk);
+
 private:
 	//! Lock for appending entries to the table
 	mutex append_lock;

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

@@ -25,7 +25,7 @@ class SingleFileBlockManager : public BlockManager {
 	static constexpr uint64_t BLOCK_START = Storage::FILE_HEADER_SIZE * 3;
 
 public:
-	SingleFileBlockManager(DatabaseInstance &db, string path, bool read_only, bool create_new, bool use_direct_io);
+	SingleFileBlockManager(AttachedDatabase &db, string path, bool read_only, bool create_new, bool use_direct_io);
 
 	//! 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;
@@ -63,7 +63,7 @@ private:
 	vector<block_id_t> GetFreeListBlocks();
 
 private:
-	DatabaseInstance &db;
+	AttachedDatabase &db;
 	//! The active DatabaseHeader, either 0 (h1) or 1 (h2)
 	uint8_t active_header;
 	//! The path where the file is stored

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

@@ -46,8 +46,8 @@ public:
 public:
 	static unique_ptr<BaseStatistics> CreateEmpty(LogicalType type, StatisticsType stats_type);
 
-	bool CanHaveNull() const;
-	bool CanHaveNoNull() const;
+	DUCKDB_API bool CanHaveNull() const;
+	DUCKDB_API bool CanHaveNoNull() const;
 
 	void UpdateDistinctStatistics(Vector &v, idx_t count);
 

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

@@ -46,22 +46,18 @@ public:
 //! database on disk
 class StorageManager {
 public:
-	StorageManager(DatabaseInstance &db, string path, bool read_only);
+	StorageManager(AttachedDatabase &db, string path, bool read_only);
 	virtual ~StorageManager();
 
-	//! The BufferManager of the database
-	unique_ptr<BufferManager> buffer_manager;
-	//! The database this storagemanager belongs to
-	DatabaseInstance &db;
-
 public:
-	static StorageManager &GetStorageManager(ClientContext &context);
-	static StorageManager &GetStorageManager(DatabaseInstance &db);
+	static StorageManager &Get(AttachedDatabase &db);
+	static StorageManager &Get(Catalog &catalog);
 
 	//! Initialize a database or load an existing database from the given path
 	void Initialize();
 
-	DatabaseInstance &GetDatabase() {
+	DatabaseInstance &GetDatabase();
+	AttachedDatabase &GetAttached() {
 		return db;
 	}
 
@@ -84,13 +80,14 @@ public:
 
 protected:
 	virtual void LoadDatabase() = 0;
-	virtual void CreateBufferManager();
 
+protected:
+	//! The database this storagemanager belongs to
+	AttachedDatabase &db;
 	//! The path of the database
 	string path;
 	//! The WriteAheadLog of the storage manager
 	unique_ptr<WriteAheadLog> wal;
-
 	//! Whether or not the database is opened in read-only mode
 	bool read_only;
 };
@@ -98,7 +95,7 @@ protected:
 //! Stores database in a single file.
 class SingleFileStorageManager : public StorageManager {
 public:
-	SingleFileStorageManager(DatabaseInstance &db, string path, bool read_only);
+	SingleFileStorageManager(AttachedDatabase &db, string path, bool read_only);
 
 	//! The BlockManager to read/store meta information and data in blocks
 	unique_ptr<BlockManager> block_manager;

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

@@ -17,12 +17,10 @@ class DatabaseInstance;
 class TableIOManager;
 
 struct DataTableInfo {
-	DataTableInfo(DatabaseInstance &db, shared_ptr<TableIOManager> table_io_manager_p, string schema, string table)
-	    : db(db), table_io_manager(move(table_io_manager_p)), cardinality(0), schema(move(schema)), table(move(table)) {
-	}
+	DataTableInfo(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_manager_p, string schema, string table);
 
 	//! The database instance of the table
-	DatabaseInstance &db;
+	AttachedDatabase &db;
 	//! The table IO manager
 	shared_ptr<TableIOManager> table_io_manager;
 	//! The amount of elements in the table. Note that this number signifies the amount of COMMITTED entries in the
@@ -35,9 +33,7 @@ struct DataTableInfo {
 
 	TableIndexList indexes;
 
-	bool IsTemporary() {
-		return schema == TEMP_SCHEMA;
-	}
+	bool IsTemporary() const;
 };
 
 } // namespace duckdb

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

@@ -19,6 +19,7 @@
 #include "duckdb/parser/column_list.hpp"
 
 namespace duckdb {
+class AttachedDatabase;
 class BlockManager;
 class ColumnData;
 class DatabaseInstance;
@@ -49,15 +50,15 @@ public:
 	static constexpr const idx_t ROW_GROUP_VECTOR_COUNT = ROW_GROUP_SIZE / STANDARD_VECTOR_SIZE;
 
 public:
-	RowGroup(DatabaseInstance &db, BlockManager &block_manager, DataTableInfo &table_info, idx_t start, idx_t count);
-	RowGroup(DatabaseInstance &db, BlockManager &block_manager, DataTableInfo &table_info,
+	RowGroup(AttachedDatabase &db, BlockManager &block_manager, DataTableInfo &table_info, idx_t start, idx_t count);
+	RowGroup(AttachedDatabase &db, BlockManager &block_manager, DataTableInfo &table_info,
 	         const vector<LogicalType> &types, RowGroupPointer &&pointer);
 	RowGroup(RowGroup &row_group, idx_t start);
 	~RowGroup();
 
 private:
 	//! The database instance
-	DatabaseInstance &db;
+	AttachedDatabase &db;
 	//! The block manager
 	BlockManager &block_manager;
 	//! The table info of this row_group
@@ -70,9 +71,7 @@ private:
 	vector<shared_ptr<SegmentStatistics>> stats;
 
 public:
-	DatabaseInstance &GetDatabase() {
-		return db;
-	}
+	DatabaseInstance &GetDatabase();
 	BlockManager &GetBlockManager() {
 		return block_manager;
 	}

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

@@ -22,6 +22,7 @@ namespace duckdb {
 
 struct AlterInfo;
 
+class AttachedDatabase;
 class BufferedSerializer;
 class Catalog;
 class DatabaseInstance;
@@ -36,13 +37,14 @@ class TransactionManager;
 
 class ReplayState {
 public:
-	ReplayState(DatabaseInstance &db, ClientContext &context, Deserializer &source)
-	    : db(db), context(context), source(source), current_table(nullptr), deserialize_only(false),
-	      checkpoint_id(INVALID_BLOCK) {
+	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) {
 	}
 
-	DatabaseInstance &db;
+	AttachedDatabase &db;
 	ClientContext &context;
+	Catalog &catalog;
 	Deserializer &source;
 	TableCatalogEntry *current_table;
 	bool deserialize_only;
@@ -89,7 +91,7 @@ protected:
 class WriteAheadLog {
 public:
 	//! Initialize the WAL in the specified directory
-	explicit WriteAheadLog(DatabaseInstance &database, const string &path);
+	explicit WriteAheadLog(AttachedDatabase &database, const string &path);
 	virtual ~WriteAheadLog();
 
 	//! Skip writing to the WAL
@@ -97,7 +99,7 @@ public:
 
 public:
 	//! Replay the WAL
-	static bool Replay(DatabaseInstance &database, string &path);
+	static bool Replay(AttachedDatabase &database, string &path);
 
 	//! Returns the current size of the WAL in bytes
 	int64_t GetWALSize();
@@ -151,7 +153,7 @@ public:
 	void WriteCheckpoint(block_id_t meta_block);
 
 protected:
-	DatabaseInstance &database;
+	AttachedDatabase &database;
 	unique_ptr<BufferedFileWriter> writer;
 	string wal_path;
 };

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

@@ -14,6 +14,7 @@
 #include "duckdb/storage/table/table_statistics.hpp"
 
 namespace duckdb {
+class AttachedDatabase;
 class DataTable;
 class WriteAheadLog;
 struct TableAppendState;
@@ -123,7 +124,8 @@ public:
 	explicit LocalStorage(ClientContext &context, Transaction &transaction);
 
 	static LocalStorage &Get(Transaction &transaction);
-	static LocalStorage &Get(ClientContext &context);
+	static LocalStorage &Get(ClientContext &context, AttachedDatabase &db);
+	static LocalStorage &Get(ClientContext &context, Catalog &catalog);
 
 	//! Initialize a scan of the local storage
 	void InitializeScan(DataTable *table, CollectionScanState &state, TableFilterSet *table_filters);

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

@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/transaction/meta_transaction.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/atomic.hpp"
+#include "duckdb/main/valid_checker.hpp"
+#include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/common/unordered_map.hpp"
+
+namespace duckdb {
+class AttachedDatabase;
+class ClientContext;
+class Transaction;
+
+//! The MetaTransaction manages multiple transactions for different attached databases
+class MetaTransaction {
+public:
+	DUCKDB_API MetaTransaction(ClientContext &context, timestamp_t start_timestamp, idx_t catalog_version);
+
+	ClientContext &context;
+	//! The timestamp when the transaction started
+	timestamp_t start_timestamp;
+	//! The catalog version when the transaction was started
+	idx_t catalog_version;
+	//! The validity checker of the transaction
+	ValidChecker transaction_validity;
+	//! Whether or not any transaction have made modifications
+	bool read_only;
+	//! The active query number
+	transaction_t active_query;
+
+public:
+	DUCKDB_API static MetaTransaction &Get(ClientContext &context);
+	timestamp_t GetCurrentTransactionStartTimestamp() {
+		return start_timestamp;
+	}
+
+	Transaction &GetTransaction(AttachedDatabase *db);
+
+	string Commit();
+	void Rollback();
+
+	idx_t GetActiveQuery();
+	void SetActiveQuery(transaction_t query_number);
+
+	void ModifyDatabase(AttachedDatabase *db);
+
+private:
+	//! The set of active transactions for each database
+	unordered_map<AttachedDatabase *, Transaction *> transactions;
+	//! The set of transactions in order of when they were started
+	vector<AttachedDatabase *> all_transactions;
+	//! The database we are modifying - we can only modify one database per transaction
+	AttachedDatabase *modified_database;
+};
+
+} // namespace duckdb

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

@@ -10,22 +10,23 @@
 
 #include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/unordered_map.hpp"
 #include "duckdb/transaction/undo_buffer.hpp"
 #include "duckdb/common/atomic.hpp"
 #include "duckdb/transaction/transaction_data.hpp"
-#include "duckdb/main/valid_checker.hpp"
 
 namespace duckdb {
 class SequenceCatalogEntry;
 class SchemaCatalogEntry;
 
+class AttachedDatabase;
 class ColumnData;
 class ClientContext;
 class CatalogEntry;
 class DataTable;
 class DatabaseInstance;
 class LocalStorage;
+class MetaTransaction;
+class TransactionManager;
 class WriteAheadLog;
 
 class ChunkVectorInfo;
@@ -37,10 +38,11 @@ struct UpdateInfo;
 //! transaction
 class Transaction {
 public:
-	Transaction(ClientContext &context, transaction_t start_time, transaction_t transaction_id,
-	            timestamp_t start_timestamp, idx_t catalog_version);
+	Transaction(TransactionManager &manager, ClientContext &context, transaction_t start_time,
+	            transaction_t transaction_id);
 	~Transaction();
 
+	TransactionManager &manager;
 	weak_ptr<ClientContext> context;
 	//! The start timestamp of this transaction
 	transaction_t start_time;
@@ -48,33 +50,26 @@ public:
 	transaction_t transaction_id;
 	//! The commit id of this transaction, if it has successfully been committed
 	transaction_t commit_id;
-	//! Highest active query when the transaction finished, used for cleaning up
-	transaction_t highest_active_query;
+	//! 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;
-	//! The timestamp when the transaction started
-	timestamp_t start_timestamp;
-	//! The catalog version when the transaction was started
-	idx_t catalog_version;
-	//! 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 validity checker of the transaction
-	ValidChecker transaction_validity;
-	//! A pointer to the temporary objects of the client context
-	shared_ptr<SchemaCatalogEntry> temporary_objects;
+	//! Highest active query when the transaction finished, used for cleaning up
+	transaction_t highest_active_query;
 
 public:
-	static Transaction &GetTransaction(ClientContext &context);
+	static Transaction &Get(ClientContext &context, AttachedDatabase &db);
+	static Transaction &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(DatabaseInstance &db, transaction_t commit_id, bool checkpoint) noexcept;
+	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(DatabaseInstance &db);
+	bool AutomaticCheckpoint(AttachedDatabase &db);
 
 	//! Rollback
 	void Rollback() noexcept;
@@ -83,10 +78,6 @@ public:
 
 	bool ChangesMade();
 
-	timestamp_t GetCurrentTransactionStartTimestamp() {
-		return start_timestamp;
-	}
-
 	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);