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

package/binding.gyp

@@ -133,7 +133,6 @@
                 "src/duckdb/ub_src_planner_expression_binder.cpp", 
                 "src/duckdb/ub_src_planner_filter.cpp", 
                 "src/duckdb/ub_src_planner_operator.cpp", 
-                "src/duckdb/ub_src_planner_parsed_data.cpp", 
                 "src/duckdb/ub_src_planner_subquery.cpp", 
                 "src/duckdb/ub_src_storage.cpp", 
                 "src/duckdb/ub_src_storage_buffer.cpp", 
@@ -147,7 +146,6 @@
                 "src/duckdb/ub_src_transaction.cpp", 
                 "src/duckdb/src/verification/copied_statement_verifier.cpp", 
                 "src/duckdb/src/verification/deserialized_statement_verifier.cpp", 
-                "src/duckdb/src/verification/deserialized_statement_verifier_v2.cpp", 
                 "src/duckdb/src/verification/external_statement_verifier.cpp", 
                 "src/duckdb/src/verification/no_operator_caching_verifier.cpp", 
                 "src/duckdb/src/verification/parsed_statement_verifier.cpp", 

package/lib/duckdb.js

@@ -1,6 +1,6 @@
 /**
  * @module duckdb
- * @summary these jsdoc annotations are still a work in progress - feedback and suggestions are welcome!
+ * @summary DuckDB is an embeddable SQL OLAP Database Management System
  */
 
 var duckdb = require('./duckdb-binding.js');
@@ -441,7 +441,7 @@ Database.prototype.close_internal;
 Database.prototype.wait;
 
 /**
- * TODO: what does this do?
+ * Currently a no-op. Provided for SQLite compatibility
  * @method
  * @param callback
  * @return {void}
@@ -449,7 +449,7 @@ Database.prototype.wait;
 Database.prototype.serialize;
 
 /**
- * TODO: what does this do?
+ * Currently a no-op. Provided for SQLite compatibility
  * @method
  * @param callback
  * @return {void}

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev4126.0",
+  "version": "0.8.2-dev4203.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/connection.cpp

@@ -9,9 +9,7 @@
 
 namespace node_duckdb {
 
-Napi::FunctionReference Connection::constructor;
-
-Napi::Object Connection::Init(Napi::Env env, Napi::Object exports) {
+Napi::FunctionReference Connection::Init(Napi::Env env, Napi::Object exports) {
 	Napi::HandleScope scope(env);
 
 	Napi::Function t =
@@ -22,11 +20,9 @@ Napi::Object Connection::Init(Napi::Env env, Napi::Object exports) {
 	                 InstanceMethod("unregister_udf", &Connection::UnregisterUdf),
 	                 InstanceMethod("unregister_buffer", &Connection::UnRegisterBuffer)});
 
-	constructor = Napi::Persistent(t);
-	constructor.SuppressDestruct();
-
 	exports.Set("Connection", t);
-	return exports;
+
+	return Napi::Persistent(t);
 }
 
 struct ConnectTask : public Task {
@@ -103,7 +99,8 @@ Napi::Value Connection::Prepare(const Napi::CallbackInfo &info) {
 	for (size_t i = 0; i < info.Length(); i++) {
 		args.push_back(info[i]);
 	}
-	auto res = Utils::NewUnwrap<Statement>(args);
+	auto obj = Statement::NewInstance(info.Env(), args);
+	auto res = Statement::Unwrap(obj);
 	res->SetProcessFirstParam();
 	return res->Value();
 }
@@ -515,4 +512,8 @@ Napi::Value Connection::UnRegisterBuffer(const Napi::CallbackInfo &info) {
 	return Value();
 }
 
+Napi::Object Connection::NewInstance(const Napi::Value &db) {
+	return NodeDuckDB::GetData(db.Env())->connection_constructor.New({db});
+}
+
 } // namespace node_duckdb

package/src/database.cpp

@@ -10,9 +10,7 @@
 
 namespace node_duckdb {
 
-Napi::FunctionReference Database::constructor;
-
-Napi::Object Database::Init(Napi::Env env, Napi::Object exports) {
+Napi::FunctionReference Database::Init(Napi::Env env, Napi::Object exports) {
 	Napi::HandleScope scope(env);
 
 	Napi::Function t = DefineClass(
@@ -22,11 +20,9 @@ Napi::Object Database::Init(Napi::Env env, Napi::Object exports) {
 	     InstanceMethod("connect", &Database::Connect), InstanceMethod("interrupt", &Database::Interrupt),
 	     InstanceMethod("registerReplacementScan", &Database::RegisterReplacementScan)});
 
-	constructor = Napi::Persistent(t);
-	constructor.SuppressDestruct();
-
 	exports.Set("Database", t);
-	return exports;
+
+	return Napi::Persistent(t);
 }
 
 struct OpenTask : public Task {
@@ -266,7 +262,8 @@ Napi::Value Database::Interrupt(const Napi::CallbackInfo &info) {
 }
 
 Napi::Value Database::Connect(const Napi::CallbackInfo &info) {
-	return Connection::constructor.New({Value()});
+	Napi::HandleScope scope(env);
+	return Connection::NewInstance(Value());
 }
 
 struct JSRSArgs {

package/src/duckdb/extension/icu/icu-datepart.cpp

@@ -543,12 +543,12 @@ struct ICUDatePart : public ICUDateFunc {
 		return make_uniq<BindStructData>(context, part_codes, bigints, doubles);
 	}
 
-	static void SerializeFunction(FieldWriter &writer, const FunctionData *bind_data_p,
+	static void SerializeFunction(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
 	                              const ScalarFunction &function) {
 		throw NotImplementedException("FIXME: serialize icu-datepart");
 	}
 
-	static duckdb::unique_ptr<FunctionData> DeserializeFunction(PlanDeserializationState &state, FieldReader &reader,
+	static duckdb::unique_ptr<FunctionData> DeserializeFunction(Deserializer &deserializer,
 	                                                            ScalarFunction &bound_function) {
 		throw NotImplementedException("FIXME: serialize icu-datepart");
 	}

package/src/duckdb/extension/icu/icu-strptime.cpp

@@ -48,15 +48,6 @@ struct ICUStrptime : public ICUDateFunc {
 		duckdb::unique_ptr<FunctionData> Copy() const override {
 			return make_uniq<ICUStrptimeBindData>(*this);
 		}
-
-		static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
-			throw NotImplementedException("FIXME: serialize icu-strptime");
-		}
-
-		static duckdb::unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
-		                                                    ScalarFunction &bound_function) {
-			throw NotImplementedException("FIXME: serialize icu-strptime");
-		}
 	};
 
 	static void ParseFormatSpecifier(string_t &format_specifier, StrpTimeFormat &format) {

package/src/duckdb/extension/icu/icu_extension.cpp

@@ -136,12 +136,12 @@ static duckdb::unique_ptr<FunctionData> ICUSortKeyBind(ClientContext &context, S
 	}
 }
 
-static void ICUCollateSerialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
+static void ICUCollateSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
+                                const ScalarFunction &function) {
 	throw NotImplementedException("FIXME: serialize icu-collate");
 }
 
-static duckdb::unique_ptr<FunctionData> ICUCollateDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                              ScalarFunction &bound_function) {
+static duckdb::unique_ptr<FunctionData> ICUCollateDeserialize(Deserializer &deserializer, ScalarFunction &function) {
 	throw NotImplementedException("FIXME: serialize icu-collate");
 }
 

package/src/duckdb/extension/icu/third_party/icu/i18n/unicode/gregocal.h

@@ -141,7 +141,7 @@ U_NAMESPACE_BEGIN
  *     cout << "DST_OFFSET: " << (calendar->get( UCAL_DST_OFFSET, success )/(60*60*1000)) << endl; // in hours
  *
  *     if (U_FAILURE(success)) {
- *         cout << "An error occured. success=" << u_errorName(success) << endl;
+ *         cout << "An error occurred. success=" << u_errorName(success) << endl;
  *     }
  *
  *     delete ids;

package/src/duckdb/extension/json/buffered_json_reader.cpp

@@ -1,28 +1,14 @@
 #include "buffered_json_reader.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/file_opener.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/printer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 #include <utility>
 
 namespace duckdb {
 
-void BufferedJSONReaderOptions::Serialize(FieldWriter &writer) const {
-	writer.WriteField<JSONFormat>(format);
-	writer.WriteField<JSONRecordType>(record_type);
-	writer.WriteField<FileCompressionType>(compression);
-	writer.WriteSerializable(file_options);
-}
-
-void BufferedJSONReaderOptions::Deserialize(FieldReader &reader) {
-	format = reader.ReadRequired<JSONFormat>();
-	record_type = reader.ReadRequired<JSONRecordType>();
-	compression = reader.ReadRequired<FileCompressionType>();
-	file_options = reader.ReadRequiredSerializable<MultiFileReaderOptions, MultiFileReaderOptions>();
-}
-
 JSONBufferHandle::JSONBufferHandle(idx_t buffer_index_p, idx_t readers_p, AllocatedData &&buffer_p, idx_t buffer_size_p)
     : buffer_index(buffer_index_p), readers(readers_p), buffer(std::move(buffer_p)), buffer_size(buffer_size_p) {
 }

package/src/duckdb/extension/json/include/buffered_json_reader.hpp

@@ -31,11 +31,8 @@ public:
 	MultiFileReaderOptions file_options;
 
 public:
-	void Serialize(FieldWriter &writer) const;
-	void Deserialize(FieldReader &reader);
-
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static BufferedJSONReaderOptions FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static BufferedJSONReaderOptions Deserialize(Deserializer &deserializer);
 };
 
 struct JSONBufferHandle {

package/src/duckdb/extension/json/include/json_deserializer.hpp

@@ -1,10 +1,10 @@
 #pragma once
 #include "json_common.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
-class JsonDeserializer : public FormatDeserializer {
+class JsonDeserializer : public Deserializer {
 public:
 	JsonDeserializer(yyjson_val *val, yyjson_doc *doc) : doc(doc) {
 		deserialize_enum_from_string = true;

package/src/duckdb/extension/json/include/json_scan.hpp

@@ -92,11 +92,8 @@ public:
 	void InitializeFormats(bool auto_detect);
 	void SetCompression(const string &compression);
 
-	void Serialize(FieldWriter &writer) const;
-	void Deserialize(ClientContext &context, FieldReader &reader);
-
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static unique_ptr<JSONScanData> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<JSONScanData> Deserialize(Deserializer &deserializer);
 
 public:
 	//! Scan type
@@ -294,13 +291,9 @@ public:
 	static void ComplexFilterPushdown(ClientContext &context, LogicalGet &get, FunctionData *bind_data_p,
 	                                  vector<unique_ptr<Expression>> &filters);
 
-	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const TableFunction &function);
-	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
-	                                            TableFunction &function);
-
-	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data,
-	                            const TableFunction &function);
-	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, TableFunction &function);
+	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
+	                      const TableFunction &function);
+	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, TableFunction &function);
 
 	static void TableFunctionDefaults(TableFunction &table_function);
 };

package/src/duckdb/extension/json/include/json_serializer.hpp

@@ -1,11 +1,11 @@
 #pragma once
 
 #include "json_common.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
 
 namespace duckdb {
 
-struct JsonSerializer : FormatSerializer {
+struct JsonSerializer : Serializer {
 private:
 	yyjson_mut_doc *doc;
 	yyjson_mut_val *current_tag;
@@ -34,7 +34,7 @@ public:
 	template <class T>
 	static yyjson_mut_val *Serialize(T &value, yyjson_mut_doc *doc, bool skip_if_null, bool skip_if_empty) {
 		JsonSerializer serializer(doc, skip_if_null, skip_if_empty);
-		value.FormatSerialize(serializer);
+		value.Serialize(serializer);
 		return serializer.GetRootObject();
 	}
 

package/src/duckdb/extension/json/include/json_transform.hpp

@@ -42,11 +42,8 @@ public:
 	idx_t object_index = DConstants::INVALID_INDEX;
 
 public:
-	void Serialize(FieldWriter &writer) const;
-	void Deserialize(FieldReader &reader);
-
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static JSONTransformOptions FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static JSONTransformOptions Deserialize(Deserializer &deserializer);
 };
 
 struct TryParseDate {

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

@@ -184,7 +184,7 @@ static unique_ptr<SelectStatement> DeserializeSelectStatement(string_t input, yy
 	}
 	auto stmt_json = yyjson_arr_get(statements, 0);
 	JsonDeserializer deserializer(stmt_json, doc);
-	return SelectStatement::FormatDeserialize(deserializer);
+	return SelectStatement::Deserialize(deserializer);
 }
 
 //----------------------------------------------------------------------

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

@@ -8,8 +8,8 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "json_functions.hpp"
 #include "json_scan.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -22,22 +22,6 @@ JSONTransformOptions::JSONTransformOptions(bool strict_cast_p, bool error_duplic
       error_unknown_key(error_unkown_key_p) {
 }
 
-void JSONTransformOptions::Serialize(FieldWriter &writer) const {
-	writer.WriteField(strict_cast);
-	writer.WriteField(error_duplicate_key);
-	writer.WriteField(error_missing_key);
-	writer.WriteField(error_unknown_key);
-	writer.WriteField(delay_error);
-}
-
-void JSONTransformOptions::Deserialize(FieldReader &reader) {
-	strict_cast = reader.ReadRequired<bool>();
-	error_duplicate_key = reader.ReadRequired<bool>();
-	error_missing_key = reader.ReadRequired<bool>();
-	error_unknown_key = reader.ReadRequired<bool>();
-	delay_error = reader.ReadRequired<bool>();
-}
-
 //! Forward declaration for recursion
 static LogicalType StructureStringToType(yyjson_val *val, ClientContext &context);
 

package/src/duckdb/extension/json/json_scan.cpp

@@ -2,11 +2,11 @@
 
 #include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
 #include "duckdb/main/extension_helper.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -116,64 +116,6 @@ void JSONScanData::SetCompression(const string &compression) {
 	options.compression = EnumUtil::FromString<FileCompressionType>(StringUtil::Upper(compression));
 }
 
-void JSONScanData::Serialize(FieldWriter &writer) const {
-	writer.WriteField<JSONScanType>(type);
-
-	options.Serialize(writer);
-
-	writer.WriteSerializable(reader_bind);
-
-	writer.WriteList<string>(files);
-
-	writer.WriteField<bool>(ignore_errors);
-	writer.WriteField<idx_t>(maximum_object_size);
-	writer.WriteField<bool>(auto_detect);
-	writer.WriteField<idx_t>(sample_size);
-	writer.WriteField<idx_t>(max_depth);
-
-	transform_options.Serialize(writer);
-	writer.WriteList<string>(names);
-	if (!date_format.empty()) {
-		writer.WriteString(date_format);
-	} else if (date_format_map.HasFormats(LogicalTypeId::DATE)) {
-		writer.WriteString(date_format_map.GetFormat(LogicalTypeId::DATE).format_specifier);
-	} else {
-		writer.WriteString("");
-	}
-	if (!timestamp_format.empty()) {
-		writer.WriteString(timestamp_format);
-	} else if (date_format_map.HasFormats(LogicalTypeId::TIMESTAMP)) {
-		writer.WriteString(date_format_map.GetFormat(LogicalTypeId::TIMESTAMP).format_specifier);
-	} else {
-		writer.WriteString("");
-	}
-}
-
-void JSONScanData::Deserialize(ClientContext &context, FieldReader &reader) {
-	type = reader.ReadRequired<JSONScanType>();
-
-	options.Deserialize(reader);
-
-	reader_bind = reader.ReadRequiredSerializable<MultiFileReaderBindData, MultiFileReaderBindData>();
-
-	files = reader.ReadRequiredList<string>();
-	InitializeReaders(context);
-
-	ignore_errors = reader.ReadRequired<bool>();
-	maximum_object_size = reader.ReadRequired<idx_t>();
-	auto_detect = reader.ReadRequired<bool>();
-	sample_size = reader.ReadRequired<idx_t>();
-	max_depth = reader.ReadRequired<idx_t>();
-
-	transform_options.Deserialize(reader);
-	names = reader.ReadRequiredList<string>();
-	date_format = reader.ReadRequired<string>();
-	timestamp_format = reader.ReadRequired<string>();
-
-	InitializeFormats();
-	transform_options.date_format_map = &date_format_map;
-}
-
 string JSONScanData::GetDateFormat() const {
 	if (!date_format.empty()) {
 		return date_format;
@@ -988,26 +930,17 @@ void JSONScan::ComplexFilterPushdown(ClientContext &context, LogicalGet &get, Fu
 	}
 }
 
-void JSONScan::Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const TableFunction &) {
-	auto &bind_data = bind_data_p->Cast<JSONScanData>();
-	bind_data.Serialize(writer);
-}
-
-unique_ptr<FunctionData> JSONScan::Deserialize(PlanDeserializationState &state, FieldReader &reader, TableFunction &) {
-	auto result = make_uniq<JSONScanData>();
-	result->Deserialize(state.context, reader);
-	return std::move(result);
-}
-
-void JSONScan::FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                               const TableFunction &) {
+void JSONScan::Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p, const TableFunction &) {
 	auto &bind_data = bind_data_p->Cast<JSONScanData>();
 	serializer.WriteProperty(100, "scan_data", &bind_data);
 }
 
-unique_ptr<FunctionData> JSONScan::FormatDeserialize(FormatDeserializer &deserializer, TableFunction &) {
+unique_ptr<FunctionData> JSONScan::Deserialize(Deserializer &deserializer, TableFunction &) {
 	unique_ptr<JSONScanData> result;
 	deserializer.ReadProperty(100, "scan_data", result);
+	result->InitializeReaders(deserializer.Get<ClientContext &>());
+	result->InitializeFormats();
+	result->transform_options.date_format_map = &result->date_format_map;
 	return std::move(result);
 }
 
@@ -1025,8 +958,6 @@ void JSONScan::TableFunctionDefaults(TableFunction &table_function) {
 
 	table_function.serialize = Serialize;
 	table_function.deserialize = Deserialize;
-	table_function.format_serialize = FormatSerialize;
-	table_function.format_deserialize = FormatDeserialize;
 
 	table_function.projection_pushdown = true;
 	table_function.filter_pushdown = false;

package/src/duckdb/extension/json/serialize_json.cpp

@@ -3,22 +3,22 @@
 // Do not edit this file manually, your changes will be overwritten
 //===----------------------------------------------------------------------===//
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 #include "buffered_json_reader.hpp"
 #include "json_transform.hpp"
 #include "json_scan.hpp"
 
 namespace duckdb {
 
-void BufferedJSONReaderOptions::FormatSerialize(FormatSerializer &serializer) const {
+void BufferedJSONReaderOptions::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "format", format);
 	serializer.WriteProperty(101, "record_type", record_type);
 	serializer.WriteProperty(102, "compression", compression);
 	serializer.WriteProperty(103, "file_options", file_options);
 }
 
-BufferedJSONReaderOptions BufferedJSONReaderOptions::FormatDeserialize(FormatDeserializer &deserializer) {
+BufferedJSONReaderOptions BufferedJSONReaderOptions::Deserialize(Deserializer &deserializer) {
 	BufferedJSONReaderOptions result;
 	deserializer.ReadProperty(100, "format", result.format);
 	deserializer.ReadProperty(101, "record_type", result.record_type);
@@ -27,7 +27,7 @@ BufferedJSONReaderOptions BufferedJSONReaderOptions::FormatDeserialize(FormatDes
 	return result;
 }
 
-void JSONScanData::FormatSerialize(FormatSerializer &serializer) const {
+void JSONScanData::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "json_type", type);
 	serializer.WriteProperty(101, "options", options);
 	serializer.WriteProperty(102, "reader_bind", reader_bind);
@@ -43,7 +43,7 @@ void JSONScanData::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(112, "timestamp_format", GetTimestampFormat());
 }
 
-unique_ptr<JSONScanData> JSONScanData::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<JSONScanData> JSONScanData::Deserialize(Deserializer &deserializer) {
 	auto type = deserializer.ReadProperty<JSONScanType>(100, "json_type");
 	auto options = deserializer.ReadProperty<BufferedJSONReaderOptions>(101, "options");
 	auto reader_bind = deserializer.ReadProperty<MultiFileReaderBindData>(102, "reader_bind");
@@ -71,7 +71,7 @@ unique_ptr<JSONScanData> JSONScanData::FormatDeserialize(FormatDeserializer &des
 	return result;
 }
 
-void JSONTransformOptions::FormatSerialize(FormatSerializer &serializer) const {
+void JSONTransformOptions::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "strict_cast", strict_cast);
 	serializer.WriteProperty(101, "error_duplicate_key", error_duplicate_key);
 	serializer.WriteProperty(102, "error_missing_key", error_missing_key);
@@ -79,7 +79,7 @@ void JSONTransformOptions::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(104, "delay_error", delay_error);
 }
 
-JSONTransformOptions JSONTransformOptions::FormatDeserialize(FormatDeserializer &deserializer) {
+JSONTransformOptions JSONTransformOptions::Deserialize(Deserializer &deserializer) {
 	JSONTransformOptions result;
 	deserializer.ReadProperty(100, "strict_cast", result.strict_cast);
 	deserializer.ReadProperty(101, "error_duplicate_key", result.error_duplicate_key);