duckdb 0.8.2-dev2809.0 → 0.8.2-dev2850.0

package/package.json

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

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

@@ -48,7 +48,7 @@ private:
 	void ThrowTypeError(yyjson_val *val, const char *expected);
 
 	// Set the 'tag' of the property to read
-	void SetTag(const char *tag) final;
+	void SetTag(const field_id_t, const char *tag) final;
 
 	//===--------------------------------------------------------------------===//
 	// Nested Types Hooks

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

@@ -42,7 +42,7 @@ public:
 		return stack.front();
 	};
 
-	void SetTag(const char *tag) final;
+	void SetTag(const field_id_t, const char *tag) final;
 
 	//===--------------------------------------------------------------------===//
 	// Nested Types Hooks

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

@@ -3,7 +3,7 @@
 
 namespace duckdb {
 
-void JsonDeserializer::SetTag(const char *tag) {
+void JsonDeserializer::SetTag(const field_id_t, const char *tag) {
 	current_tag = tag;
 }
 
@@ -43,8 +43,10 @@ void JsonDeserializer::ThrowTypeError(yyjson_val *val, const char *expected) {
 	if (yyjson_is_obj(parent.val)) {
 		auto msg =
 		    StringUtil::Format("property '%s' expected type '%s', but got type: '%s'", current_tag, expected, actual);
+		throw ParserException(msg);
 	} else if (yyjson_is_arr(parent.val)) {
 		auto msg = StringUtil::Format("Sequence expect child of type '%s', but got type: %s", expected, actual);
+		throw ParserException(msg);
 	} else {
 		// unreachable?
 		throw InternalException("cannot get nested value from non object or array-type");
@@ -122,11 +124,11 @@ void JsonDeserializer::OnMapEntryBegin() {
 }
 
 void JsonDeserializer::OnMapKeyBegin() {
-	SetTag("key");
+	SetTag(100, "key");
 }
 
 void JsonDeserializer::OnMapValueBegin() {
-	SetTag("value");
+	SetTag(101, "value");
 }
 
 void JsonDeserializer::OnMapEntryEnd() {
@@ -146,11 +148,11 @@ void JsonDeserializer::OnPairBegin() {
 }
 
 void JsonDeserializer::OnPairKeyBegin() {
-	SetTag("key");
+	SetTag(100, "key");
 }
 
 void JsonDeserializer::OnPairValueBegin() {
-	SetTag("value");
+	SetTag(101, "value");
 }
 
 void JsonDeserializer::OnPairEnd() {
@@ -178,7 +180,7 @@ bool JsonDeserializer::ReadBool() {
 
 int8_t JsonDeserializer::ReadSignedInt8() {
 	auto val = GetNextValue();
-	if (!yyjson_is_sint(val)) {
+	if (!yyjson_is_int(val)) {
 		ThrowTypeError(val, "int8_t");
 	}
 	return yyjson_get_sint(val);
@@ -194,7 +196,7 @@ uint8_t JsonDeserializer::ReadUnsignedInt8() {
 
 int16_t JsonDeserializer::ReadSignedInt16() {
 	auto val = GetNextValue();
-	if (!yyjson_is_sint(val)) {
+	if (!yyjson_is_int(val)) {
 		ThrowTypeError(val, "int16_t");
 	}
 	return yyjson_get_sint(val);
@@ -210,7 +212,7 @@ uint16_t JsonDeserializer::ReadUnsignedInt16() {
 
 int32_t JsonDeserializer::ReadSignedInt32() {
 	auto val = GetNextValue();
-	if (!yyjson_is_sint(val)) {
+	if (!yyjson_is_int(val)) {
 		ThrowTypeError(val, "int32_t");
 	}
 	return yyjson_get_sint(val);
@@ -226,7 +228,7 @@ uint32_t JsonDeserializer::ReadUnsignedInt32() {
 
 int64_t JsonDeserializer::ReadSignedInt64() {
 	auto val = GetNextValue();
-	if (!yyjson_is_sint(val)) {
+	if (!yyjson_is_int(val)) {
 		ThrowTypeError(val, "int64_t");
 	}
 	return yyjson_get_sint(val);
@@ -271,9 +273,9 @@ interval_t JsonDeserializer::ReadInterval() {
 	}
 	Push(val);
 	interval_t result;
-	ReadProperty("months", result.months);
-	ReadProperty("days", result.days);
-	ReadProperty("micros", result.micros);
+	ReadProperty(100, "months", result.months);
+	ReadProperty(101, "days", result.days);
+	ReadProperty(102, "micros", result.micros);
 	Pop();
 	return result;
 }
@@ -285,8 +287,8 @@ hugeint_t JsonDeserializer::ReadHugeInt() {
 	}
 	Push(val);
 	hugeint_t result;
-	ReadProperty("upper", result.upper);
-	ReadProperty("lower", result.lower);
+	ReadProperty(100, "upper", result.upper);
+	ReadProperty(101, "lower", result.lower);
 	Pop();
 	return result;
 }

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

@@ -999,12 +999,12 @@ unique_ptr<FunctionData> JSONScan::Deserialize(PlanDeserializationState &state,
 void JSONScan::FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                const TableFunction &function) {
 	auto &bind_data = bind_data_p->Cast<JSONScanData>();
-	serializer.WriteProperty("scan_data", bind_data);
+	serializer.WriteProperty(100, "scan_data", bind_data);
 }
 
 unique_ptr<FunctionData> JSONScan::FormatDeserialize(FormatDeserializer &deserializer, TableFunction &function) {
 	unique_ptr<JSONScanData> result;
-	deserializer.ReadProperty("scan_data", result);
+	deserializer.ReadProperty(100, "scan_data", result);
 	return std::move(result);
 }
 

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

@@ -19,7 +19,7 @@ void JsonSerializer::PushValue(yyjson_mut_val *val) {
 	}
 }
 
-void JsonSerializer::SetTag(const char *tag) {
+void JsonSerializer::SetTag(const field_id_t, const char *tag) {
 	current_tag = yyjson_mut_strcpy(doc, tag);
 }
 
@@ -63,11 +63,11 @@ void JsonSerializer::OnMapEntryBegin() {
 }
 
 void JsonSerializer::OnMapKeyBegin() {
-	SetTag("key");
+	SetTag(100, "key");
 }
 
 void JsonSerializer::OnMapValueBegin() {
-	SetTag("value");
+	SetTag(101, "value");
 }
 
 void JsonSerializer::OnMapEntryEnd() {
@@ -127,11 +127,11 @@ void JsonSerializer::OnPairBegin() {
 }
 
 void JsonSerializer::OnPairKeyBegin() {
-	SetTag("key");
+	SetTag(100, "key");
 }
 
 void JsonSerializer::OnPairValueBegin() {
-	SetTag("value");
+	SetTag(101, "value");
 }
 
 void JsonSerializer::OnPairEnd() {
@@ -172,7 +172,7 @@ void JsonSerializer::WriteValue(uint32_t value) {
 }
 
 void JsonSerializer::WriteValue(int32_t value) {
-	auto val = yyjson_mut_int(doc, value);
+	auto val = yyjson_mut_sint(doc, value);
 	PushValue(val);
 }
 
@@ -190,8 +190,8 @@ void JsonSerializer::WriteValue(hugeint_t value) {
 	auto val = yyjson_mut_obj(doc);
 	PushValue(val);
 	stack.push_back(val);
-	WriteProperty("upper", value.upper);
-	WriteProperty("lower", value.lower);
+	WriteProperty(100, "upper", value.upper);
+	WriteProperty(101, "lower", value.lower);
 	stack.pop_back();
 }
 
@@ -209,9 +209,9 @@ void JsonSerializer::WriteValue(interval_t value) {
 	auto val = yyjson_mut_obj(doc);
 	PushValue(val);
 	stack.push_back(val);
-	WriteProperty("months", value.months);
-	WriteProperty("days", value.days);
-	WriteProperty("micros", value.micros);
+	WriteProperty(100, "months", value.months);
+	WriteProperty(101, "days", value.days);
+	WriteProperty(102, "micros", value.micros);
 	stack.pop_back();
 }
 

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

@@ -12,51 +12,51 @@
 namespace duckdb {
 
 void BufferedJSONReaderOptions::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("format", format);
-	serializer.WriteProperty("record_type", record_type);
-	serializer.WriteProperty("compression", compression);
-	serializer.WriteProperty("file_options", file_options);
+	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 result;
-	deserializer.ReadProperty("format", result.format);
-	deserializer.ReadProperty("record_type", result.record_type);
-	deserializer.ReadProperty("compression", result.compression);
-	deserializer.ReadProperty("file_options", result.file_options);
+	deserializer.ReadProperty(100, "format", result.format);
+	deserializer.ReadProperty(101, "record_type", result.record_type);
+	deserializer.ReadProperty(102, "compression", result.compression);
+	deserializer.ReadProperty(103, "file_options", result.file_options);
 	return result;
 }
 
 void JSONScanData::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("json_type", type);
-	serializer.WriteProperty("options", options);
-	serializer.WriteProperty("reader_bind", reader_bind);
-	serializer.WriteProperty("files", files);
-	serializer.WriteProperty("ignore_errors", ignore_errors);
-	serializer.WriteProperty("maximum_object_size", maximum_object_size);
-	serializer.WriteProperty("auto_detect", auto_detect);
-	serializer.WriteProperty("sample_size", sample_size);
-	serializer.WriteProperty("max_depth", max_depth);
-	serializer.WriteProperty("transform_options", transform_options);
-	serializer.WriteProperty("names", names);
-	serializer.WriteProperty("date_format", GetDateFormat());
-	serializer.WriteProperty("timestamp_format", GetTimestampFormat());
+	serializer.WriteProperty(100, "json_type", type);
+	serializer.WriteProperty(101, "options", options);
+	serializer.WriteProperty(102, "reader_bind", reader_bind);
+	serializer.WriteProperty(103, "files", files);
+	serializer.WriteProperty(104, "ignore_errors", ignore_errors);
+	serializer.WriteProperty(105, "maximum_object_size", maximum_object_size);
+	serializer.WriteProperty(106, "auto_detect", auto_detect);
+	serializer.WriteProperty(107, "sample_size", sample_size);
+	serializer.WriteProperty(108, "max_depth", max_depth);
+	serializer.WriteProperty(109, "transform_options", transform_options);
+	serializer.WriteProperty(110, "names", names);
+	serializer.WriteProperty(111, "date_format", GetDateFormat());
+	serializer.WriteProperty(112, "timestamp_format", GetTimestampFormat());
 }
 
 unique_ptr<JSONScanData> JSONScanData::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<JSONScanType>("json_type");
-	auto options = deserializer.ReadProperty<BufferedJSONReaderOptions>("options");
-	auto reader_bind = deserializer.ReadProperty<MultiFileReaderBindData>("reader_bind");
-	auto files = deserializer.ReadProperty<vector<string>>("files");
-	auto ignore_errors = deserializer.ReadProperty<bool>("ignore_errors");
-	auto maximum_object_size = deserializer.ReadProperty<idx_t>("maximum_object_size");
-	auto auto_detect = deserializer.ReadProperty<bool>("auto_detect");
-	auto sample_size = deserializer.ReadProperty<idx_t>("sample_size");
-	auto max_depth = deserializer.ReadProperty<idx_t>("max_depth");
-	auto transform_options = deserializer.ReadProperty<JSONTransformOptions>("transform_options");
-	auto names = deserializer.ReadProperty<vector<string>>("names");
-	auto date_format = deserializer.ReadProperty<string>("date_format");
-	auto timestamp_format = deserializer.ReadProperty<string>("timestamp_format");
+	auto type = deserializer.ReadProperty<JSONScanType>(100, "json_type");
+	auto options = deserializer.ReadProperty<BufferedJSONReaderOptions>(101, "options");
+	auto reader_bind = deserializer.ReadProperty<MultiFileReaderBindData>(102, "reader_bind");
+	auto files = deserializer.ReadProperty<vector<string>>(103, "files");
+	auto ignore_errors = deserializer.ReadProperty<bool>(104, "ignore_errors");
+	auto maximum_object_size = deserializer.ReadProperty<idx_t>(105, "maximum_object_size");
+	auto auto_detect = deserializer.ReadProperty<bool>(106, "auto_detect");
+	auto sample_size = deserializer.ReadProperty<idx_t>(107, "sample_size");
+	auto max_depth = deserializer.ReadProperty<idx_t>(108, "max_depth");
+	auto transform_options = deserializer.ReadProperty<JSONTransformOptions>(109, "transform_options");
+	auto names = deserializer.ReadProperty<vector<string>>(110, "names");
+	auto date_format = deserializer.ReadProperty<string>(111, "date_format");
+	auto timestamp_format = deserializer.ReadProperty<string>(112, "timestamp_format");
 	auto result = duckdb::unique_ptr<JSONScanData>(new JSONScanData(deserializer.Get<ClientContext &>(), std::move(files), std::move(date_format), std::move(timestamp_format)));
 	result->type = type;
 	result->options = options;
@@ -72,20 +72,20 @@ unique_ptr<JSONScanData> JSONScanData::FormatDeserialize(FormatDeserializer &des
 }
 
 void JSONTransformOptions::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("strict_cast", strict_cast);
-	serializer.WriteProperty("error_duplicate_key", error_duplicate_key);
-	serializer.WriteProperty("error_missing_key", error_missing_key);
-	serializer.WriteProperty("error_unknown_key", error_unknown_key);
-	serializer.WriteProperty("delay_error", delay_error);
+	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);
+	serializer.WriteProperty(103, "error_unknown_key", error_unknown_key);
+	serializer.WriteProperty(104, "delay_error", delay_error);
 }
 
 JSONTransformOptions JSONTransformOptions::FormatDeserialize(FormatDeserializer &deserializer) {
 	JSONTransformOptions result;
-	deserializer.ReadProperty("strict_cast", result.strict_cast);
-	deserializer.ReadProperty("error_duplicate_key", result.error_duplicate_key);
-	deserializer.ReadProperty("error_missing_key", result.error_missing_key);
-	deserializer.ReadProperty("error_unknown_key", result.error_unknown_key);
-	deserializer.ReadProperty("delay_error", result.delay_error);
+	deserializer.ReadProperty(100, "strict_cast", result.strict_cast);
+	deserializer.ReadProperty(101, "error_duplicate_key", result.error_duplicate_key);
+	deserializer.ReadProperty(102, "error_missing_key", result.error_missing_key);
+	deserializer.ReadProperty(103, "error_unknown_key", result.error_unknown_key);
+	deserializer.ReadProperty(104, "delay_error", result.delay_error);
 	return result;
 }
 

package/src/duckdb/extension/parquet/parquet_extension.cpp

@@ -201,8 +201,9 @@ public:
 
 		for (auto &option : info.options) {
 			auto loption = StringUtil::Lower(option.first);
-			if (loption == "compression" || loption == "codec") {
-				// CODEC option has no effect on parquet read: we determine codec from the file
+			if (loption == "compression" || loption == "codec" || loption == "row_group_size") {
+				// CODEC/COMPRESSION and ROW_GROUP_SIZE options have no effect on parquet read.
+				// These options are determined from the file.
 				continue;
 			} else if (loption == "binary_as_string") {
 				parquet_options.binary_as_string = true;
@@ -437,19 +438,19 @@ public:
 	static void ParquetScanFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
 	                                       const TableFunction &function) {
 		auto &bind_data = bind_data_p->Cast<ParquetReadBindData>();
-		serializer.WriteProperty("files", bind_data.files);
-		serializer.WriteProperty("types", bind_data.types);
-		serializer.WriteProperty("names", bind_data.names);
-		serializer.WriteProperty("parquet_options", bind_data.parquet_options);
+		serializer.WriteProperty(100, "files", bind_data.files);
+		serializer.WriteProperty(101, "types", bind_data.types);
+		serializer.WriteProperty(102, "names", bind_data.names);
+		serializer.WriteProperty(103, "parquet_options", bind_data.parquet_options);
 	}
 
 	static unique_ptr<FunctionData> ParquetScanFormatDeserialize(FormatDeserializer &deserializer,
 	                                                             TableFunction &function) {
 		auto &context = deserializer.Get<ClientContext &>();
-		auto files = deserializer.ReadProperty<vector<string>>("files");
-		auto types = deserializer.ReadProperty<vector<LogicalType>>("types");
-		auto names = deserializer.ReadProperty<vector<string>>("names");
-		auto parquet_options = deserializer.ReadProperty<ParquetOptions>("parquet_options");
+		auto files = deserializer.ReadProperty<vector<string>>(100, "files");
+		auto types = deserializer.ReadProperty<vector<LogicalType>>(101, "types");
+		auto names = deserializer.ReadProperty<vector<string>>(102, "names");
+		auto parquet_options = deserializer.ReadProperty<ParquetOptions>(103, "parquet_options");
 		return ParquetScanBindInternal(context, files, types, names, parquet_options);
 	}
 

package/src/duckdb/extension/parquet/serialize_parquet.cpp

@@ -10,16 +10,16 @@
 namespace duckdb {
 
 void ParquetOptions::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("binary_as_string", binary_as_string);
-	serializer.WriteProperty("file_row_number", file_row_number);
-	serializer.WriteProperty("file_options", file_options);
+	serializer.WriteProperty(100, "binary_as_string", binary_as_string);
+	serializer.WriteProperty(101, "file_row_number", file_row_number);
+	serializer.WriteProperty(102, "file_options", file_options);
 }
 
 ParquetOptions ParquetOptions::FormatDeserialize(FormatDeserializer &deserializer) {
 	ParquetOptions result;
-	deserializer.ReadProperty("binary_as_string", result.binary_as_string);
-	deserializer.ReadProperty("file_row_number", result.file_row_number);
-	deserializer.ReadProperty("file_options", result.file_options);
+	deserializer.ReadProperty(100, "binary_as_string", result.binary_as_string);
+	deserializer.ReadProperty(101, "file_row_number", result.file_row_number);
+	deserializer.ReadProperty(102, "file_options", result.file_options);
 	return result;
 }
 

package/src/duckdb/src/common/extra_type_info.cpp

@@ -426,7 +426,7 @@ shared_ptr<ExtraTypeInfo> EnumTypeInfo::Deserialize(FieldReader &reader) {
 }
 
 shared_ptr<ExtraTypeInfo> EnumTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto enum_size = deserializer.ReadProperty<idx_t>("enum_size");
+	auto enum_size = deserializer.ReadProperty<idx_t>(200, "enum_size");
 	auto enum_internal_type = EnumTypeInfo::DictType(enum_size);
 	switch (enum_internal_type) {
 	case PhysicalType::UINT8:
@@ -476,7 +476,7 @@ void EnumTypeInfo::Serialize(FieldWriter &writer) const {
 
 void EnumTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("dict_size", dict_size);
+	serializer.WriteProperty(200, "dict_size", dict_size);
 	((Vector &)values_insert_order).FormatSerialize(serializer, dict_size); // NOLINT - FIXME
 }
 

package/src/duckdb/src/common/serializer/binary_deserializer.cpp

@@ -2,7 +2,8 @@
 
 namespace duckdb {
 
-void BinaryDeserializer::SetTag(const char *tag) {
+void BinaryDeserializer::SetTag(const field_id_t field_id, const char *tag) {
+	current_field_id = field_id;
 	current_tag = tag;
 	stack.back().read_field_count++;
 	if (stack.back().read_field_count > stack.back().expected_field_count) {
@@ -14,12 +15,13 @@ void BinaryDeserializer::SetTag(const char *tag) {
 // Nested Types Hooks
 //===--------------------------------------------------------------------===//
 void BinaryDeserializer::OnObjectBegin() {
+	auto expected_field_id = ReadPrimitive<field_id_t>();
 	auto expected_field_count = ReadPrimitive<uint32_t>();
 	auto expected_size = ReadPrimitive<uint64_t>();
 	D_ASSERT(expected_field_count > 0);
 	D_ASSERT(expected_size > 0);
-
-	stack.emplace_back(expected_field_count, expected_size);
+	D_ASSERT(expected_field_id == current_field_id);
+	stack.emplace_back(expected_field_count, expected_size, expected_field_id);
 }
 
 void BinaryDeserializer::OnObjectEnd() {

package/src/duckdb/src/common/serializer/binary_serializer.cpp

@@ -2,9 +2,9 @@
 
 namespace duckdb {
 
-void BinarySerializer::SetTag(const char *tag) {
+void BinarySerializer::SetTag(const field_id_t field_id, const char *tag) {
+	current_field_id = field_id;
 	current_tag = tag;
-
 	// Increment the number of fields
 	stack.back().field_count++;
 }
@@ -45,6 +45,9 @@ void BinarySerializer::OnMapEnd(idx_t count) {
 
 void BinarySerializer::OnObjectBegin() {
 	stack.push_back(State({0, 0, data.size()}));
+	// Store the field id
+	Write<field_id_t>(current_field_id);
+	// Store the offset so we can patch the field count and size later
 	Write<uint32_t>(0); // Placeholder for the field count
 	Write<uint64_t>(0); // Placeholder for the size
 }
@@ -52,9 +55,11 @@ void BinarySerializer::OnObjectBegin() {
 void BinarySerializer::OnObjectEnd() {
 	auto &frame = stack.back();
 	// Patch the field count and size
-	auto message_start = &data[frame.offset];
-	Store<uint32_t>(frame.field_count, message_start);
-	Store<uint64_t>(frame.size, message_start + sizeof(uint32_t));
+	auto ptr = &data[frame.offset];
+	ptr += sizeof(field_id_t); // Skip the field id
+	Store<uint32_t>(frame.field_count, ptr);
+	ptr += sizeof(uint32_t); // Skip the field count
+	Store<uint64_t>(frame.size, ptr);
 	stack.pop_back();
 }
 

package/src/duckdb/src/common/types/column/column_data_collection.cpp

@@ -1069,13 +1069,13 @@ void ColumnDataCollection::FormatSerialize(FormatSerializer &serializer) const {
 			}
 		}
 	}
-	serializer.WriteProperty("types", types);
-	serializer.WriteProperty("values", values);
+	serializer.WriteProperty(100, "types", types);
+	serializer.WriteProperty(101, "values", values);
 }
 
 unique_ptr<ColumnDataCollection> ColumnDataCollection::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto types = deserializer.ReadProperty<vector<LogicalType>>("types");
-	auto values = deserializer.ReadProperty<vector<vector<Value>>>("values");
+	auto types = deserializer.ReadProperty<vector<LogicalType>>(100, "types");
+	auto values = deserializer.ReadProperty<vector<vector<Value>>>(101, "values");
 
 	auto collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
 	if (values.empty()) {

package/src/duckdb/src/common/types/value.cpp

@@ -1763,55 +1763,55 @@ Value Value::Deserialize(Deserializer &main_source) {
 }
 
 void Value::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type_);
-	serializer.WriteProperty("is_null", is_null);
+	serializer.WriteProperty(100, "type", type_);
+	serializer.WriteProperty(101, "is_null", is_null);
 	if (!IsNull()) {
 		switch (type_.InternalType()) {
 		case PhysicalType::BOOL:
-			serializer.WriteProperty("value", value_.boolean);
+			serializer.WriteProperty(100, "value", value_.boolean);
 			break;
 		case PhysicalType::INT8:
-			serializer.WriteProperty("value", value_.tinyint);
+			serializer.WriteProperty(100, "value", value_.tinyint);
 			break;
 		case PhysicalType::INT16:
-			serializer.WriteProperty("value", value_.smallint);
+			serializer.WriteProperty(100, "value", value_.smallint);
 			break;
 		case PhysicalType::INT32:
-			serializer.WriteProperty("value", value_.integer);
+			serializer.WriteProperty(100, "value", value_.integer);
 			break;
 		case PhysicalType::INT64:
-			serializer.WriteProperty("value", value_.bigint);
+			serializer.WriteProperty(100, "value", value_.bigint);
 			break;
 		case PhysicalType::UINT8:
-			serializer.WriteProperty("value", value_.utinyint);
+			serializer.WriteProperty(100, "value", value_.utinyint);
 			break;
 		case PhysicalType::UINT16:
-			serializer.WriteProperty("value", value_.usmallint);
+			serializer.WriteProperty(100, "value", value_.usmallint);
 			break;
 		case PhysicalType::UINT32:
-			serializer.WriteProperty("value", value_.uinteger);
+			serializer.WriteProperty(100, "value", value_.uinteger);
 			break;
 		case PhysicalType::UINT64:
-			serializer.WriteProperty("value", value_.ubigint);
+			serializer.WriteProperty(100, "value", value_.ubigint);
 			break;
 		case PhysicalType::INT128:
-			serializer.WriteProperty("value", value_.hugeint);
+			serializer.WriteProperty(100, "value", value_.hugeint);
 			break;
 		case PhysicalType::FLOAT:
-			serializer.WriteProperty("value", value_.float_);
+			serializer.WriteProperty(100, "value", value_.float_);
 			break;
 		case PhysicalType::DOUBLE:
-			serializer.WriteProperty("value", value_.double_);
+			serializer.WriteProperty(100, "value", value_.double_);
 			break;
 		case PhysicalType::INTERVAL:
-			serializer.WriteProperty("value", value_.interval);
+			serializer.WriteProperty(100, "value", value_.interval);
 			break;
 		case PhysicalType::VARCHAR:
 			if (type_.id() == LogicalTypeId::BLOB) {
 				auto blob_str = Blob::ToString(StringValue::Get(*this));
-				serializer.WriteProperty("value", blob_str);
+				serializer.WriteProperty(100, "value", blob_str);
 			} else {
-				serializer.WriteProperty("value", StringValue::Get(*this));
+				serializer.WriteProperty(100, "value", StringValue::Get(*this));
 			}
 			break;
 		default: {
@@ -1824,8 +1824,8 @@ void Value::FormatSerialize(FormatSerializer &serializer) const {
 }
 
 Value Value::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<LogicalType>("type");
-	auto is_null = deserializer.ReadProperty<bool>("is_null");
+	auto type = deserializer.ReadProperty<LogicalType>(100, "type");
+	auto is_null = deserializer.ReadProperty<bool>(101, "is_null");
 	Value new_value = Value(type);
 	if (is_null) {
 		return new_value;
@@ -1833,46 +1833,46 @@ Value Value::FormatDeserialize(FormatDeserializer &deserializer) {
 	new_value.is_null = false;
 	switch (type.InternalType()) {
 	case PhysicalType::BOOL:
-		new_value.value_.boolean = deserializer.ReadProperty<bool>("value");
+		new_value.value_.boolean = deserializer.ReadProperty<bool>(100, "value");
 		break;
 	case PhysicalType::UINT8:
-		new_value.value_.utinyint = deserializer.ReadProperty<uint8_t>("value");
+		new_value.value_.utinyint = deserializer.ReadProperty<uint8_t>(100, "value");
 		break;
 	case PhysicalType::INT8:
-		new_value.value_.tinyint = deserializer.ReadProperty<int8_t>("value");
+		new_value.value_.tinyint = deserializer.ReadProperty<int8_t>(100, "value");
 		break;
 	case PhysicalType::UINT16:
-		new_value.value_.usmallint = deserializer.ReadProperty<uint16_t>("value");
+		new_value.value_.usmallint = deserializer.ReadProperty<uint16_t>(100, "value");
 		break;
 	case PhysicalType::INT16:
-		new_value.value_.smallint = deserializer.ReadProperty<int16_t>("value");
+		new_value.value_.smallint = deserializer.ReadProperty<int16_t>(100, "value");
 		break;
 	case PhysicalType::UINT32:
-		new_value.value_.uinteger = deserializer.ReadProperty<uint32_t>("value");
+		new_value.value_.uinteger = deserializer.ReadProperty<uint32_t>(100, "value");
 		break;
 	case PhysicalType::INT32:
-		new_value.value_.integer = deserializer.ReadProperty<int32_t>("value");
+		new_value.value_.integer = deserializer.ReadProperty<int32_t>(100, "value");
 		break;
 	case PhysicalType::UINT64:
-		new_value.value_.ubigint = deserializer.ReadProperty<uint64_t>("value");
+		new_value.value_.ubigint = deserializer.ReadProperty<uint64_t>(100, "value");
 		break;
 	case PhysicalType::INT64:
-		new_value.value_.bigint = deserializer.ReadProperty<int64_t>("value");
+		new_value.value_.bigint = deserializer.ReadProperty<int64_t>(100, "value");
 		break;
 	case PhysicalType::INT128:
-		new_value.value_.hugeint = deserializer.ReadProperty<hugeint_t>("value");
+		new_value.value_.hugeint = deserializer.ReadProperty<hugeint_t>(100, "value");
 		break;
 	case PhysicalType::FLOAT:
-		new_value.value_.float_ = deserializer.ReadProperty<float>("value");
+		new_value.value_.float_ = deserializer.ReadProperty<float>(100, "value");
 		break;
 	case PhysicalType::DOUBLE:
-		new_value.value_.double_ = deserializer.ReadProperty<double>("value");
+		new_value.value_.double_ = deserializer.ReadProperty<double>(100, "value");
 		break;
 	case PhysicalType::INTERVAL:
-		new_value.value_.interval = deserializer.ReadProperty<interval_t>("value");
+		new_value.value_.interval = deserializer.ReadProperty<interval_t>(100, "value");
 		break;
 	case PhysicalType::VARCHAR: {
-		auto str = deserializer.ReadProperty<string>("value");
+		auto str = deserializer.ReadProperty<string>(100, "value");
 		if (type.id() == LogicalTypeId::BLOB) {
 			new_value.value_info_ = make_shared<StringValueInfo>(Blob::ToBlob(str));
 		} else {