duckdb 0.8.2-dev3458.0 → 0.8.2-dev3949.0

package/binding.gyp

@@ -63,6 +63,8 @@
                 "src/duckdb/ub_src_execution_index_art.cpp", 
                 "src/duckdb/ub_src_execution_nested_loop_join.cpp", 
                 "src/duckdb/ub_src_execution_operator_aggregate.cpp", 
+                "src/duckdb/ub_src_execution_operator_csv_scanner.cpp", 
+                "src/duckdb/ub_src_execution_operator_csv_scanner_sniffer.cpp", 
                 "src/duckdb/ub_src_execution_operator_filter.cpp", 
                 "src/duckdb/ub_src_execution_operator_helper.cpp", 
                 "src/duckdb/ub_src_execution_operator_join.cpp", 

package/package.json

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

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

@@ -43,13 +43,13 @@ struct IcuBindData : public FunctionData {
 		UErrorCode status = U_ZERO_ERROR;
 		auto locale = icu::Locale(language.c_str(), country.c_str());
 		if (locale.isBogus()) {
-			throw InternalException("Locale is bogus!?");
+			throw InvalidInputException("Locale is bogus!?");
 		}
 		this->collator = duckdb::unique_ptr<icu::Collator>(icu::Collator::createInstance(locale, status));
 		if (U_FAILURE(status)) {
 			auto error_name = u_errorName(status);
-			throw InternalException("Failed to create ICU collator: %s (language: %s, country: %s)", error_name,
-			                        language, country);
+			throw InvalidInputException("Failed to create ICU collator: %s (language: %s, country: %s)", error_name,
+			                            language, country);
 		}
 	}
 
@@ -113,7 +113,7 @@ static duckdb::unique_ptr<FunctionData> ICUCollateBind(ClientContext &context, S
 	} else if (splits.size() == 2) {
 		return make_uniq<IcuBindData>(splits[0], splits[1]);
 	} else {
-		throw InternalException("Expected one or two splits");
+		throw InvalidInputException("Expected one or two splits");
 	}
 }
 
@@ -132,7 +132,7 @@ static duckdb::unique_ptr<FunctionData> ICUSortKeyBind(ClientContext &context, S
 	} else if (splits.size() == 2) {
 		return make_uniq<IcuBindData>(splits[0], splits[1]);
 	} else {
-		throw InternalException("Expected one or two splits");
+		throw InvalidInputException("Expected one or two splits");
 	}
 }
 

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

@@ -47,28 +47,20 @@ private:
 
 	void ThrowTypeError(yyjson_val *val, const char *expected);
 
-	// Set the 'tag' of the property to read
-	void SetTag(const field_id_t, const char *tag) final;
-
 	//===--------------------------------------------------------------------===//
 	// Nested Types Hooks
 	//===--------------------------------------------------------------------===//
+	void OnPropertyBegin(const field_id_t field_id, const char *tag) final;
+	void OnPropertyEnd() final;
+	bool OnOptionalPropertyBegin(const field_id_t field_id, const char *tag) final;
+	void OnOptionalPropertyEnd(bool present) final;
+
 	void OnObjectBegin() final;
 	void OnObjectEnd() final;
 	idx_t OnListBegin() final;
 	void OnListEnd() final;
-	idx_t OnMapBegin() final;
-	void OnMapEnd() final;
-	void OnMapEntryBegin() final;
-	void OnMapEntryEnd() final;
-	void OnMapKeyBegin() final;
-	void OnMapValueBegin() final;
-	bool OnOptionalBegin() final;
-
-	void OnPairBegin() final;
-	void OnPairKeyBegin() final;
-	void OnPairValueBegin() final;
-	void OnPairEnd() final;
+	bool OnNullableBegin() final;
+	void OnNullableEnd() final;
 
 	//===--------------------------------------------------------------------===//
 	// Primitive Types
@@ -85,7 +77,6 @@ private:
 	float ReadFloat() final;
 	double ReadDouble() final;
 	string ReadString() final;
-	interval_t ReadInterval() final;
 	hugeint_t ReadHugeInt() final;
 	void ReadDataPtr(data_ptr_t &ptr, idx_t count) final;
 };

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

@@ -27,6 +27,7 @@ private:
 	explicit JsonSerializer(yyjson_mut_doc *doc, bool skip_if_null, bool skip_if_empty)
 	    : doc(doc), stack({yyjson_mut_obj(doc)}), skip_if_null(skip_if_null), skip_if_empty(skip_if_empty) {
 		serialize_enum_as_string = true;
+		serialize_default_values = true;
 	}
 
 public:
@@ -42,26 +43,20 @@ public:
 		return stack.front();
 	};
 
-	void SetTag(const field_id_t, const char *tag) final;
-
 	//===--------------------------------------------------------------------===//
 	// Nested Types Hooks
 	//===--------------------------------------------------------------------===//
-	void OnOptionalBegin(bool present) final;
+	void OnPropertyBegin(const field_id_t field_id, const char *tag) final;
+	void OnPropertyEnd() final;
+	void OnOptionalPropertyBegin(const field_id_t field_id, const char *tag, bool present) final;
+	void OnOptionalPropertyEnd(bool present) final;
+
 	void OnListBegin(idx_t count) final;
-	void OnListEnd(idx_t count) final;
-	void OnMapBegin(idx_t count) final;
-	void OnMapEntryBegin() final;
-	void OnMapEntryEnd() final;
-	void OnMapKeyBegin() final;
-	void OnMapValueBegin() final;
-	void OnMapEnd(idx_t count) final;
+	void OnListEnd() final;
 	void OnObjectBegin() final;
 	void OnObjectEnd() final;
-	void OnPairBegin() final;
-	void OnPairKeyBegin() final;
-	void OnPairValueBegin() final;
-	void OnPairEnd() final;
+	void OnNullableBegin(bool present) final;
+	void OnNullableEnd() final;
 
 	//===--------------------------------------------------------------------===//
 	// Primitive Types
@@ -78,7 +73,6 @@ public:
 	void WriteValue(hugeint_t value) final;
 	void WriteValue(float value) final;
 	void WriteValue(double value) final;
-	void WriteValue(interval_t value) final;
 	void WriteValue(const string_t value) final;
 	void WriteValue(const string &value) final;
 	void WriteValue(const char *value) final;

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

@@ -3,10 +3,25 @@
 
 namespace duckdb {
 
-void JsonDeserializer::SetTag(const field_id_t, const char *tag) {
+void JsonDeserializer::OnPropertyBegin(const field_id_t, const char *tag) {
 	current_tag = tag;
 }
 
+void JsonDeserializer::OnPropertyEnd() {
+}
+
+bool JsonDeserializer::OnOptionalPropertyBegin(const field_id_t, const char *tag) {
+	auto parent = Current();
+	auto present = yyjson_obj_get(parent.val, tag) != nullptr;
+	if (present) {
+		current_tag = tag;
+	}
+	return present;
+}
+
+void JsonDeserializer::OnOptionalPropertyEnd(bool) {
+}
+
 // If inside an object, return the value associated by the current tag (property name)
 // If inside an array, return the next element in the sequence
 yyjson_val *JsonDeserializer::GetNextValue() {
@@ -105,68 +120,29 @@ void JsonDeserializer::OnListEnd() {
 	Pop();
 }
 
-// Deserialize maps as [ { key: ..., value: ... } ]
-idx_t JsonDeserializer::OnMapBegin() {
-	auto val = GetNextValue();
-	if (!yyjson_is_arr(val)) {
-		ThrowTypeError(val, "array");
+bool JsonDeserializer::OnNullableBegin() {
+	auto &parent_val = Current();
+	yyjson_arr_iter iter;
+	if (yyjson_is_arr(parent_val.val)) {
+		iter = parent_val.arr_iter;
 	}
-	Push(val);
-	return yyjson_arr_size(val);
-}
-
-void JsonDeserializer::OnMapEntryBegin() {
 	auto val = GetNextValue();
-	if (!yyjson_is_obj(val)) {
-		ThrowTypeError(val, "object");
-	}
-	Push(val);
-}
-
-void JsonDeserializer::OnMapKeyBegin() {
-	SetTag(100, "key");
-}
-
-void JsonDeserializer::OnMapValueBegin() {
-	SetTag(101, "value");
-}
 
-void JsonDeserializer::OnMapEntryEnd() {
-	stack.pop_back();
-}
-
-void JsonDeserializer::OnMapEnd() {
-	stack.pop_back();
-}
-
-void JsonDeserializer::OnPairBegin() {
-	auto val = GetNextValue();
-	if (!yyjson_is_obj(val)) {
-		ThrowTypeError(val, "object");
+	// Recover the iterator if we are inside an array
+	if (yyjson_is_arr(parent_val.val)) {
+		parent_val.arr_iter = iter;
 	}
-	Push(val);
-}
-
-void JsonDeserializer::OnPairKeyBegin() {
-	SetTag(100, "key");
-}
-
-void JsonDeserializer::OnPairValueBegin() {
-	SetTag(101, "value");
-}
-
-void JsonDeserializer::OnPairEnd() {
-	stack.pop_back();
-}
 
-bool JsonDeserializer::OnOptionalBegin() {
-	auto val = GetNextValue();
 	if (yyjson_is_null(val)) {
 		return false;
 	}
+
 	return true;
 }
 
+void JsonDeserializer::OnNullableEnd() {
+}
+
 //===--------------------------------------------------------------------===//
 // Primitive Types
 //===--------------------------------------------------------------------===//
@@ -266,20 +242,6 @@ string JsonDeserializer::ReadString() {
 	return yyjson_get_str(val);
 }
 
-interval_t JsonDeserializer::ReadInterval() {
-	auto val = GetNextValue();
-	if (!yyjson_is_obj(val)) {
-		ThrowTypeError(val, "object");
-	}
-	Push(val);
-	interval_t result;
-	ReadProperty(100, "months", result.months);
-	ReadProperty(101, "days", result.days);
-	ReadProperty(102, "micros", result.micros);
-	Pop();
-	return result;
-}
-
 hugeint_t JsonDeserializer::ReadHugeInt() {
 	auto val = GetNextValue();
 	if (!yyjson_is_obj(val)) {
@@ -302,7 +264,7 @@ void JsonDeserializer::ReadDataPtr(data_ptr_t &ptr, idx_t count) {
 	auto len = yyjson_get_len(val);
 	D_ASSERT(len == count);
 	auto blob = string_t(str, len);
-	Blob::ToString(blob, (char *&)ptr);
+	Blob::ToString(blob, char_ptr_cast(ptr));
 }
 
 } // namespace duckdb

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

@@ -999,7 +999,7 @@ 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(100, "scan_data", bind_data);
+	serializer.WriteProperty(100, "scan_data", &bind_data);
 }
 
 unique_ptr<FunctionData> JSONScan::FormatDeserialize(FormatDeserializer &deserializer, TableFunction &function) {

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

@@ -19,19 +19,32 @@ void JsonSerializer::PushValue(yyjson_mut_val *val) {
 	}
 }
 
-void JsonSerializer::SetTag(const field_id_t, const char *tag) {
+void JsonSerializer::OnPropertyBegin(const field_id_t, const char *tag) {
 	current_tag = yyjson_mut_strcpy(doc, tag);
 }
 
-//===--------------------------------------------------------------------===//
-// Nested types
-//===--------------------------------------------------------------------===//
-void JsonSerializer::OnOptionalBegin(bool present) {
+void JsonSerializer::OnPropertyEnd() {
+}
+
+void JsonSerializer::OnOptionalPropertyBegin(const field_id_t, const char *tag, bool) {
+	current_tag = yyjson_mut_strcpy(doc, tag);
+}
+
+void JsonSerializer::OnOptionalPropertyEnd(bool) {
+}
+
+//-------------------------------------------------------------------------
+// Nested Types
+//-------------------------------------------------------------------------
+void JsonSerializer::OnNullableBegin(bool present) {
 	if (!present && !skip_if_null) {
 		WriteNull();
 	}
 }
 
+void JsonSerializer::OnNullableEnd() {
+}
+
 void JsonSerializer::OnListBegin(idx_t count) {
 	auto new_value = yyjson_mut_arr(doc);
 	// We always push a value to the stack, we just don't add it as a child to the current value
@@ -43,38 +56,7 @@ void JsonSerializer::OnListBegin(idx_t count) {
 	stack.push_back(new_value);
 }
 
-void JsonSerializer::OnListEnd(idx_t count) {
-	stack.pop_back();
-}
-
-// Serialize maps as arrays of objects with "key" and "value" properties.
-void JsonSerializer::OnMapBegin(idx_t count) {
-	auto new_value = yyjson_mut_arr(doc);
-	if (!(count == 0 && skip_if_empty)) {
-		PushValue(new_value);
-	}
-	stack.push_back(new_value);
-}
-
-void JsonSerializer::OnMapEntryBegin() {
-	auto new_value = yyjson_mut_obj(doc);
-	PushValue(new_value);
-	stack.push_back(new_value);
-}
-
-void JsonSerializer::OnMapKeyBegin() {
-	SetTag(100, "key");
-}
-
-void JsonSerializer::OnMapValueBegin() {
-	SetTag(101, "value");
-}
-
-void JsonSerializer::OnMapEntryEnd() {
-	stack.pop_back();
-}
-
-void JsonSerializer::OnMapEnd(idx_t count) {
+void JsonSerializer::OnListEnd() {
 	stack.pop_back();
 }
 
@@ -120,28 +102,13 @@ void JsonSerializer::OnObjectEnd() {
 	}
 }
 
-void JsonSerializer::OnPairBegin() {
-	auto new_value = yyjson_mut_obj(doc);
-	PushValue(new_value);
-	stack.push_back(new_value);
-}
-
-void JsonSerializer::OnPairKeyBegin() {
-	SetTag(100, "key");
-}
-
-void JsonSerializer::OnPairValueBegin() {
-	SetTag(101, "value");
-}
-
-void JsonSerializer::OnPairEnd() {
-	stack.pop_back();
-}
-
-//===--------------------------------------------------------------------===//
-// Primitive types
-//===--------------------------------------------------------------------===//
+//-------------------------------------------------------------------------
+// Primitive Types
+//-------------------------------------------------------------------------
 void JsonSerializer::WriteNull() {
+	if (skip_if_null) {
+		return;
+	}
 	auto val = yyjson_mut_null(doc);
 	PushValue(val);
 }
@@ -205,16 +172,6 @@ void JsonSerializer::WriteValue(double value) {
 	PushValue(val);
 }
 
-void JsonSerializer::WriteValue(interval_t value) {
-	auto val = yyjson_mut_obj(doc);
-	PushValue(val);
-	stack.push_back(val);
-	WriteProperty(100, "months", value.months);
-	WriteProperty(101, "days", value.days);
-	WriteProperty(102, "micros", value.micros);
-	stack.pop_back();
-}
-
 void JsonSerializer::WriteValue(const string &value) {
 	if (skip_if_empty && value.empty()) {
 		return;
@@ -245,7 +202,7 @@ void JsonSerializer::WriteValue(bool value) {
 }
 
 void JsonSerializer::WriteDataPtr(const_data_ptr_t ptr, idx_t count) {
-	auto blob = Blob::ToBlob(string_t((const char *)ptr, count));
+	auto blob = Blob::ToBlob(string_t(const_char_ptr_cast(ptr), count));
 	auto val = yyjson_mut_strcpy(doc, blob.c_str());
 	PushValue(val);
 }

package/src/duckdb/src/common/enum_util.cpp

@@ -57,6 +57,7 @@
 #include "duckdb/common/types/column/column_data_scan_states.hpp"
 #include "duckdb/common/types/column/partitioned_column_data.hpp"
 #include "duckdb/common/types/conflict_manager.hpp"
+#include "duckdb/common/types/hyperloglog.hpp"
 #include "duckdb/common/types/row/partitioned_tuple_data.hpp"
 #include "duckdb/common/types/row/tuple_data_states.hpp"
 #include "duckdb/common/types/timestamp.hpp"
@@ -64,8 +65,10 @@
 #include "duckdb/common/types/vector_buffer.hpp"
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/operator/persistent/base_csv_reader.hpp"
-#include "duckdb/execution/operator/persistent/csv_reader_options.hpp"
+#include "duckdb/execution/operator/scan/csv/base_csv_reader.hpp"
+#include "duckdb/execution/operator/scan/csv/csv_reader_options.hpp"
+#include "duckdb/execution/operator/scan/csv/csv_state_machine.hpp"
+#include "duckdb/execution/operator/scan/csv/quote_rules.hpp"
 #include "duckdb/function/aggregate_state.hpp"
 #include "duckdb/function/function.hpp"
 #include "duckdb/function/macro_function.hpp"
@@ -639,6 +642,64 @@ CAPIResultSetType EnumUtil::FromString<CAPIResultSetType>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<CSVState>(CSVState value) {
+	switch(value) {
+	case CSVState::STANDARD:
+		return "STANDARD";
+	case CSVState::DELIMITER:
+		return "DELIMITER";
+	case CSVState::RECORD_SEPARATOR:
+		return "RECORD_SEPARATOR";
+	case CSVState::CARRIAGE_RETURN:
+		return "CARRIAGE_RETURN";
+	case CSVState::QUOTED:
+		return "QUOTED";
+	case CSVState::UNQUOTED:
+		return "UNQUOTED";
+	case CSVState::ESCAPE:
+		return "ESCAPE";
+	case CSVState::EMPTY_LINE:
+		return "EMPTY_LINE";
+	case CSVState::INVALID:
+		return "INVALID";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+CSVState EnumUtil::FromString<CSVState>(const char *value) {
+	if (StringUtil::Equals(value, "STANDARD")) {
+		return CSVState::STANDARD;
+	}
+	if (StringUtil::Equals(value, "DELIMITER")) {
+		return CSVState::DELIMITER;
+	}
+	if (StringUtil::Equals(value, "RECORD_SEPARATOR")) {
+		return CSVState::RECORD_SEPARATOR;
+	}
+	if (StringUtil::Equals(value, "CARRIAGE_RETURN")) {
+		return CSVState::CARRIAGE_RETURN;
+	}
+	if (StringUtil::Equals(value, "QUOTED")) {
+		return CSVState::QUOTED;
+	}
+	if (StringUtil::Equals(value, "UNQUOTED")) {
+		return CSVState::UNQUOTED;
+	}
+	if (StringUtil::Equals(value, "ESCAPE")) {
+		return CSVState::ESCAPE;
+	}
+	if (StringUtil::Equals(value, "EMPTY_LINE")) {
+		return CSVState::EMPTY_LINE;
+	}
+	if (StringUtil::Equals(value, "INVALID")) {
+		return CSVState::INVALID;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<CTEMaterialize>(CTEMaterialize value) {
 	switch(value) {
@@ -2305,6 +2366,24 @@ FunctionSideEffects EnumUtil::FromString<FunctionSideEffects>(const char *value)
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<HLLStorageType>(HLLStorageType value) {
+	switch(value) {
+	case HLLStorageType::UNCOMPRESSED:
+		return "UNCOMPRESSED";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+HLLStorageType EnumUtil::FromString<HLLStorageType>(const char *value) {
+	if (StringUtil::Equals(value, "UNCOMPRESSED")) {
+		return HLLStorageType::UNCOMPRESSED;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<IndexConstraintType>(IndexConstraintType value) {
 	switch(value) {
@@ -3761,8 +3840,6 @@ const char* EnumUtil::ToChars<ParserMode>(ParserMode value) {
 	switch(value) {
 	case ParserMode::PARSING:
 		return "PARSING";
-	case ParserMode::SNIFFING_DIALECT:
-		return "SNIFFING_DIALECT";
 	case ParserMode::SNIFFING_DATATYPES:
 		return "SNIFFING_DATATYPES";
 	case ParserMode::PARSING_HEADER:
@@ -3777,9 +3854,6 @@ ParserMode EnumUtil::FromString<ParserMode>(const char *value) {
 	if (StringUtil::Equals(value, "PARSING")) {
 		return ParserMode::PARSING;
 	}
-	if (StringUtil::Equals(value, "SNIFFING_DIALECT")) {
-		return ParserMode::SNIFFING_DIALECT;
-	}
 	if (StringUtil::Equals(value, "SNIFFING_DATATYPES")) {
 		return ParserMode::SNIFFING_DATATYPES;
 	}
@@ -3794,6 +3868,8 @@ const char* EnumUtil::ToChars<PartitionSortStage>(PartitionSortStage value) {
 	switch(value) {
 	case PartitionSortStage::INIT:
 		return "INIT";
+	case PartitionSortStage::SCAN:
+		return "SCAN";
 	case PartitionSortStage::PREPARE:
 		return "PREPARE";
 	case PartitionSortStage::MERGE:
@@ -3810,6 +3886,9 @@ PartitionSortStage EnumUtil::FromString<PartitionSortStage>(const char *value) {
 	if (StringUtil::Equals(value, "INIT")) {
 		return PartitionSortStage::INIT;
 	}
+	if (StringUtil::Equals(value, "SCAN")) {
+		return PartitionSortStage::SCAN;
+	}
 	if (StringUtil::Equals(value, "PREPARE")) {
 		return PartitionSortStage::PREPARE;
 	}
@@ -4547,6 +4626,34 @@ QueryResultType EnumUtil::FromString<QueryResultType>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<QuoteRule>(QuoteRule value) {
+	switch(value) {
+	case QuoteRule::QUOTES_RFC:
+		return "QUOTES_RFC";
+	case QuoteRule::QUOTES_OTHER:
+		return "QUOTES_OTHER";
+	case QuoteRule::NO_QUOTES:
+		return "NO_QUOTES";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+QuoteRule EnumUtil::FromString<QuoteRule>(const char *value) {
+	if (StringUtil::Equals(value, "QUOTES_RFC")) {
+		return QuoteRule::QUOTES_RFC;
+	}
+	if (StringUtil::Equals(value, "QUOTES_OTHER")) {
+		return QuoteRule::QUOTES_OTHER;
+	}
+	if (StringUtil::Equals(value, "NO_QUOTES")) {
+		return QuoteRule::NO_QUOTES;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<RelationType>(RelationType value) {
 	switch(value) {
@@ -6009,6 +6116,8 @@ const char* EnumUtil::ToChars<VerificationType>(VerificationType value) {
 		return "DESERIALIZED";
 	case VerificationType::DESERIALIZED_V2:
 		return "DESERIALIZED_V2";
+	case VerificationType::DESERIALIZED_V2_NO_DEFAULT:
+		return "DESERIALIZED_V2_NO_DEFAULT";
 	case VerificationType::PARSED:
 		return "PARSED";
 	case VerificationType::UNOPTIMIZED:
@@ -6040,6 +6149,9 @@ VerificationType EnumUtil::FromString<VerificationType>(const char *value) {
 	if (StringUtil::Equals(value, "DESERIALIZED_V2")) {
 		return VerificationType::DESERIALIZED_V2;
 	}
+	if (StringUtil::Equals(value, "DESERIALIZED_V2_NO_DEFAULT")) {
+		return VerificationType::DESERIALIZED_V2_NO_DEFAULT;
+	}
 	if (StringUtil::Equals(value, "PARSED")) {
 		return VerificationType::PARSED;
 	}

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

@@ -326,9 +326,11 @@ struct EnumTypeInfoTemplated : public EnumTypeInfo {
 		return make_shared<EnumTypeInfoTemplated>(values_insert_order, size);
 	}
 
-	static shared_ptr<EnumTypeInfoTemplated> FormatDeserialize(FormatDeserializer &source, uint32_t size) {
+	static shared_ptr<EnumTypeInfoTemplated> FormatDeserialize(FormatDeserializer &deserializer, uint32_t size) {
 		Vector values_insert_order(LogicalType::VARCHAR, size);
-		values_insert_order.FormatDeserialize(source, size);
+		deserializer.ReadObject(201, "values_insert_order", [&](FormatDeserializer &source) {
+			values_insert_order.FormatDeserialize(source, size);
+		});
 		return make_shared<EnumTypeInfoTemplated>(values_insert_order, size);
 	}
 
@@ -477,7 +479,9 @@ void EnumTypeInfo::Serialize(FieldWriter &writer) const {
 void EnumTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "dict_size", dict_size);
-	((Vector &)values_insert_order).FormatSerialize(serializer, dict_size); // NOLINT - FIXME
+	serializer.WriteObject(201, "values_insert_order", [&](FormatSerializer &serializer) {
+		((Vector &)GetValuesInsertOrder()).FormatSerialize(serializer, dict_size); // NOLINT - FIXME
+	});
 }
 
 } // namespace duckdb