duckdb 0.8.2-dev4474.0 → 0.8.2-dev4572.0

package/lib/duckdb.js

@@ -412,6 +412,13 @@ Connection.prototype.register_buffer;
  */
 Connection.prototype.unregister_buffer;
 
+/**
+ * Closes connection
+ * @method
+ * @param callback
+ * @return {void}
+ */
+Connection.prototype.close;
 
 /**
  * Closes database instance
@@ -420,7 +427,10 @@ Connection.prototype.unregister_buffer;
  * @return {void}
  */
 Database.prototype.close = function() {
-    this.default_connection = null
+    if (this.default_connection) {
+        this.default_connection.close(); // this queues up a job in the internals, which blocks the below close call
+        this.default_connection = null;
+    }
     this.close_internal.apply(this, arguments);
 };
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev4474.0",
+  "version": "0.8.2-dev4572.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {
@@ -29,12 +29,14 @@
   "devDependencies": {
     "@types/chai": "^4.3.4",
     "@types/chai-as-promised": "^7.1.5",
+    "@types/fs-extra": "^11.0.1",
     "@types/mocha": "^10.0.0",
     "@types/node": "^18.11.0",
     "apache-arrow": "^9.0.0",
     "aws-sdk": "^2.790.0",
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
+    "fs-extra": "^11.1.1",
     "jsdoc3-parser": "^2.0.0",
     "mocha": "^8.3.0",
     "ts-node": "^10.9.1",

package/src/connection.cpp

@@ -12,13 +12,13 @@ namespace node_duckdb {
 Napi::FunctionReference Connection::Init(Napi::Env env, Napi::Object exports) {
 	Napi::HandleScope scope(env);
 
-	Napi::Function t =
-	    DefineClass(env, "Connection",
-	                {InstanceMethod("prepare", &Connection::Prepare), InstanceMethod("exec", &Connection::Exec),
-	                 InstanceMethod("register_udf_bulk", &Connection::RegisterUdf),
-	                 InstanceMethod("register_buffer", &Connection::RegisterBuffer),
-	                 InstanceMethod("unregister_udf", &Connection::UnregisterUdf),
-	                 InstanceMethod("unregister_buffer", &Connection::UnRegisterBuffer)});
+	Napi::Function t = DefineClass(
+	    env, "Connection",
+	    {InstanceMethod("prepare", &Connection::Prepare), InstanceMethod("exec", &Connection::Exec),
+	     InstanceMethod("register_udf_bulk", &Connection::RegisterUdf),
+	     InstanceMethod("register_buffer", &Connection::RegisterBuffer),
+	     InstanceMethod("unregister_udf", &Connection::UnregisterUdf), InstanceMethod("close", &Connection::Close),
+	     InstanceMethod("unregister_buffer", &Connection::UnRegisterBuffer)});
 
 	exports.Set("Connection", t);
 
@@ -407,6 +407,36 @@ struct ExecTaskWithCallback : public ExecTask {
 	std::function<void(void)> cpp_callback;
 };
 
+struct CloseConnectionTask : public Task {
+	CloseConnectionTask(Connection &connection, Napi::Function callback) : Task(connection, callback) {
+	}
+
+	void DoWork() override {
+		auto &connection = Get<Connection>();
+		if (connection.connection) {
+			connection.connection.reset();
+			success = true;
+		} else {
+			success = false;
+		}
+	}
+
+	void Callback() override {
+		auto &connection = Get<Connection>();
+		auto env = connection.Env();
+		Napi::HandleScope scope(env);
+
+		auto cb = callback.Value();
+		if (!success) {
+			cb.MakeCallback(connection.Value(), {Utils::CreateError(env, "Connection was already closed")});
+			return;
+		}
+		cb.MakeCallback(connection.Value(), {env.Null(), connection.Value()});
+	}
+
+	bool success = false;
+};
+
 Napi::Value Connection::Exec(const Napi::CallbackInfo &info) {
 	auto env = info.Env();
 
@@ -512,6 +542,17 @@ Napi::Value Connection::UnRegisterBuffer(const Napi::CallbackInfo &info) {
 	return Value();
 }
 
+Napi::Value Connection::Close(const Napi::CallbackInfo &info) {
+	Napi::Function callback;
+	if (info.Length() > 0 && info[0].IsFunction()) {
+		callback = info[0].As<Napi::Function>();
+	}
+
+	database_ref->Schedule(info.Env(), duckdb::make_uniq<CloseConnectionTask>(*this, callback));
+
+	return info.Env().Undefined();
+}
+
 Napi::Object Connection::NewInstance(const Napi::Value &db) {
 	return NodeDuckDB::GetData(db.Env())->connection_constructor.New({db});
 }

package/src/duckdb/extension/json/json_functions/json_serialize_sql.cpp

@@ -244,6 +244,9 @@ struct ExecuteSqlTableFunction {
 		auto result = make_uniq<BindData>();
 
 		result->con = make_uniq<Connection>(*context.db);
+		if (input.inputs[0].IsNull()) {
+			throw BinderException("json_execute_serialized_sql cannot execute NULL plan");
+		}
 		auto serialized = input.inputs[0].GetValueUnsafe<string>();
 		auto stmt = DeserializeSelectStatement(serialized, alc);
 		result->plan = result->con->RelationFromQuery(std::move(stmt));

package/src/duckdb/src/catalog/catalog.cpp

@@ -35,6 +35,7 @@
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/function/built_in_functions.hpp"
 #include "duckdb/catalog/similar_catalog_entry.hpp"
+#include "duckdb/storage/database_size.hpp"
 #include <algorithm>
 
 namespace duckdb {
@@ -831,6 +832,10 @@ void Catalog::Alter(ClientContext &context, AlterInfo &info) {
 	return lookup.schema->Alter(context, info);
 }
 
+vector<MetadataBlockInfo> Catalog::GetMetadataInfo(ClientContext &context) {
+	return vector<MetadataBlockInfo>();
+}
+
 void Catalog::Verify() {
 }
 

package/src/duckdb/src/catalog/duck_catalog.cpp

@@ -132,6 +132,10 @@ DatabaseSize DuckCatalog::GetDatabaseSize(ClientContext &context) {
 	return db.GetStorageManager().GetDatabaseSize();
 }
 
+vector<MetadataBlockInfo> DuckCatalog::GetMetadataInfo(ClientContext &context) {
+	return db.GetStorageManager().GetMetadataInfo();
+}
+
 bool DuckCatalog::InMemory() {
 	return db.GetStorageManager().InMemory();
 }

package/src/duckdb/src/execution/column_binding_resolver.cpp

@@ -102,6 +102,7 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 	default:
 		break;
 	}
+
 	// general case
 	// first visit the children of this operator
 	VisitOperatorChildren(op);

package/src/duckdb/src/execution/operator/persistent/physical_batch_insert.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/storage/table_io_manager.hpp"
 #include "duckdb/transaction/local_storage.hpp"
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/storage/table/append_state.hpp"
 #include "duckdb/storage/table/scan_state.hpp"
 
@@ -119,6 +120,7 @@ public:
 	idx_t insert_count;
 	vector<RowGroupBatchEntry> collections;
 	idx_t next_start = 0;
+	bool optimistically_written = false;
 
 	void FindMergeCollections(idx_t min_batch_index, optional_idx &merged_batch_index,
 	                          vector<unique_ptr<RowGroupCollection>> &result) {
@@ -176,10 +178,12 @@ public:
 	unique_ptr<RowGroupCollection> MergeCollections(ClientContext &context,
 	                                                vector<unique_ptr<RowGroupCollection>> merge_collections,
 	                                                OptimisticDataWriter &writer) {
+		D_ASSERT(!merge_collections.empty());
 		CollectionMerger merger(context);
 		for (auto &collection : merge_collections) {
 			merger.AddCollection(std::move(collection));
 		}
+		optimistically_written = true;
 		return merger.Flush(writer);
 	}
 
@@ -373,48 +377,65 @@ SinkFinalizeType PhysicalBatchInsert::Finalize(Pipeline &pipeline, Event &event,
                                                OperatorSinkFinalizeInput &input) const {
 	auto &gstate = input.global_state.Cast<BatchInsertGlobalState>();
 
-	// in the finalize, do a final pass over all of the collections we created and try to merge smaller collections
-	// together
-	vector<unique_ptr<CollectionMerger>> mergers;
-	unique_ptr<CollectionMerger> current_merger;
-
-	auto &storage = gstate.table.GetStorage();
-	for (auto &entry : gstate.collections) {
-		if (entry.type == RowGroupBatchType::NOT_FLUSHED) {
-			// this collection has not been flushed: add it to the merge set
-			if (!current_merger) {
-				current_merger = make_uniq<CollectionMerger>(context);
-			}
-			current_merger->AddCollection(std::move(entry.collection));
-		} else {
-			// this collection has been flushed: it does not need to be merged
-			// create a separate collection merger only for this entry
-			if (current_merger) {
-				// we have small collections remaining: flush them
-				mergers.push_back(std::move(current_merger));
-				current_merger.reset();
+	if (gstate.optimistically_written || gstate.insert_count >= LocalStorage::MERGE_THRESHOLD) {
+		// we have written data to disk optimistically or are inserting a large amount of data
+		// perform a final pass over all of the row groups and merge them together
+		vector<unique_ptr<CollectionMerger>> mergers;
+		unique_ptr<CollectionMerger> current_merger;
+
+		auto &storage = gstate.table.GetStorage();
+		for (auto &entry : gstate.collections) {
+			if (entry.type == RowGroupBatchType::NOT_FLUSHED) {
+				// this collection has not been flushed: add it to the merge set
+				if (!current_merger) {
+					current_merger = make_uniq<CollectionMerger>(context);
+				}
+				current_merger->AddCollection(std::move(entry.collection));
+			} else {
+				// this collection has been flushed: it does not need to be merged
+				// create a separate collection merger only for this entry
+				if (current_merger) {
+					// we have small collections remaining: flush them
+					mergers.push_back(std::move(current_merger));
+					current_merger.reset();
+				}
+				auto larger_merger = make_uniq<CollectionMerger>(context);
+				larger_merger->AddCollection(std::move(entry.collection));
+				mergers.push_back(std::move(larger_merger));
 			}
-			auto larger_merger = make_uniq<CollectionMerger>(context);
-			larger_merger->AddCollection(std::move(entry.collection));
-			mergers.push_back(std::move(larger_merger));
 		}
-	}
-	if (current_merger) {
-		mergers.push_back(std::move(current_merger));
-	}
+		if (current_merger) {
+			mergers.push_back(std::move(current_merger));
+		}
 
-	// now that we have created all of the mergers, perform the actual merging
-	vector<unique_ptr<RowGroupCollection>> final_collections;
-	final_collections.reserve(mergers.size());
-	auto &writer = storage.CreateOptimisticWriter(context);
-	for (auto &merger : mergers) {
-		final_collections.push_back(merger->Flush(writer));
-	}
-	storage.FinalizeOptimisticWriter(context, writer);
+		// now that we have created all of the mergers, perform the actual merging
+		vector<unique_ptr<RowGroupCollection>> final_collections;
+		final_collections.reserve(mergers.size());
+		auto &writer = storage.CreateOptimisticWriter(context);
+		for (auto &merger : mergers) {
+			final_collections.push_back(merger->Flush(writer));
+		}
+		storage.FinalizeOptimisticWriter(context, writer);
 
-	// finally, merge the row groups into the local storage
-	for (auto &collection : final_collections) {
-		storage.LocalMerge(context, *collection);
+		// finally, merge the row groups into the local storage
+		for (auto &collection : final_collections) {
+			storage.LocalMerge(context, *collection);
+		}
+	} else {
+		// we are writing a small amount of data to disk
+		// append directly to transaction local storage
+		auto &table = gstate.table;
+		auto &storage = table.GetStorage();
+		LocalAppendState append_state;
+		storage.InitializeLocalAppend(append_state, context);
+		auto &transaction = DuckTransaction::Get(context, table.catalog);
+		for (auto &entry : gstate.collections) {
+			entry.collection->Scan(transaction, [&](DataChunk &insert_chunk) {
+				storage.LocalAppend(append_state, table, context, insert_chunk);
+				return true;
+			});
+		}
+		storage.FinalizeLocalAppend(append_state);
 	}
 	return SinkFinalizeType::READY;
 }

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -187,9 +187,14 @@ string PragmaStorageInfo(ClientContext &context, const FunctionParameters &param
 	return StringUtil::Format("SELECT * FROM pragma_storage_info('%s');", parameters.values[0].ToString());
 }
 
+string PragmaMetadataInfo(ClientContext &context, const FunctionParameters &parameters) {
+	return "SELECT * FROM pragma_metadata_info();";
+}
+
 void PragmaQueries::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(PragmaFunction::PragmaCall("table_info", PragmaTableInfo, {LogicalType::VARCHAR}));
 	set.AddFunction(PragmaFunction::PragmaCall("storage_info", PragmaStorageInfo, {LogicalType::VARCHAR}));
+	set.AddFunction(PragmaFunction::PragmaCall("metadata_info", PragmaMetadataInfo, {}));
 	set.AddFunction(PragmaFunction::PragmaStatement("show_tables", PragmaShowTables));
 	set.AddFunction(PragmaFunction::PragmaStatement("show_tables_expanded", PragmaShowTablesExpanded));
 	set.AddFunction(PragmaFunction::PragmaStatement("show_databases", PragmaShowDatabases));

package/src/duckdb/src/function/table/arrow.cpp

@@ -208,18 +208,10 @@ void ArrowTableFunction::RenameArrowColumns(vector<string> &names) {
 	}
 }
 
-unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &context, TableFunctionBindInput &input,
-                                                           vector<LogicalType> &return_types, vector<string> &names) {
-	auto stream_factory_ptr = input.inputs[0].GetPointer();
-	auto stream_factory_produce = (stream_factory_produce_t)input.inputs[1].GetPointer();       // NOLINT
-	auto stream_factory_get_schema = (stream_factory_get_schema_t)input.inputs[2].GetPointer(); // NOLINT
-
-	auto res = make_uniq<ArrowScanFunctionData>(stream_factory_produce, stream_factory_ptr);
-
-	auto &data = *res;
-	stream_factory_get_schema(stream_factory_ptr, data.schema_root);
-	for (idx_t col_idx = 0; col_idx < (idx_t)data.schema_root.arrow_schema.n_children; col_idx++) {
-		auto &schema = *data.schema_root.arrow_schema.children[col_idx];
+void ArrowTableFunction::PopulateArrowTableType(ArrowTableType &arrow_table, ArrowSchemaWrapper &schema_p,
+                                                vector<string> &names, vector<LogicalType> &return_types) {
+	for (idx_t col_idx = 0; col_idx < (idx_t)schema_p.arrow_schema.n_children; col_idx++) {
+		auto &schema = *schema_p.arrow_schema.children[col_idx];
 		if (!schema.release) {
 			throw InvalidInputException("arrow_scan: released schema passed");
 		}
@@ -233,7 +225,7 @@ unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &contex
 		} else {
 			return_types.emplace_back(arrow_type->GetDuckType());
 		}
-		res->arrow_table.AddColumn(col_idx, std::move(arrow_type));
+		arrow_table.AddColumn(col_idx, std::move(arrow_type));
 		auto format = string(schema.format);
 		auto name = string(schema.name);
 		if (name.empty()) {
@@ -241,6 +233,19 @@ unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &contex
 		}
 		names.push_back(name);
 	}
+}
+
+unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &context, TableFunctionBindInput &input,
+                                                           vector<LogicalType> &return_types, vector<string> &names) {
+	auto stream_factory_ptr = input.inputs[0].GetPointer();
+	auto stream_factory_produce = (stream_factory_produce_t)input.inputs[1].GetPointer();       // NOLINT
+	auto stream_factory_get_schema = (stream_factory_get_schema_t)input.inputs[2].GetPointer(); // NOLINT
+
+	auto res = make_uniq<ArrowScanFunctionData>(stream_factory_produce, stream_factory_ptr);
+
+	auto &data = *res;
+	stream_factory_get_schema(stream_factory_ptr, data.schema_root);
+	PopulateArrowTableType(res->arrow_table, data.schema_root, names, return_types);
 	RenameArrowColumns(names);
 	res->all_types = return_types;
 	return std::move(res);

package/src/duckdb/src/function/table/system/pragma_metadata_info.cpp

@@ -0,0 +1,83 @@
+#include "duckdb/function/table/system_functions.hpp"
+
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/storage/database_size.hpp"
+#include "duckdb/main/database_manager.hpp"
+#include "duckdb/function/function_set.hpp"
+namespace duckdb {
+
+struct PragmaMetadataFunctionData : public TableFunctionData {
+	explicit PragmaMetadataFunctionData() {
+	}
+
+	vector<MetadataBlockInfo> metadata_info;
+};
+
+struct PragmaMetadataOperatorData : public GlobalTableFunctionState {
+	PragmaMetadataOperatorData() : offset(0) {
+	}
+
+	idx_t offset;
+};
+
+static unique_ptr<FunctionData> PragmaMetadataInfoBind(ClientContext &context, TableFunctionBindInput &input,
+                                                       vector<LogicalType> &return_types, vector<string> &names) {
+	names.emplace_back("block_id");
+	return_types.emplace_back(LogicalType::BIGINT);
+
+	names.emplace_back("total_blocks");
+	return_types.emplace_back(LogicalType::BIGINT);
+
+	names.emplace_back("free_blocks");
+	return_types.emplace_back(LogicalType::BIGINT);
+
+	names.emplace_back("free_list");
+	return_types.emplace_back(LogicalType::LIST(LogicalType::BIGINT));
+
+	string db_name =
+	    input.inputs.empty() ? DatabaseManager::GetDefaultDatabase(context) : StringValue::Get(input.inputs[0]);
+	auto &catalog = Catalog::GetCatalog(context, db_name);
+	auto result = make_uniq<PragmaMetadataFunctionData>();
+	result->metadata_info = catalog.GetMetadataInfo(context);
+	return std::move(result);
+}
+
+unique_ptr<GlobalTableFunctionState> PragmaMetadataInfoInit(ClientContext &context, TableFunctionInitInput &input) {
+	return make_uniq<PragmaMetadataOperatorData>();
+}
+
+static void PragmaMetadataInfoFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = data_p.bind_data->Cast<PragmaMetadataFunctionData>();
+	auto &data = data_p.global_state->Cast<PragmaMetadataOperatorData>();
+	idx_t count = 0;
+	while (data.offset < bind_data.metadata_info.size() && count < STANDARD_VECTOR_SIZE) {
+		auto &entry = bind_data.metadata_info[data.offset++];
+
+		idx_t col_idx = 0;
+		// block_id
+		output.SetValue(col_idx++, count, Value::BIGINT(entry.block_id));
+		// total_blocks
+		output.SetValue(col_idx++, count, Value::BIGINT(entry.total_blocks));
+		// free_blocks
+		output.SetValue(col_idx++, count, Value::BIGINT(entry.free_list.size()));
+		// free_list
+		vector<Value> list_values;
+		for (auto &free_id : entry.free_list) {
+			list_values.push_back(Value::BIGINT(free_id));
+		}
+		output.SetValue(col_idx++, count, Value::LIST(LogicalType::BIGINT, std::move(list_values)));
+		count++;
+	}
+	output.SetCardinality(count);
+}
+
+void PragmaMetadataInfo::RegisterFunction(BuiltinFunctions &set) {
+	TableFunctionSet metadata_info("pragma_metadata_info");
+	metadata_info.AddFunction(
+	    TableFunction({}, PragmaMetadataInfoFunction, PragmaMetadataInfoBind, PragmaMetadataInfoInit));
+	metadata_info.AddFunction(TableFunction({LogicalType::VARCHAR}, PragmaMetadataInfoFunction, PragmaMetadataInfoBind,
+	                                        PragmaMetadataInfoInit));
+	set.AddFunction(metadata_info);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/table/system/pragma_storage_info.cpp

@@ -76,6 +76,9 @@ static unique_ptr<FunctionData> PragmaStorageInfoBind(ClientContext &context, Ta
 	names.emplace_back("block_offset");
 	return_types.emplace_back(LogicalType::BIGINT);
 
+	names.emplace_back("segment_info");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
 	auto qname = QualifiedName::Parse(input.inputs[0].GetValue<string>());
 
 	// look up the table name in the catalog
@@ -133,6 +136,8 @@ static void PragmaStorageInfoFunction(ClientContext &context, TableFunctionInput
 			output.SetValue(col_idx++, count, Value());
 			output.SetValue(col_idx++, count, Value());
 		}
+		// segment_info
+		output.SetValue(col_idx++, count, Value(entry.segment_info));
 		count++;
 	}
 	output.SetCardinality(count);

package/src/duckdb/src/function/table/system_functions.cpp

@@ -14,6 +14,7 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 	PragmaCollations::RegisterFunction(*this);
 	PragmaTableInfo::RegisterFunction(*this);
 	PragmaStorageInfo::RegisterFunction(*this);
+	PragmaMetadataInfo::RegisterFunction(*this);
 	PragmaDatabaseSize::RegisterFunction(*this);
 	PragmaLastProfilingOutput::RegisterFunction(*this);
 	PragmaDetailedProfilingOutput::RegisterFunction(*this);

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev4474"
+#define DUCKDB_VERSION "0.8.2-dev4572"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "ba71015ee7"
+#define DUCKDB_SOURCE_ID "53dc13de5c"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -34,6 +34,7 @@ struct CreateIndexInfo;
 struct CreateTypeInfo;
 struct CreateTableInfo;
 struct DatabaseSize;
+struct MetadataBlockInfo;
 
 class AttachedDatabase;
 class ClientContext;
@@ -266,6 +267,7 @@ public:
 	                                                    unique_ptr<LogicalOperator> plan) = 0;
 
 	virtual DatabaseSize GetDatabaseSize(ClientContext &context) = 0;
+	virtual vector<MetadataBlockInfo> GetMetadataInfo(ClientContext &context);
 
 	virtual bool InMemory() = 0;
 	virtual string GetDBPath() = 0;

package/src/duckdb/src/include/duckdb/catalog/duck_catalog.hpp

@@ -54,6 +54,7 @@ public:
 	                                                       unique_ptr<LogicalOperator> plan) override;
 
 	DatabaseSize GetDatabaseSize(ClientContext &context) override;
+	vector<MetadataBlockInfo> GetMetadataInfo(ClientContext &context) override;
 
 	DUCKDB_API bool InMemory() override;
 	DUCKDB_API string GetDBPath() override;

package/src/duckdb/src/include/duckdb/common/serializer/deserialization_data.hpp

@@ -15,10 +15,12 @@
 namespace duckdb {
 class ClientContext;
 class Catalog;
+class DatabaseInstance;
 enum class ExpressionType : uint8_t;
 
 struct DeserializationData {
 	stack<reference<ClientContext>> contexts;
+	stack<reference<DatabaseInstance>> databases;
 	stack<idx_t> enums;
 	stack<reference<bound_parameter_map_t>> parameter_data;
 	stack<reference<LogicalType>> types;
@@ -74,6 +76,23 @@ inline void DeserializationData::Unset<LogicalOperatorType>() {
 	enums.pop();
 }
 
+template <>
+inline void DeserializationData::Set(CompressionType type) {
+	enums.push(idx_t(type));
+}
+
+template <>
+inline CompressionType DeserializationData::Get() {
+	AssertNotEmpty(enums);
+	return CompressionType(enums.top());
+}
+
+template <>
+inline void DeserializationData::Unset<CompressionType>() {
+	AssertNotEmpty(enums);
+	enums.pop();
+}
+
 template <>
 inline void DeserializationData::Set(CatalogType type) {
 	enums.push(idx_t(type));
@@ -108,6 +127,23 @@ inline void DeserializationData::Unset<ClientContext>() {
 	contexts.pop();
 }
 
+template <>
+inline void DeserializationData::Set(DatabaseInstance &db) {
+	databases.push(db);
+}
+
+template <>
+inline DatabaseInstance &DeserializationData::Get() {
+	AssertNotEmpty(databases);
+	return databases.top();
+}
+
+template <>
+inline void DeserializationData::Unset<DatabaseInstance>() {
+	AssertNotEmpty(databases);
+	databases.pop();
+}
+
 template <>
 inline void DeserializationData::Set(bound_parameter_map_t &context) {
 	parameter_data.push(context);