duckdb 0.8.2-dev4126.0 → 0.8.2-dev4203.0

package/src/duckdb/src/storage/write_ahead_log.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
 #include <cstring>
 
 namespace duckdb {
@@ -49,9 +50,11 @@ void WriteAheadLog::Delete() {
 // Write Entries
 //===--------------------------------------------------------------------===//
 void WriteAheadLog::WriteCheckpoint(MetaBlockPointer meta_block) {
-	writer->Write<WALType>(WALType::CHECKPOINT);
-	writer->Write<idx_t>(meta_block.block_pointer);
-	writer->Write<uint32_t>(meta_block.offset);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CHECKPOINT);
+	serializer.WriteProperty(101, "meta_block", meta_block);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -61,8 +64,11 @@ void WriteAheadLog::WriteCreateTable(const TableCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_TABLE);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_TABLE);
+	serializer.WriteProperty(101, "table", &entry);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -72,9 +78,12 @@ void WriteAheadLog::WriteDropTable(const TableCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_TABLE);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_TABLE);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -84,8 +93,11 @@ void WriteAheadLog::WriteCreateSchema(const SchemaCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_SCHEMA);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_SCHEMA);
+	serializer.WriteProperty(101, "schema", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -95,28 +107,37 @@ void WriteAheadLog::WriteCreateSequence(const SequenceCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_SEQUENCE);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_SEQUENCE);
+	serializer.WriteProperty(101, "sequence", &entry);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDropSequence(const SequenceCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_SEQUENCE);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_SEQUENCE);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteSequenceValue(const SequenceCatalogEntry &entry, SequenceValue val) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::SEQUENCE_VALUE);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
-	writer->Write<uint64_t>(val.usage_count);
-	writer->Write<int64_t>(val.counter);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::SEQUENCE_VALUE);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.WriteProperty(103, "usage_count", val.usage_count);
+	serializer.WriteProperty(104, "counter", val.counter);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -126,34 +147,46 @@ void WriteAheadLog::WriteCreateMacro(const ScalarMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_MACRO);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_MACRO);
+	serializer.WriteProperty(101, "macro", &entry);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDropMacro(const ScalarMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_MACRO);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_MACRO);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteCreateTableMacro(const TableMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_TABLE_MACRO);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_TABLE_MACRO);
+	serializer.WriteProperty(101, "table", &entry);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDropTableMacro(const TableMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_TABLE_MACRO);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_TABLE_MACRO);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -163,17 +196,23 @@ void WriteAheadLog::WriteCreateIndex(const IndexCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_INDEX);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_INDEX);
+	serializer.WriteProperty(101, "index", &entry);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDropIndex(const IndexCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_INDEX);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_INDEX);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -183,17 +222,23 @@ void WriteAheadLog::WriteCreateType(const TypeCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_TYPE);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_TYPE);
+	serializer.WriteProperty(101, "type", &entry);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDropType(const TypeCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_TYPE);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_TYPE);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -203,17 +248,23 @@ void WriteAheadLog::WriteCreateView(const ViewCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_VIEW);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_VIEW);
+	serializer.WriteProperty(101, "view", &entry);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDropView(const ViewCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_VIEW);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_VIEW);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -223,8 +274,11 @@ void WriteAheadLog::WriteDropSchema(const SchemaCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_SCHEMA);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_SCHEMA);
+	serializer.WriteProperty(101, "schema", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -234,9 +288,12 @@ void WriteAheadLog::WriteSetTable(string &schema, string &table) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::USE_TABLE);
-	writer->WriteString(schema);
-	writer->WriteString(table);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::USE_TABLE);
+	serializer.WriteProperty(101, "schema", schema);
+	serializer.WriteProperty(102, "table", table);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteInsert(DataChunk &chunk) {
@@ -246,8 +303,11 @@ void WriteAheadLog::WriteInsert(DataChunk &chunk) {
 	D_ASSERT(chunk.size() > 0);
 	chunk.Verify();
 
-	writer->Write<WALType>(WALType::INSERT_TUPLE);
-	chunk.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::INSERT_TUPLE);
+	serializer.WriteProperty(101, "chunk", chunk);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDelete(DataChunk &chunk) {
@@ -258,8 +318,11 @@ void WriteAheadLog::WriteDelete(DataChunk &chunk) {
 	D_ASSERT(chunk.ColumnCount() == 1 && chunk.data[0].GetType() == LogicalType::ROW_TYPE);
 	chunk.Verify();
 
-	writer->Write<WALType>(WALType::DELETE_TUPLE);
-	chunk.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DELETE_TUPLE);
+	serializer.WriteProperty(101, "chunk", chunk);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteUpdate(DataChunk &chunk, const vector<column_t> &column_indexes) {
@@ -271,23 +334,26 @@ void WriteAheadLog::WriteUpdate(DataChunk &chunk, const vector<column_t> &column
 	D_ASSERT(chunk.data[1].GetType().id() == LogicalType::ROW_TYPE);
 	chunk.Verify();
 
-	writer->Write<WALType>(WALType::UPDATE_TUPLE);
-	writer->Write<idx_t>(column_indexes.size());
-	for (auto &col_idx : column_indexes) {
-		writer->Write<column_t>(col_idx);
-	}
-	chunk.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::UPDATE_TUPLE);
+	serializer.WriteProperty(101, "column_indexes", column_indexes);
+	serializer.WriteProperty(102, "chunk", chunk);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
 // Write ALTER Statement
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteAlter(data_ptr_t ptr, idx_t data_size) {
+void WriteAheadLog::WriteAlter(const AlterInfo &info) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::ALTER_INFO);
-	writer->WriteData(ptr, data_size);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::ALTER_INFO);
+	serializer.WriteProperty(101, "info", &info);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -297,8 +363,13 @@ void WriteAheadLog::Flush() {
 	if (skip_writing) {
 		return;
 	}
+
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
 	// write an empty entry
-	writer->Write<WALType>(WALType::WAL_FLUSH);
+	serializer.WriteProperty(100, "wal_type", WALType::WAL_FLUSH);
+	serializer.End();
+
 	// flushes all changes made to the WAL to disk
 	writer->Sync();
 }

package/src/duckdb/src/transaction/commit_state.cpp

@@ -5,7 +5,6 @@
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/storage/table/chunk_info.hpp"
 #include "duckdb/storage/table/column_data.hpp"
@@ -17,6 +16,8 @@
 #include "duckdb/transaction/update_info.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
+#include "duckdb/common/serializer/memory_stream.hpp"
 
 namespace duckdb {
 
@@ -45,18 +46,23 @@ void CommitState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) {
 			auto &table_entry = entry.Cast<DuckTableEntry>();
 			D_ASSERT(table_entry.IsDuckTable());
 			// ALTER TABLE statement, read the extra data after the entry
+
 			auto extra_data_size = Load<idx_t>(dataptr);
 			auto extra_data = data_ptr_cast(dataptr + sizeof(idx_t));
 
-			BufferedDeserializer source(extra_data, extra_data_size);
-			string column_name = source.Read<string>();
+			MemoryStream source(extra_data, extra_data_size);
+			BinaryDeserializer deserializer(source);
+			deserializer.Begin();
+			auto column_name = deserializer.ReadProperty<string>(100, "column_name");
+			auto parse_info = deserializer.ReadProperty<unique_ptr<ParseInfo>>(101, "alter_info");
+			deserializer.End();
 
 			if (!column_name.empty()) {
 				// write the alter table in the log
 				table_entry.CommitAlter(column_name);
 			}
-
-			log->WriteAlter(source.ptr, source.endptr - source.ptr);
+			auto &alter_info = parse_info->Cast<AlterInfo>();
+			log->WriteAlter(alter_info);
 		} else {
 			// CREATE TABLE statement
 			log->WriteCreateTable(parent->Cast<TableCatalogEntry>());
@@ -75,10 +81,18 @@ void CommitState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) {
 			auto extra_data_size = Load<idx_t>(dataptr);
 			auto extra_data = data_ptr_cast(dataptr + sizeof(idx_t));
 			// deserialize it
-			BufferedDeserializer source(extra_data, extra_data_size);
-			string column_name = source.Read<string>();
+			MemoryStream source(extra_data, extra_data_size);
+			BinaryDeserializer deserializer(source);
+			deserializer.Begin();
+			auto column_name = deserializer.ReadProperty<string>(100, "column_name");
+			auto parse_info = deserializer.ReadProperty<unique_ptr<ParseInfo>>(101, "alter_info");
+			deserializer.End();
+
+			(void)column_name;
+
 			// write the alter table in the log
-			log->WriteAlter(source.ptr, source.endptr - source.ptr);
+			auto &alter_info = parse_info->Cast<AlterInfo>();
+			log->WriteAlter(alter_info);
 		} else {
 			log->WriteCreateView(parent->Cast<ViewCatalogEntry>());
 		}

package/src/duckdb/src/verification/deserialized_statement_verifier.cpp

@@ -1,7 +1,8 @@
 #include "duckdb/verification/deserialized_statement_verifier.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
+
 #include "duckdb/common/serializer/binary_deserializer.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/common/serializer/memory_stream.hpp"
 namespace duckdb {
 
 DeserializedStatementVerifier::DeserializedStatementVerifier(unique_ptr<SQLStatement> statement_p)
@@ -9,11 +10,15 @@ DeserializedStatementVerifier::DeserializedStatementVerifier(unique_ptr<SQLState
 }
 
 unique_ptr<StatementVerifier> DeserializedStatementVerifier::Create(const SQLStatement &statement) {
+
 	auto &select_stmt = statement.Cast<SelectStatement>();
-	BufferedSerializer serializer;
-	select_stmt.Serialize(serializer);
-	BufferedDeserializer source(serializer);
-	return make_uniq<DeserializedStatementVerifier>(SelectStatement::Deserialize(source));
+
+	MemoryStream stream;
+	BinarySerializer::Serialize(select_stmt, stream);
+	stream.Rewind();
+	auto result = BinaryDeserializer::Deserialize<SelectStatement>(stream);
+
+	return make_uniq<DeserializedStatementVerifier>(std::move(result));
 }
 
 } // namespace duckdb

package/src/duckdb/src/verification/statement_verifier.cpp

@@ -5,7 +5,6 @@
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/verification/copied_statement_verifier.hpp"
 #include "duckdb/verification/deserialized_statement_verifier.hpp"
-#include "duckdb/verification/deserialized_statement_verifier_v2.hpp"
 #include "duckdb/verification/external_statement_verifier.hpp"
 #include "duckdb/verification/parsed_statement_verifier.hpp"
 #include "duckdb/verification/prepared_statement_verifier.hpp"
@@ -33,10 +32,6 @@ unique_ptr<StatementVerifier> StatementVerifier::Create(VerificationType type, c
 		return CopiedStatementVerifier::Create(statement_p);
 	case VerificationType::DESERIALIZED:
 		return DeserializedStatementVerifier::Create(statement_p);
-	case VerificationType::DESERIALIZED_V2:
-		return DeserializedStatementVerifierV2::Create(statement_p);
-	case VerificationType::DESERIALIZED_V2_NO_DEFAULT:
-		return DeserializedStatementVerifierNoDefaultV2::Create(statement_p);
 	case VerificationType::PARSED:
 		return ParsedStatementVerifier::Create(statement_p);
 	case VerificationType::UNOPTIMIZED:

package/src/duckdb/third_party/parquet/parquet_types.h

@@ -101,7 +101,7 @@ extern const std::map<int, const char*> _Encoding_VALUES_TO_NAMES;
 std::ostream& operator<<(std::ostream& out, const Encoding::type& val);
 
 struct CompressionCodec {
-  enum type {
+  enum type : uint8_t {
     UNCOMPRESSED = 0,
     SNAPPY = 1,
     GZIP = 2,

package/src/duckdb/ub_src_common.cpp

@@ -20,8 +20,6 @@
 
 #include "src/common/extra_type_info.cpp"
 
-#include "src/common/field_writer.cpp"
-
 #include "src/common/file_buffer.cpp"
 
 #include "src/common/file_system.cpp"
@@ -52,8 +50,6 @@
 
 #include "src/common/random_engine.cpp"
 
-#include "src/common/serializer.cpp"
-
 #include "src/common/string_util.cpp"
 
 #include "src/common/enum_util.cpp"

package/src/duckdb/ub_src_common_serializer.cpp

@@ -2,13 +2,11 @@
 
 #include "src/common/serializer/binary_deserializer.cpp"
 
-#include "src/common/serializer/buffered_deserializer.cpp"
-
 #include "src/common/serializer/buffered_file_reader.cpp"
 
 #include "src/common/serializer/buffered_file_writer.cpp"
 
-#include "src/common/serializer/buffered_serializer.cpp"
+#include "src/common/serializer/memory_stream.cpp"
 
-#include "src/common/serializer/format_serializer.cpp"
+#include "src/common/serializer/serializer.cpp"
 

package/src/duckdb/ub_src_planner.cpp

@@ -18,8 +18,6 @@
 
 #include "src/planner/planner.cpp"
 
-#include "src/planner/plan_serialization.cpp"
-
 #include "src/planner/pragma_handler.cpp"
 
 #include "src/planner/logical_operator_visitor.cpp"

package/src/duckdb/ub_src_planner_expression.cpp

@@ -16,8 +16,6 @@
 
 #include "src/planner/expression/bound_constant_expression.cpp"
 
-#include "src/planner/expression/bound_default_expression.cpp"
-
 #include "src/planner/expression/bound_function_expression.cpp"
 
 #include "src/planner/expression/bound_lambda_expression.cpp"

package/src/duckdb/ub_src_planner_operator.cpp

@@ -30,12 +30,6 @@
 
 #include "src/planner/operator/logical_empty_result.cpp"
 
-#include "src/planner/operator/logical_execute.cpp"
-
-#include "src/planner/operator/logical_explain.cpp"
-
-#include "src/planner/operator/logical_export.cpp"
-
 #include "src/planner/operator/logical_expression_get.cpp"
 
 #include "src/planner/operator/logical_extension_operator.cpp"
@@ -76,8 +70,6 @@
 
 #include "src/planner/operator/logical_set_operation.cpp"
 
-#include "src/planner/operator/logical_show.cpp"
-
 #include "src/planner/operator/logical_simple.cpp"
 
 #include "src/planner/operator/logical_top_n.cpp"

package/src/duckdb_node.cpp

@@ -4,15 +4,13 @@
 	Napi::PropertyDescriptor::Value(#name, Napi::Number::New(env, constant),                                           \
 	                                static_cast<napi_property_attributes>(napi_enumerable | napi_configurable)),
 
-namespace {
-
-Napi::Object RegisterModule(Napi::Env env, Napi::Object exports) {
+NodeDuckDB::NodeDuckDB(Napi::Env env, Napi::Object exports) {
 	Napi::HandleScope scope(env);
 
-	node_duckdb::Database::Init(env, exports);
-	node_duckdb::Connection::Init(env, exports);
-	node_duckdb::Statement::Init(env, exports);
-	node_duckdb::QueryResult::Init(env, exports);
+	database_constructor = node_duckdb::Database::Init(env, exports);
+	connection_constructor = node_duckdb::Connection::Init(env, exports);
+	statement_constructor = node_duckdb::Statement::Init(env, exports);
+	query_result_constructor = node_duckdb::QueryResult::Init(env, exports);
 
 	exports.DefineProperties({
 	    DEFINE_CONSTANT_INTEGER(exports, node_duckdb::Database::DUCKDB_NODEJS_ERROR, ERROR) DEFINE_CONSTANT_INTEGER(
@@ -23,10 +21,6 @@ Napi::Object RegisterModule(Napi::Env env, Napi::Object exports) {
 	    DEFINE_CONSTANT_INTEGER(exports, 0, OPEN_SHAREDCACHE)                      // ignored
 	    DEFINE_CONSTANT_INTEGER(exports, 0, OPEN_PRIVATECACHE)                     // ignored
 	});
-
-	return exports;
 }
 
-} // namespace
-
-NODE_API_MODULE(node_duckdb, RegisterModule);
+NODE_API_ADDON(NodeDuckDB);