duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

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

@@ -8,6 +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"
 
 namespace duckdb {
 
@@ -41,7 +43,7 @@ static LogicalType StructureStringToType(yyjson_val *val, ClientContext &context
 
 static LogicalType StructureStringToTypeArray(yyjson_val *arr, ClientContext &context) {
 	if (yyjson_arr_size(arr) != 1) {
-		throw InvalidInputException("Too many values in array of JSON structure");
+		throw BinderException("Too many values in array of JSON structure");
 	}
 	return LogicalType::LIST(StructureStringToType(yyjson_arr_get_first(arr), context));
 }
@@ -62,7 +64,7 @@ static LogicalType StructureToTypeObject(yyjson_val *obj, ClientContext &context
 	}
 	D_ASSERT(yyjson_obj_size(obj) == names.size());
 	if (child_types.empty()) {
-		throw InvalidInputException("Empty object in JSON structure");
+		throw BinderException("Empty object in JSON structure");
 	}
 	return LogicalType::STRUCT(child_types);
 }
@@ -76,7 +78,7 @@ static LogicalType StructureStringToType(yyjson_val *val, ClientContext &context
 	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE:
 		return TransformStringToLogicalType(unsafe_yyjson_get_str(val), context);
 	default:
-		throw InvalidInputException("invalid JSON structure");
+		throw BinderException("invalid JSON structure");
 	}
 }
 
@@ -89,20 +91,15 @@ static unique_ptr<FunctionData> JSONTransformBind(ClientContext &context, Scalar
 	if (arguments[1]->return_type == LogicalTypeId::SQLNULL) {
 		bound_function.return_type = LogicalTypeId::SQLNULL;
 	} else if (!arguments[1]->IsFoldable()) {
-		throw InvalidInputException("JSON structure must be a constant!");
+		throw BinderException("JSON structure must be a constant!");
 	} else {
 		auto structure_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
 		if (!structure_val.DefaultTryCastAs(JSONCommon::JSONType())) {
-			throw InvalidInputException("Cannot cast JSON structure to string");
+			throw BinderException("Cannot cast JSON structure to string");
 		}
 		auto structure_string = structure_val.GetValueUnsafe<string_t>();
 		JSONAllocator json_allocator(Allocator::DefaultAllocator());
-		yyjson_read_err err;
-		auto doc =
-		    JSONCommon::ReadDocumentUnsafe(structure_string, JSONCommon::READ_FLAG, json_allocator.GetYYAlc(), &err);
-		if (err.code != YYJSON_READ_SUCCESS) {
-			JSONCommon::ThrowParseError(structure_string.GetData(), structure_string.GetSize(), err);
-		}
+		auto doc = JSONCommon::ReadDocument(structure_string, JSONCommon::READ_FLAG, json_allocator.GetYYAlc());
 		bound_function.return_type = StructureStringToType(doc->root, context);
 	}
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
@@ -114,10 +111,9 @@ static inline string_t GetString(yyjson_val *val) {
 
 template <class T, class OP = TryCast>
 static inline bool GetValueNumerical(yyjson_val *val, T &result, JSONTransformOptions &options) {
+	D_ASSERT(unsafe_yyjson_get_tag(val) != (YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE));
 	bool success;
 	switch (unsafe_yyjson_get_tag(val)) {
-	case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:
-		return false;
 	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE:
 		success = OP::template Operation<string_t, T>(GetString(val), result, options.strict_cast);
 		break;
@@ -150,10 +146,9 @@ static inline bool GetValueNumerical(yyjson_val *val, T &result, JSONTransformOp
 
 template <class T, class OP = TryCastToDecimal>
 static inline bool GetValueDecimal(yyjson_val *val, T &result, uint8_t w, uint8_t s, JSONTransformOptions &options) {
+	D_ASSERT(unsafe_yyjson_get_tag(val) != (YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE));
 	bool success;
 	switch (unsafe_yyjson_get_tag(val)) {
-	case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:
-		return false;
 	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE:
 		success = OP::template Operation<string_t, T>(GetString(val), result, &options.error_message, w, s);
 		break;
@@ -186,9 +181,8 @@ static inline bool GetValueDecimal(yyjson_val *val, T &result, uint8_t w, uint8_
 }
 
 static inline bool GetValueString(yyjson_val *val, yyjson_alc *alc, string_t &result, Vector &vector) {
+	D_ASSERT(unsafe_yyjson_get_tag(val) != (YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE));
 	switch (unsafe_yyjson_get_tag(val)) {
-	case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:
-		return true;
 	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE:
 		result = string_t(unsafe_yyjson_get_str(val), unsafe_yyjson_get_len(val));
 		return true;
@@ -318,26 +312,14 @@ static bool TransformStringWithFormat(Vector &string_vector, StrpTimeFormat &for
 	auto &target_validity = FlatVector::Validity(result);
 
 	bool success = true;
-	if (source_validity.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			if (!OP::template Operation<T>(format, source_strings[i], target_vals[i], options.error_message)) {
-				target_validity.SetInvalid(i);
-				if (success && options.strict_cast) {
-					options.object_index = i;
-					success = false;
-				}
-			}
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			if (!source_validity.RowIsValid(i)) {
-				target_validity.SetInvalid(i);
-			} else if (!OP::template Operation<T>(format, source_strings[i], target_vals[i], options.error_message)) {
-				target_validity.SetInvalid(i);
-				if (success && options.strict_cast) {
-					options.object_index = i;
-					success = false;
-				}
+	for (idx_t i = 0; i < count; i++) {
+		if (!source_validity.RowIsValid(i)) {
+			target_validity.SetInvalid(i);
+		} else if (!OP::template Operation<T>(format, source_strings[i], target_vals[i], options.error_message)) {
+			target_validity.SetInvalid(i);
+			if (success && options.strict_cast) {
+				options.object_index = i;
+				success = false;
 			}
 		}
 	}
@@ -689,6 +671,77 @@ bool TransformToJSON(yyjson_val *vals[], yyjson_alc *alc, Vector &result, const
 	return true;
 }
 
+bool TransformValueIntoUnion(yyjson_val **vals, yyjson_alc *alc, Vector &result, const idx_t count,
+                             JSONTransformOptions &options) {
+	auto type = result.GetType();
+
+	auto fields = UnionType::CopyMemberTypes(type);
+	vector<string> names;
+	for (const auto &field : fields) {
+		names.push_back(field.first);
+	}
+
+	bool success = true;
+
+	auto &validity = FlatVector::Validity(result);
+
+	auto set_error = [&](idx_t i, const string &message) {
+		validity.SetInvalid(i);
+		result.SetValue(i, Value(nullptr));
+		if (success && options.strict_cast) {
+			options.error_message = message;
+			options.object_index = i;
+			success = false;
+		}
+	};
+
+	for (idx_t i = 0; i < count; i++) {
+		const auto &obj = vals[i];
+
+		if (!obj || unsafe_yyjson_is_null(vals[i])) {
+			validity.SetInvalid(i);
+			result.SetValue(i, Value(nullptr));
+			continue;
+		}
+
+		if (!unsafe_yyjson_is_obj(obj)) {
+			set_error(i,
+			          StringUtil::Format("Expected an object representing a union, got %s", yyjson_get_type_desc(obj)));
+			continue;
+		}
+
+		auto len = unsafe_yyjson_get_len(obj);
+		if (len > 1) {
+			set_error(i, "Found object containing more than one key, instead of union");
+			continue;
+		} else if (len == 0) {
+			set_error(i, "Found empty object, instead of union");
+			continue;
+		}
+
+		auto key = unsafe_yyjson_get_first(obj);
+		auto val = yyjson_obj_iter_get_val(key);
+
+		auto tag = std::find(names.begin(), names.end(), unsafe_yyjson_get_str(key));
+		if (tag == names.end()) {
+			set_error(i, StringUtil::Format("Found object containing unknown key, instead of union: %s",
+			                                unsafe_yyjson_get_str(key)));
+			continue;
+		}
+
+		idx_t actual_tag = tag - names.begin();
+
+		Vector single(UnionType::GetMemberType(type, actual_tag), 1);
+		if (!JSONTransform::Transform(&val, alc, single, 1, options)) {
+			success = false;
+		}
+
+		result.SetValue(i, Value::UNION(fields, actual_tag, single.GetValue(0)));
+	}
+
+	return success;
+}
+
 bool JSONTransform::Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &result, const idx_t count,
                               JSONTransformOptions &options) {
 	auto result_type = result.GetType();
@@ -767,8 +820,10 @@ bool JSONTransform::Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &resul
 		return TransformArray(vals, alc, result, count, options);
 	case LogicalTypeId::MAP:
 		return TransformObjectToMap(vals, alc, result, count, options);
+	case LogicalTypeId::UNION:
+		return TransformValueIntoUnion(vals, alc, result, count, options);
 	default:
-		throw InternalException("Unexpected type at JSON Transform %s", result_type.ToString());
+		throw NotImplementedException("Cannot read a value of type %s from a json file", result_type.ToString());
 	}
 }
 

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

@@ -3,7 +3,7 @@
 namespace duckdb {
 
 static inline string_t GetType(yyjson_val *val, yyjson_alc *alc, Vector &result) {
-	return JSONCommon::ValTypeToStringT<yyjson_val>(val);
+	return JSONCommon::ValTypeToStringT(val);
 }
 
 static void UnaryTypeFunction(DataChunk &args, ExpressionState &state, Vector &result) {

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

@@ -12,24 +12,23 @@
 
 namespace duckdb {
 
-static void CheckPath(const Value &path_val, string &path, size_t &len) {
-	string error;
-	Value path_str_val;
+using JSONPathType = JSONCommon::JSONPathType;
+
+static JSONPathType CheckPath(const Value &path_val, string &path, size_t &len) {
 	if (path_val.IsNull()) {
 		throw InvalidInputException("JSON path cannot be NULL");
 	}
-	if (!path_val.DefaultTryCastAs(LogicalType::VARCHAR, path_str_val, &error)) {
-		throw InvalidInputException(error);
-	}
+	const auto path_str_val = path_val.DefaultCastAs(LogicalType::VARCHAR);
 	auto path_str = path_str_val.GetValueUnsafe<string_t>();
 	len = path_str.GetSize();
 	auto ptr = path_str.GetData();
 	// Empty strings and invalid $ paths yield an error
 	if (len == 0) {
-		throw InvalidInputException("Empty JSON path");
+		throw BinderException("Empty JSON path");
 	}
+	JSONPathType path_type = JSONPathType::REGULAR;
 	if (*ptr == '$') {
-		JSONCommon::ValidatePathDollar(ptr, len);
+		path_type = JSONCommon::ValidatePath(ptr, len, true);
 	}
 	// Copy over string to the bind data
 	if (*ptr == '/' || *ptr == '$') {
@@ -38,19 +37,20 @@ static void CheckPath(const Value &path_val, string &path, size_t &len) {
 		path = "/" + string(ptr, len);
 		len++;
 	}
+	return path_type;
 }
 
-JSONReadFunctionData::JSONReadFunctionData(bool constant, string path_p, idx_t len)
-    : constant(constant), path(std::move(path_p)), ptr(path.c_str()), len(len) {
+JSONReadFunctionData::JSONReadFunctionData(bool constant, string path_p, idx_t len, JSONPathType path_type_p)
+    : constant(constant), path(std::move(path_p)), path_type(path_type_p), ptr(path.c_str()), len(len) {
 }
 
 unique_ptr<FunctionData> JSONReadFunctionData::Copy() const {
-	return make_uniq<JSONReadFunctionData>(constant, path, len);
+	return make_uniq<JSONReadFunctionData>(constant, path, len, path_type);
 }
 
 bool JSONReadFunctionData::Equals(const FunctionData &other_p) const {
 	auto &other = (const JSONReadFunctionData &)other_p;
-	return constant == other.constant && path == other.path && len == other.len;
+	return constant == other.constant && path == other.path && len == other.len && path_type == other.path_type;
 }
 
 unique_ptr<FunctionData> JSONReadFunctionData::Bind(ClientContext &context, ScalarFunction &bound_function,
@@ -59,12 +59,16 @@ unique_ptr<FunctionData> JSONReadFunctionData::Bind(ClientContext &context, Scal
 	bool constant = false;
 	string path = "";
 	size_t len = 0;
+	JSONPathType path_type = JSONPathType::REGULAR;
 	if (arguments[1]->return_type.id() != LogicalTypeId::SQLNULL && arguments[1]->IsFoldable()) {
 		constant = true;
 		const auto path_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-		CheckPath(path_val, path, len);
+		path_type = CheckPath(path_val, path, len);
+	}
+	if (path_type == JSONCommon::JSONPathType::WILDCARD) {
+		bound_function.return_type = LogicalType::LIST(bound_function.return_type);
 	}
-	return make_uniq<JSONReadFunctionData>(constant, std::move(path), len);
+	return make_uniq<JSONReadFunctionData>(constant, std::move(path), len, path_type);
 }
 
 JSONReadManyFunctionData::JSONReadManyFunctionData(vector<string> paths_p, vector<size_t> lens_p)
@@ -90,10 +94,7 @@ unique_ptr<FunctionData> JSONReadManyFunctionData::Bind(ClientContext &context,
 		throw ParameterNotResolvedException();
 	}
 	if (!arguments[1]->IsFoldable()) {
-		throw InvalidInputException("List of paths must be constant");
-	}
-	if (arguments[1]->return_type.id() == LogicalTypeId::SQLNULL) {
-		return make_uniq<JSONReadManyFunctionData>(vector<string>(), vector<size_t>());
+		throw BinderException("List of paths must be constant");
 	}
 
 	vector<string> paths;
@@ -102,7 +103,9 @@ unique_ptr<FunctionData> JSONReadManyFunctionData::Bind(ClientContext &context,
 	for (auto &path_val : ListValue::GetChildren(paths_val)) {
 		paths.emplace_back("");
 		lens.push_back(0);
-		CheckPath(path_val, paths.back(), lens.back());
+		if (CheckPath(path_val, paths.back(), lens.back()) == JSONPathType::WILDCARD) {
+			throw BinderException("Cannot have wildcards in JSON path when supplying multiple paths");
+		}
 	}
 
 	return make_uniq<JSONReadManyFunctionData>(std::move(paths), std::move(lens));
@@ -120,11 +123,8 @@ unique_ptr<FunctionLocalState> JSONFunctionLocalState::Init(ExpressionState &sta
 }
 
 unique_ptr<FunctionLocalState> JSONFunctionLocalState::InitCastLocalState(CastLocalStateParameters &parameters) {
-	if (parameters.context) {
-		return make_uniq<JSONFunctionLocalState>(*parameters.context);
-	} else {
-		return make_uniq<JSONFunctionLocalState>(Allocator::DefaultAllocator());
-	}
+	return parameters.context ? make_uniq<JSONFunctionLocalState>(*parameters.context)
+	                          : make_uniq<JSONFunctionLocalState>(Allocator::DefaultAllocator());
 }
 
 JSONFunctionLocalState &JSONFunctionLocalState::ResetAndGet(ExpressionState &state) {
@@ -209,7 +209,8 @@ unique_ptr<TableRef> JSONFunctions::ReadJSONReplacement(ClientContext &context,
 	table_function->function = make_uniq<FunctionExpression>("read_json_auto", std::move(children));
 
 	if (!FileSystem::HasGlob(table_name)) {
-		table_function->alias = FileSystem::ExtractBaseName(table_name);
+		auto &fs = FileSystem::GetFileSystem(context);
+		table_function->alias = fs.ExtractBaseName(table_name);
 	}
 
 	return std::move(table_function);

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

@@ -5,12 +5,22 @@
 #include "duckdb/main/extension_helper.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
 JSONScanData::JSONScanData() {
 }
 
+JSONScanData::JSONScanData(ClientContext &context, vector<string> files_p, string date_format_p,
+                           string timestamp_format_p)
+    : files(std::move(files_p)), date_format(std::move(date_format_p)),
+      timestamp_format(std::move(timestamp_format_p)) {
+	InitializeReaders(context);
+	InitializeFormats();
+}
+
 void JSONScanData::Bind(ClientContext &context, TableFunctionBindInput &input) {
 	auto &info = input.info->Cast<JSONScanInfo>();
 	type = info.type;
@@ -19,7 +29,7 @@ void JSONScanData::Bind(ClientContext &context, TableFunctionBindInput &input) {
 	auto_detect = info.auto_detect;
 
 	for (auto &kv : input.named_parameters) {
-		if (MultiFileReader::ParseOption(kv.first, kv.second, options.file_options)) {
+		if (MultiFileReader::ParseOption(kv.first, kv.second, options.file_options, context)) {
 			continue;
 		}
 		auto loption = StringUtil::Lower(kv.first);
@@ -51,10 +61,7 @@ void JSONScanData::Bind(ClientContext &context, TableFunctionBindInput &input) {
 	}
 
 	files = MultiFileReader::GetFileList(context, input.inputs[0], "JSON");
-
-	if (options.file_options.auto_detect_hive_partitioning) {
-		options.file_options.hive_partitioning = MultiFileReaderOptions::AutoDetectHivePartitioning(files);
-	}
+	options.file_options.AutoDetectHivePartitioning(files, context);
 
 	InitializeReaders(context);
 }
@@ -167,6 +174,26 @@ void JSONScanData::Deserialize(ClientContext &context, FieldReader &reader) {
 	transform_options.date_format_map = &date_format_map;
 }
 
+string JSONScanData::GetDateFormat() const {
+	if (!date_format.empty()) {
+		return date_format;
+	} else if (date_format_map.HasFormats(LogicalTypeId::DATE)) {
+		return date_format_map.GetFormat(LogicalTypeId::DATE).format_specifier;
+	} else {
+		return string();
+	}
+}
+
+string JSONScanData::GetTimestampFormat() const {
+	if (!timestamp_format.empty()) {
+		return timestamp_format;
+	} else if (date_format_map.HasFormats(LogicalTypeId::TIMESTAMP)) {
+		return date_format_map.GetFormat(LogicalTypeId::TIMESTAMP).format_specifier;
+	} else {
+		return string();
+	}
+}
+
 JSONScanGlobalState::JSONScanGlobalState(ClientContext &context, const JSONScanData &bind_data_p)
     : bind_data(bind_data_p), transform_options(bind_data.transform_options),
       allocator(BufferManager::GetBufferManager(context).GetBufferAllocator()),
@@ -236,7 +263,7 @@ unique_ptr<GlobalTableFunctionState> JSONGlobalTableFunctionState::Init(ClientCo
 	for (auto &reader : gstate.json_readers) {
 		MultiFileReader::FinalizeBind(reader->GetOptions().file_options, gstate.bind_data.reader_bind,
 		                              reader->GetFileName(), gstate.names, dummy_types, bind_data.names,
-		                              input.column_ids, reader->reader_data);
+		                              input.column_ids, reader->reader_data, context);
 	}
 
 	return std::move(result);
@@ -969,6 +996,18 @@ unique_ptr<FunctionData> JSONScan::Deserialize(PlanDeserializationState &state,
 	return std::move(result);
 }
 
+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);
+}
+
+unique_ptr<FunctionData> JSONScan::FormatDeserialize(FormatDeserializer &deserializer, TableFunction &function) {
+	unique_ptr<JSONScanData> result;
+	deserializer.ReadProperty(100, "scan_data", result);
+	return std::move(result);
+}
+
 void JSONScan::TableFunctionDefaults(TableFunction &table_function) {
 	MultiFileReader::AddParameters(table_function);
 
@@ -983,6 +1022,8 @@ 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/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

@@ -0,0 +1,92 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_serialization.py
+// 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 "buffered_json_reader.hpp"
+#include "json_transform.hpp"
+#include "json_scan.hpp"
+
+namespace duckdb {
+
+void BufferedJSONReaderOptions::FormatSerialize(FormatSerializer &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 result;
+	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(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>(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;
+	result->reader_bind = reader_bind;
+	result->ignore_errors = ignore_errors;
+	result->maximum_object_size = maximum_object_size;
+	result->auto_detect = auto_detect;
+	result->sample_size = sample_size;
+	result->max_depth = max_depth;
+	result->transform_options = transform_options;
+	result->names = std::move(names);
+	return result;
+}
+
+void JSONTransformOptions::FormatSerialize(FormatSerializer &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);
+	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(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;
+}
+
+} // namespace duckdb