duckdb 0.6.2-dev1971.0 → 0.6.2-dev2015.0

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

@@ -1,19 +1,35 @@
+#include "json_transform.hpp"
+
 #include "duckdb/common/types.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
-#include "json_common.hpp"
 #include "json_functions.hpp"
+#include "json_scan.hpp"
 
 namespace duckdb {
 
+void JSONTransformOptions::Serialize(FieldWriter &writer) {
+	writer.WriteField(strict_cast);
+	writer.WriteField(error_duplicate_key);
+	writer.WriteField(error_missing_key);
+	writer.WriteField(error_unknown_key);
+}
+
+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>();
+}
+
 //! Forward declaration for recursion
-static LogicalType StructureToType(yyjson_val *val, ClientContext &context);
+static LogicalType StructureStringToType(yyjson_val *val, ClientContext &context);
 
-static LogicalType StructureToTypeArray(yyjson_val *arr, 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");
 	}
-	return LogicalType::LIST(StructureToType(yyjson_arr_get_first(arr), context));
+	return LogicalType::LIST(StructureStringToType(yyjson_arr_get_first(arr), context));
 }
 
 static LogicalType StructureToTypeObject(yyjson_val *obj, ClientContext &context) {
@@ -23,25 +39,25 @@ static LogicalType StructureToTypeObject(yyjson_val *obj, ClientContext &context
 	yyjson_val *key, *val;
 	yyjson_obj_foreach(obj, idx, max, key, val) {
 		val = yyjson_obj_iter_get_val(key);
-		auto key_str = yyjson_get_str(key);
+		auto key_str = unsafe_yyjson_get_str(key);
 		if (names.find(key_str) != names.end()) {
 			JSONCommon::ThrowValFormatError("Duplicate keys in object in JSON structure: %s", val);
 		}
 		names.insert(key_str);
-		child_types.emplace_back(key_str, StructureToType(val, context));
+		child_types.emplace_back(key_str, StructureStringToType(val, context));
 	}
 	D_ASSERT(yyjson_obj_size(obj) == names.size());
 	return LogicalType::STRUCT(child_types);
 }
 
-static LogicalType StructureToType(yyjson_val *val, ClientContext &context) {
+static LogicalType StructureStringToType(yyjson_val *val, ClientContext &context) {
 	switch (yyjson_get_tag(val)) {
 	case YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE:
-		return StructureToTypeArray(val, context);
+		return StructureStringToTypeArray(val, context);
 	case YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE:
 		return StructureToTypeObject(val, context);
 	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE:
-		return TransformStringToLogicalType(yyjson_get_str(val), context);
+		return TransformStringToLogicalType(unsafe_yyjson_get_str(val), context);
 	default:
 		throw InvalidInputException("invalid JSON structure");
 	}
@@ -70,7 +86,7 @@ static unique_ptr<FunctionData> JSONTransformBind(ClientContext &context, Scalar
 		if (err.code != YYJSON_READ_SUCCESS) {
 			JSONCommon::ThrowParseError(structure_string.GetDataUnsafe(), structure_string.GetSize(), err);
 		}
-		bound_function.return_type = StructureToType(doc->root, context);
+		bound_function.return_type = StructureStringToType(doc->root, context);
 	}
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
@@ -155,7 +171,7 @@ static inline bool GetValueString(yyjson_val *val, yyjson_alc *alc, string_t &re
 	case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:
 		return false;
 	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE:
-		result = StringVector::AddString(vector, unsafe_yyjson_get_str(val), unsafe_yyjson_get_len(val));
+		result = string_t(unsafe_yyjson_get_str(val), unsafe_yyjson_get_len(val));
 		return true;
 	case YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE:
 	case YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE:
@@ -179,9 +195,6 @@ static inline bool GetValueString(yyjson_val *val, yyjson_alc *alc, string_t &re
 	}
 }
 
-//! Forward declaration for recursion
-static void Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &result, const idx_t count, bool strict);
-
 template <class T>
 static void TransformNumerical(yyjson_val *vals[], Vector &result, const idx_t count, const bool strict) {
 	auto data = (T *)FlatVector::GetData(result);
@@ -207,9 +220,8 @@ static void TransformDecimal(yyjson_val *vals[], Vector &result, const idx_t cou
 	}
 }
 
-static void TransformFromString(yyjson_val *vals[], Vector &result, const idx_t count, const LogicalType &target,
-                                const bool strict) {
-	Vector string_vector(LogicalTypeId::VARCHAR, count);
+void JSONTransform::GetStringVector(yyjson_val *vals[], const idx_t count, const LogicalType &target,
+                                    Vector &string_vector, const bool strict) {
 	auto data = (string_t *)FlatVector::GetData(string_vector);
 	auto &validity = FlatVector::Validity(string_vector);
 
@@ -223,6 +235,11 @@ static void TransformFromString(yyjson_val *vals[], Vector &result, const idx_t
 			data[i] = GetString(val);
 		}
 	}
+}
+
+static void TransformFromString(yyjson_val *vals[], Vector &result, const idx_t count, const bool strict) {
+	Vector string_vector(LogicalTypeId::VARCHAR, count);
+	JSONTransform::GetStringVector(vals, count, result.GetType(), string_vector, strict);
 
 	string error_message;
 	if (!VectorOperations::DefaultTryCast(string_vector, result, count, &error_message, strict) && strict) {
@@ -230,6 +247,63 @@ static void TransformFromString(yyjson_val *vals[], Vector &result, const idx_t
 	}
 }
 
+template <class OP, class T>
+static bool TransformStringWithFormat(Vector &string_vector, StrpTimeFormat &format, const idx_t count, Vector &result,
+                                      string &error_message) {
+	const auto source_strings = FlatVector::GetData<string_t>(string_vector);
+	const auto &source_validity = FlatVector::Validity(string_vector);
+
+	auto target_vals = FlatVector::GetData<T>(result);
+	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], error_message)) {
+				target_validity.SetInvalid(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], error_message)) {
+				target_validity.SetInvalid(i);
+				success = false;
+			}
+		}
+	}
+	return success;
+}
+
+static void TransformFromStringWithFormat(yyjson_val *vals[], Vector &result, const idx_t count,
+                                          const JSONTransformOptions &options) {
+	Vector string_vector(LogicalTypeId::VARCHAR, count);
+	JSONTransform::GetStringVector(vals, count, result.GetType(), string_vector, options.strict_cast);
+
+	const auto &result_type = result.GetType().id();
+	auto &format = options.date_format_map->GetFormat(result_type);
+
+	bool success;
+	string error_message;
+	switch (result_type) {
+	case LogicalTypeId::DATE:
+		success = TransformStringWithFormat<TryParseDate, date_t>(string_vector, format, count, result, error_message);
+		break;
+	case LogicalTypeId::TIMESTAMP:
+		success = TransformStringWithFormat<TryParseTimeStamp, timestamp_t>(string_vector, format, count, result,
+		                                                                    error_message);
+		break;
+	default:
+		throw InternalException("No date/timestamp formats for %s", LogicalTypeIdToString(result.GetType().id()));
+	}
+
+	if (options.strict_cast && !success) {
+		throw CastException(error_message);
+	}
+}
+
 static void TransformToString(yyjson_val *vals[], yyjson_alc *alc, Vector &result, const idx_t count) {
 	auto data = (string_t *)FlatVector::GetData(result);
 	auto &validity = FlatVector::Validity(result);
@@ -241,44 +315,118 @@ static void TransformToString(yyjson_val *vals[], yyjson_alc *alc, Vector &resul
 	}
 }
 
-static void TransformObject(yyjson_val *vals[], yyjson_alc *alc, Vector &result, const idx_t count,
-                            const LogicalType &type, bool strict) {
-	// Initialize array for the nested values
-	auto nested_vals_ptr = unique_ptr<yyjson_val *[]>(new yyjson_val *[count]);
-	auto nested_vals = nested_vals_ptr.get();
-	// Loop through child types
+static void Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &result, const idx_t count,
+                      const JSONTransformOptions &options);
+
+void JSONTransform::TransformObject(yyjson_val *objects[], yyjson_alc *alc, const idx_t count,
+                                    const vector<string> &names, const vector<Vector *> &result_vectors,
+                                    const JSONTransformOptions &options) {
+	D_ASSERT(alc);
+	D_ASSERT(names.size() == result_vectors.size());
+	const idx_t column_count = names.size();
+
+	// Build hash map from key to column index so we don't have to linearly search using the key
+	json_key_map_t<idx_t> key_map;
+	vector<yyjson_val **> nested_vals;
+	nested_vals.reserve(column_count);
+	for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
+		key_map.insert({{names[col_idx].c_str(), names[col_idx].length()}, col_idx});
+		nested_vals.push_back((yyjson_val **)alc->malloc(alc->ctx, sizeof(yyjson_val *) * count));
+	}
+
+	idx_t found_key_count;
+	auto found_keys = (bool *)alc->malloc(alc->ctx, sizeof(bool) * column_count);
+
+	size_t idx, max;
+	yyjson_val *key, *val;
+	for (idx_t i = 0; i < count; i++) {
+		if (objects[i]) {
+			found_key_count = 0;
+			memset(found_keys, false, column_count);
+			yyjson_obj_foreach(objects[i], idx, max, key, val) {
+				auto key_ptr = yyjson_get_str(key);
+				auto key_len = yyjson_get_len(key);
+				auto it = key_map.find({key_ptr, key_len});
+				if (it != key_map.end()) {
+					const auto &col_idx = it->second;
+					if (options.error_duplicate_key && found_keys[col_idx]) {
+						JSONCommon::ThrowValFormatError(
+						    "Duplicate key \"" + string(key_ptr, key_len) + "\" in object %s", objects[i]);
+					}
+					nested_vals[col_idx][i] = val;
+					found_keys[col_idx] = true;
+					if (++found_key_count == column_count) {
+						break;
+					}
+				} else if (options.error_unknown_key) {
+					JSONCommon::ThrowValFormatError("Object %s has unknown key \"" + string(key_ptr, key_len) + "\"",
+					                                objects[i]);
+				}
+			}
+			if (found_key_count != column_count) {
+				// If 'error_missing_key, we throw an error if one of the keys was not found.
+				// If not, we set the nested val to null so the recursion doesn't break
+				for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
+					if (!found_keys[col_idx]) {
+						if (options.error_missing_key) {
+							JSONCommon::ThrowValFormatError("Object %s does not have key \"" + names[col_idx] + "\"",
+							                                objects[i]);
+						} else {
+							nested_vals[col_idx][i] = nullptr;
+						}
+					}
+				}
+			}
+		} else {
+			// Set nested val to null so the recursion doesn't break
+			for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
+				nested_vals[col_idx][i] = nullptr;
+			}
+		}
+	}
+
+	for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
+		Transform(nested_vals[col_idx], alc, *result_vectors[col_idx], count, options);
+	}
+}
+
+static void TransformObject(yyjson_val *objects[], yyjson_alc *alc, Vector &result, const idx_t count,
+                            const LogicalType &type, const JSONTransformOptions &options) {
+	// Get child vectors and names
 	auto &child_vs = StructVector::GetEntries(result);
+	vector<string> child_names;
+	vector<Vector *> child_vectors;
+	child_names.reserve(child_vs.size());
+	child_vectors.reserve(child_vs.size());
 	for (idx_t child_i = 0; child_i < child_vs.size(); child_i++) {
-		const auto &name = StructType::GetChildName(type, child_i);
-		auto name_ptr = name.c_str();
-		auto name_len = name.size();
-		for (idx_t i = 0; i < count; i++) {
-			nested_vals[i] = yyjson_obj_getn(vals[i], name_ptr, name_len);
-		}
-		// Transform child values
-		Transform(nested_vals, alc, *child_vs[child_i], count, strict);
+		child_names.push_back(StructType::GetChildName(type, child_i));
+		child_vectors.push_back(child_vs[child_i].get());
 	}
+
+	JSONTransform::TransformObject(objects, alc, count, child_names, child_vectors, options);
 }
 
-static void TransformArray(yyjson_val *vals[], yyjson_alc *alc, Vector &result, const idx_t count, bool strict) {
+static void TransformArray(yyjson_val *arrays[], yyjson_alc *alc, Vector &result, const idx_t count,
+                           const JSONTransformOptions &options) {
 	// Initialize list vector
 	auto list_entries = FlatVector::GetData<list_entry_t>(result);
 	auto &list_validity = FlatVector::Validity(result);
 	idx_t offset = 0;
 	for (idx_t i = 0; i < count; i++) {
-		if (!vals[i] || yyjson_is_null(vals[i])) {
+		if (!arrays[i] || yyjson_is_null(arrays[i])) {
 			list_validity.SetInvalid(i);
 		}
 		auto &entry = list_entries[i];
 		entry.offset = offset;
-		entry.length = yyjson_arr_size(vals[i]);
+		entry.length = yyjson_arr_size(arrays[i]);
 		offset += entry.length;
 	}
 	ListVector::SetListSize(result, offset);
 	ListVector::Reserve(result, offset);
+
 	// Initialize array for the nested values
-	auto nested_vals_ptr = unique_ptr<yyjson_val *[]>(new yyjson_val *[offset]);
-	auto nested_vals = nested_vals_ptr.get();
+	auto nested_vals = (yyjson_val **)alc->malloc(alc->ctx, sizeof(yyjson_val *) * offset);
+
 	// Get array values
 	size_t idx, max;
 	yyjson_val *val;
@@ -288,57 +436,63 @@ static void TransformArray(yyjson_val *vals[], yyjson_alc *alc, Vector &result,
 			// We already marked this as invalid
 			continue;
 		}
-		yyjson_arr_foreach(vals[i], idx, max, val) {
+		yyjson_arr_foreach(arrays[i], idx, max, val) {
 			nested_vals[list_i] = val;
 			list_i++;
 		}
 	}
 	D_ASSERT(list_i == offset);
 	// Transform array values
-	Transform(nested_vals, alc, ListVector::GetEntry(result), offset, strict);
+	Transform(nested_vals, alc, ListVector::GetEntry(result), offset, options);
 }
 
-static void Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &result, const idx_t count, bool strict) {
+static void Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &result, const idx_t count,
+                      const JSONTransformOptions &options) {
 	auto result_type = result.GetType();
+	if (options.date_format_map && (result_type == LogicalTypeId::TIMESTAMP || result_type == LogicalTypeId::DATE)) {
+		TransformFromStringWithFormat(vals, result, count, options);
+		return;
+	}
+
 	switch (result_type.id()) {
 	case LogicalTypeId::SQLNULL:
 		return;
 	case LogicalTypeId::BOOLEAN:
-		return TransformNumerical<bool>(vals, result, count, strict);
+		return TransformNumerical<bool>(vals, result, count, options.strict_cast);
 	case LogicalTypeId::TINYINT:
-		return TransformNumerical<int8_t>(vals, result, count, strict);
+		return TransformNumerical<int8_t>(vals, result, count, options.strict_cast);
 	case LogicalTypeId::SMALLINT:
-		return TransformNumerical<int16_t>(vals, result, count, strict);
+		return TransformNumerical<int16_t>(vals, result, count, options.strict_cast);
 	case LogicalTypeId::INTEGER:
-		return TransformNumerical<int32_t>(vals, result, count, strict);
+		return TransformNumerical<int32_t>(vals, result, count, options.strict_cast);
 	case LogicalTypeId::BIGINT:
-		return TransformNumerical<int64_t>(vals, result, count, strict);
+		return TransformNumerical<int64_t>(vals, result, count, options.strict_cast);
 	case LogicalTypeId::UTINYINT:
-		return TransformNumerical<uint8_t>(vals, result, count, strict);
+		return TransformNumerical<uint8_t>(vals, result, count, options.strict_cast);
 	case LogicalTypeId::USMALLINT:
-		return TransformNumerical<uint16_t>(vals, result, count, strict);
+		return TransformNumerical<uint16_t>(vals, result, count, options.strict_cast);
 	case LogicalTypeId::UINTEGER:
-		return TransformNumerical<uint32_t>(vals, result, count, strict);
+		return TransformNumerical<uint32_t>(vals, result, count, options.strict_cast);
 	case LogicalTypeId::UBIGINT:
-		return TransformNumerical<uint64_t>(vals, result, count, strict);
+		return TransformNumerical<uint64_t>(vals, result, count, options.strict_cast);
 	case LogicalTypeId::HUGEINT:
-		return TransformNumerical<hugeint_t>(vals, result, count, strict);
+		return TransformNumerical<hugeint_t>(vals, result, count, options.strict_cast);
 	case LogicalTypeId::FLOAT:
-		return TransformNumerical<float>(vals, result, count, strict);
+		return TransformNumerical<float>(vals, result, count, options.strict_cast);
 	case LogicalTypeId::DOUBLE:
-		return TransformNumerical<double>(vals, result, count, strict);
+		return TransformNumerical<double>(vals, result, count, options.strict_cast);
 	case LogicalTypeId::DECIMAL: {
 		auto width = DecimalType::GetWidth(result_type);
 		auto scale = DecimalType::GetScale(result_type);
 		switch (result_type.InternalType()) {
 		case PhysicalType::INT16:
-			return TransformDecimal<int16_t>(vals, result, count, width, scale, strict);
+			return TransformDecimal<int16_t>(vals, result, count, width, scale, options.strict_cast);
 		case PhysicalType::INT32:
-			return TransformDecimal<int32_t>(vals, result, count, width, scale, strict);
+			return TransformDecimal<int32_t>(vals, result, count, width, scale, options.strict_cast);
 		case PhysicalType::INT64:
-			return TransformDecimal<int64_t>(vals, result, count, width, scale, strict);
+			return TransformDecimal<int64_t>(vals, result, count, width, scale, options.strict_cast);
 		case PhysicalType::INT128:
-			return TransformDecimal<hugeint_t>(vals, result, count, width, scale, strict);
+			return TransformDecimal<hugeint_t>(vals, result, count, width, scale, options.strict_cast);
 		default:
 			throw InternalException("Unimplemented physical type for decimal");
 		}
@@ -355,14 +509,14 @@ static void Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &result, const
 	case LogicalTypeId::TIMESTAMP_MS:
 	case LogicalTypeId::TIMESTAMP_SEC:
 	case LogicalTypeId::UUID:
-		return TransformFromString(vals, result, count, result_type, strict);
+		return TransformFromString(vals, result, count, options.strict_cast);
 	case LogicalTypeId::VARCHAR:
 	case LogicalTypeId::BLOB:
 		return TransformToString(vals, alc, result, count);
 	case LogicalTypeId::STRUCT:
-		return TransformObject(vals, alc, result, count, result_type, strict);
+		return TransformObject(vals, alc, result, count, result_type, options);
 	case LogicalTypeId::LIST:
-		return TransformArray(vals, alc, result, count, strict);
+		return TransformArray(vals, alc, result, count, options);
 	default:
 		throw InternalException("Unexpected type at JSON Transform %s", result_type.ToString());
 	}
@@ -393,8 +547,10 @@ static void TransformFunction(DataChunk &args, ExpressionState &state, Vector &r
 			vals[i] = docs[i]->root;
 		}
 	}
-	// Transform
-	Transform(vals, alc, result, count, strict);
+
+	const JSONTransformOptions options {strict, strict, strict, false, nullptr};
+
+	Transform(vals, alc, result, count, options);
 
 	if (args.AllConstant()) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);

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

@@ -0,0 +1,224 @@
+#include "json_functions.hpp"
+#include "json_scan.hpp"
+#include "json_structure.hpp"
+#include "json_transform.hpp"
+
+namespace duckdb {
+
+void AutoDetect(ClientContext &context, JSONScanData &bind_data, vector<LogicalType> &return_types,
+                vector<string> &names) {
+	auto original_scan_type = bind_data.type;
+	bind_data.type = JSONScanType::SAMPLE; // Set scan type to sample for the auto-detect, we restore it later
+	JSONScanGlobalState gstate(context, bind_data);
+	JSONScanLocalState lstate(context, gstate);
+	ArenaAllocator allocator(BufferAllocator::Get(context));
+
+	static const unordered_map<LogicalTypeId, vector<const char *>, LogicalTypeIdHash> FORMAT_TEMPLATES = {
+	    {LogicalTypeId::DATE, {"%m-%d-%Y", "%m-%d-%y", "%d-%m-%Y", "%d-%m-%y", "%Y-%m-%d", "%y-%m-%d"}},
+	    {LogicalTypeId::TIMESTAMP,
+	     {"%Y-%m-%d %H:%M:%S.%f", "%m-%d-%Y %I:%M:%S %p", "%m-%d-%y %I:%M:%S %p", "%d-%m-%Y %H:%M:%S",
+	      "%d-%m-%y %H:%M:%S", "%Y-%m-%d %H:%M:%S", "%y-%m-%d %H:%M:%S"}},
+	};
+
+	// Populate possible date/timestamp formats, assume this is consistent across columns
+	bind_data.date_format_map.Initialize(FORMAT_TEMPLATES);
+
+	// Read for the specified sample size
+	JSONStructureNode node;
+	Vector string_vector(LogicalType::VARCHAR);
+	idx_t read = 0;
+	while (read < bind_data.sample_size) {
+		allocator.Reset();
+		auto count = lstate.ReadNext(gstate);
+		if (count == 0) {
+			break;
+		}
+		idx_t i;
+		for (i = 0; i < count; i++) {
+			if (lstate.objects[i]) {
+				JSONStructure::ExtractStructure(lstate.objects[i], node);
+			}
+			if (++read == bind_data.sample_size) {
+				break;
+			}
+		}
+		if (!node.ContainsVarchar()) { // Can't refine non-VARCHAR types
+			continue;
+		}
+		node.InitializeCandidateTypes(bind_data.max_depth);
+		node.RefineCandidateTypes(lstate.objects, i, string_vector, allocator, bind_data.date_format_map);
+	}
+	bind_data.type = original_scan_type;
+	bind_data.transform_options.date_format_map = &bind_data.date_format_map;
+
+	const auto type = JSONStructure::StructureToType(context, node, bind_data.max_depth);
+	if (type.id() != LogicalTypeId::STRUCT) {
+		return_types.emplace_back(type);
+		names.emplace_back("json");
+		return;
+	}
+
+	const auto &child_types = StructType::GetChildTypes(type);
+	return_types.reserve(child_types.size());
+	names.reserve(child_types.size());
+	for (auto &child_type : child_types) {
+		return_types.emplace_back(child_type.second);
+		names.emplace_back(child_type.first);
+	}
+
+	for (auto &reader : gstate.json_readers) {
+		if (reader->IsOpen()) {
+			reader->Reset();
+		}
+	}
+	bind_data.stored_readers = std::move(gstate.json_readers);
+}
+
+unique_ptr<FunctionData> ReadJSONBind(ClientContext &context, TableFunctionBindInput &input,
+                                      vector<LogicalType> &return_types, vector<string> &names) {
+	// First bind default params
+	auto result = JSONScanData::Bind(context, input);
+	auto &bind_data = (JSONScanData &)*result;
+
+	for (auto &kv : input.named_parameters) {
+		auto loption = StringUtil::Lower(kv.first);
+		if (loption == "columns") {
+			auto &child_type = kv.second.type();
+			if (child_type.id() != LogicalTypeId::STRUCT) {
+				throw BinderException("read_json \"columns\" parameter requires a struct as input");
+			}
+			auto &struct_children = StructValue::GetChildren(kv.second);
+			D_ASSERT(StructType::GetChildCount(child_type) == struct_children.size());
+			for (idx_t i = 0; i < struct_children.size(); i++) {
+				auto &name = StructType::GetChildName(child_type, i);
+				auto &val = struct_children[i];
+				names.push_back(name);
+				if (val.type().id() != LogicalTypeId::VARCHAR) {
+					throw BinderException("read_json \"columns\" parameter type specification must be VARCHAR");
+				}
+				return_types.emplace_back(TransformStringToLogicalType(StringValue::Get(val), context));
+			}
+			D_ASSERT(names.size() == return_types.size());
+			if (names.empty()) {
+				throw BinderException("read_json \"columns\" parameter needs at least one column");
+			}
+			bind_data.names = names;
+		} else if (loption == "auto_detect") {
+			bind_data.auto_detect = BooleanValue::Get(kv.second);
+		} else if (loption == "sample_size") {
+			auto arg = BigIntValue::Get(kv.second);
+			if (arg == -1) {
+				bind_data.sample_size = NumericLimits<idx_t>::Maximum();
+			} else if (arg > 0) {
+				bind_data.sample_size = arg;
+			} else {
+				throw BinderException(
+				    "read_json \"sample_size\" parameter must be positive, or -1 to sample the entire file");
+			}
+		} else if (loption == "maximum_depth") {
+			auto arg = BigIntValue::Get(kv.second);
+			if (arg == -1) {
+				bind_data.max_depth = NumericLimits<idx_t>::Maximum();
+			} else {
+				bind_data.max_depth = arg;
+			}
+		}
+	}
+
+	if (!bind_data.names.empty()) {
+		bind_data.auto_detect = false; // override auto-detect when columns are specified
+	} else if (!bind_data.auto_detect) {
+		throw BinderException("read_json \"columns\" parameter is required when auto_detect is false");
+	}
+
+	if (bind_data.auto_detect) {
+		AutoDetect(context, bind_data, return_types, names);
+		bind_data.names = names;
+	}
+
+	auto &transform_options = bind_data.transform_options;
+	transform_options.strict_cast = !bind_data.ignore_errors;
+	transform_options.error_duplicate_key = !bind_data.ignore_errors;
+	transform_options.error_missing_key = false;
+	transform_options.error_unknown_key = bind_data.auto_detect && !bind_data.ignore_errors;
+
+	return result;
+}
+
+static void ReadJSONFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &gstate = ((JSONGlobalTableFunctionState &)*data_p.global_state).state;
+	auto &lstate = ((JSONLocalTableFunctionState &)*data_p.local_state).state;
+	D_ASSERT(output.ColumnCount() == gstate.bind_data.names.size());
+
+	// Fetch next lines
+	const auto count = lstate.ReadNext(gstate);
+	const auto objects = lstate.objects;
+
+	vector<Vector *> result_vectors;
+	result_vectors.reserve(output.ColumnCount());
+	for (idx_t col_idx = 0; col_idx < output.ColumnCount(); col_idx++) {
+		result_vectors.push_back(&output.data[col_idx]);
+	}
+
+	// TODO: if errors occur during transformation, we don't have line number information
+	JSONTransform::TransformObject(objects, lstate.GetAllocator(), count, gstate.bind_data.names, result_vectors,
+	                               gstate.bind_data.transform_options);
+	output.SetCardinality(count);
+}
+
+TableFunction GetReadJSONTableFunction(bool list_parameter, shared_ptr<JSONScanInfo> function_info) {
+	auto parameter = list_parameter ? LogicalType::LIST(LogicalType::VARCHAR) : LogicalType::VARCHAR;
+	TableFunction table_function({parameter}, ReadJSONFunction, ReadJSONBind, JSONGlobalTableFunctionState::Init,
+	                             JSONLocalTableFunctionState::Init);
+
+	JSONScan::TableFunctionDefaults(table_function);
+	table_function.named_parameters["columns"] = LogicalType::ANY;
+	table_function.named_parameters["auto_detect"] = LogicalType::BOOLEAN;
+	table_function.named_parameters["sample_size"] = LogicalType::BIGINT;
+
+	table_function.projection_pushdown = true;
+
+	table_function.function_info = std::move(function_info);
+
+	return table_function;
+}
+
+TableFunction GetReadJSONAutoTableFunction(bool list_parameter, shared_ptr<JSONScanInfo> function_info) {
+	auto table_function = GetReadJSONTableFunction(list_parameter, std::move(function_info));
+	table_function.named_parameters["maximum_depth"] = LogicalType::BIGINT;
+	return table_function;
+}
+
+CreateTableFunctionInfo JSONFunctions::GetReadJSONFunction() {
+	TableFunctionSet function_set("read_json");
+	auto function_info = make_shared<JSONScanInfo>(JSONScanType::READ_JSON, JSONFormat::UNSTRUCTURED, false);
+	function_set.AddFunction(GetReadJSONTableFunction(false, function_info));
+	function_set.AddFunction(GetReadJSONTableFunction(true, function_info));
+	return CreateTableFunctionInfo(function_set);
+}
+
+CreateTableFunctionInfo JSONFunctions::GetReadNDJSONFunction() {
+	TableFunctionSet function_set("read_ndjson");
+	auto function_info = make_shared<JSONScanInfo>(JSONScanType::READ_JSON, JSONFormat::NEWLINE_DELIMITED, false);
+	function_set.AddFunction(GetReadJSONTableFunction(false, function_info));
+	function_set.AddFunction(GetReadJSONTableFunction(true, function_info));
+	return CreateTableFunctionInfo(function_set);
+}
+
+CreateTableFunctionInfo JSONFunctions::GetReadJSONAutoFunction() {
+	TableFunctionSet function_set("read_json_auto");
+	auto function_info = make_shared<JSONScanInfo>(JSONScanType::READ_JSON, JSONFormat::AUTO_DETECT, true);
+	function_set.AddFunction(GetReadJSONAutoTableFunction(false, function_info));
+	function_set.AddFunction(GetReadJSONAutoTableFunction(true, function_info));
+	return CreateTableFunctionInfo(function_set);
+}
+
+CreateTableFunctionInfo JSONFunctions::GetReadNDJSONAutoFunction() {
+	TableFunctionSet function_set("read_ndjson_auto");
+	auto function_info = make_shared<JSONScanInfo>(JSONScanType::READ_JSON, JSONFormat::NEWLINE_DELIMITED, true);
+	function_set.AddFunction(GetReadJSONAutoTableFunction(false, function_info));
+	function_set.AddFunction(GetReadJSONAutoTableFunction(true, function_info));
+	return CreateTableFunctionInfo(function_set);
+}
+
+} // namespace duckdb