duckdb 1.3.3-dev0.0 → 1.3.3-dev4.0

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

@@ -1,22 +1,17 @@
-#define DUCKDB_EXTENSION_MAIN
 #include "json_extension.hpp"
 
+#include "json_common.hpp"
+#include "json_functions.hpp"
+
 #include "duckdb/catalog/catalog_entry/macro_catalog_entry.hpp"
 #include "duckdb/catalog/default/default_functions.hpp"
-#include "duckdb/common/string_util.hpp"
 #include "duckdb/function/copy_function.hpp"
-#include "duckdb/main/extension_util.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/main/extension/extension_loader.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "json_common.hpp"
-#include "json_functions.hpp"
 
 namespace duckdb {
 
-static DefaultMacro json_macros[] = {
+static const DefaultMacro JSON_MACROS[] = {
     {DEFAULT_SCHEMA,
      "json_group_array",
      {"x", nullptr},
@@ -36,53 +31,56 @@ static DefaultMacro json_macros[] = {
     {DEFAULT_SCHEMA, "json", {"x", nullptr}, {{nullptr, nullptr}}, "json_extract(x, '$')"},
     {nullptr, nullptr, {nullptr}, {{nullptr, nullptr}}, nullptr}};
 
-void JsonExtension::Load(DuckDB &db) {
-	auto &db_instance = *db.instance;
+static void LoadInternal(ExtensionLoader &loader) {
 	// JSON type
 	auto json_type = LogicalType::JSON();
-	ExtensionUtil::RegisterType(db_instance, LogicalType::JSON_TYPE_NAME, std::move(json_type));
+	loader.RegisterType(LogicalType::JSON_TYPE_NAME, std::move(json_type));
 
 	// JSON casts
-	JSONFunctions::RegisterSimpleCastFunctions(DBConfig::GetConfig(db_instance).GetCastFunctions());
-	JSONFunctions::RegisterJSONCreateCastFunctions(DBConfig::GetConfig(db_instance).GetCastFunctions());
-	JSONFunctions::RegisterJSONTransformCastFunctions(DBConfig::GetConfig(db_instance).GetCastFunctions());
+	JSONFunctions::RegisterSimpleCastFunctions(loader);
+	JSONFunctions::RegisterJSONCreateCastFunctions(loader);
+	JSONFunctions::RegisterJSONTransformCastFunctions(loader);
 
 	// JSON scalar functions
 	for (auto &fun : JSONFunctions::GetScalarFunctions()) {
-		ExtensionUtil::RegisterFunction(db_instance, fun);
+		loader.RegisterFunction(fun);
 	}
 
 	// JSON table functions
 	for (auto &fun : JSONFunctions::GetTableFunctions()) {
-		ExtensionUtil::RegisterFunction(db_instance, fun);
+		loader.RegisterFunction(fun);
 	}
 
 	// JSON pragma functions
 	for (auto &fun : JSONFunctions::GetPragmaFunctions()) {
-		ExtensionUtil::RegisterFunction(db_instance, fun);
+		loader.RegisterFunction(fun);
 	}
 
 	// JSON replacement scan
-	auto &config = DBConfig::GetConfig(*db.instance);
-	config.replacement_scans.emplace_back(JSONFunctions::ReadJSONReplacement);
+	DBConfig::GetConfig(loader.GetDatabaseInstance())
+	    .replacement_scans.emplace_back(JSONFunctions::ReadJSONReplacement);
 
 	// JSON copy function
 	auto copy_fun = JSONFunctions::GetJSONCopyFunction();
-	ExtensionUtil::RegisterFunction(db_instance, copy_fun);
+	loader.RegisterFunction(copy_fun);
 	copy_fun.extension = "ndjson";
 	copy_fun.name = "ndjson";
-	ExtensionUtil::RegisterFunction(db_instance, copy_fun);
+	loader.RegisterFunction(copy_fun);
 	copy_fun.extension = "jsonl";
 	copy_fun.name = "jsonl";
-	ExtensionUtil::RegisterFunction(db_instance, copy_fun);
+	loader.RegisterFunction(copy_fun);
 
 	// JSON macro's
-	for (idx_t index = 0; json_macros[index].name != nullptr; index++) {
-		auto info = DefaultFunctionGenerator::CreateInternalMacroInfo(json_macros[index]);
-		ExtensionUtil::RegisterFunction(db_instance, *info);
+	for (idx_t index = 0; JSON_MACROS[index].name != nullptr; index++) {
+		auto info = DefaultFunctionGenerator::CreateInternalMacroInfo(JSON_MACROS[index]);
+		loader.RegisterFunction(*info);
 	}
 }
 
+void JsonExtension::Load(ExtensionLoader &loader) {
+	LoadInternal(loader);
+}
+
 std::string JsonExtension::Name() {
 	return "json";
 }
@@ -99,16 +97,7 @@ std::string JsonExtension::Version() const {
 
 extern "C" {
 
-DUCKDB_EXTENSION_API void json_init(duckdb::DatabaseInstance &db) {
-	duckdb::DuckDB db_wrapper(db);
-	db_wrapper.LoadExtension<duckdb::JsonExtension>();
-}
-
-DUCKDB_EXTENSION_API const char *json_version() {
-	return duckdb::DuckDB::LibraryVersion();
+DUCKDB_CPP_EXTENSION_ENTRY(json, loader) {
+	duckdb::LoadInternal(loader);
 }
 }
-
-#ifndef DUCKDB_EXTENSION_MAIN
-#error DUCKDB_EXTENSION_MAIN not defined
-#endif

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

@@ -18,6 +18,13 @@ static void ThrowJSONCopyParameterException(const string &loption) {
 }
 
 static BoundStatement CopyToJSONPlan(Binder &binder, CopyStatement &stmt) {
+	static const unordered_set<string> SUPPORTED_BASE_OPTIONS {
+	    "compression", "encoding", "use_tmp_file", "overwrite_or_ignore", "overwrite", "append", "filename_pattern",
+	    "file_extension", "per_thread_output", "file_size_bytes",
+	    // "partition_by", unsupported
+	    "return_files", "preserve_order", "return_stats", "write_partition_columns", "write_empty_file",
+	    "hive_file_pattern"};
+
 	auto stmt_copy = stmt.Copy();
 	auto &copy = stmt_copy->Cast<CopyStatement>();
 	auto &copied_info = *copy.info;
@@ -48,9 +55,7 @@ static BoundStatement CopyToJSONPlan(Binder &binder, CopyStatement &stmt) {
 				csv_copy_options["suffix"] = {"\n]\n"};
 				csv_copy_options["new_line"] = {",\n\t"};
 			}
-		} else if (loption == "compression" || loption == "encoding" || loption == "per_thread_output" ||
-		           loption == "file_size_bytes" || loption == "use_tmp_file" || loption == "overwrite_or_ignore" ||
-		           loption == "filename_pattern" || loption == "file_extension") {
+		} else if (SUPPORTED_BASE_OPTIONS.find(loption) != SUPPORTED_BASE_OPTIONS.end()) {
 			// We support these base options
 			csv_copy_options.insert(kv);
 		} else {

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

@@ -67,7 +67,7 @@ static LogicalType GetJSONType(StructNames &const_struct_names, const LogicalTyp
 	case LogicalTypeId::TIMESTAMP_MS:
 	case LogicalTypeId::TIMESTAMP_SEC:
 	case LogicalTypeId::UUID:
-	case LogicalTypeId::VARINT:
+	case LogicalTypeId::BIGNUM:
 	case LogicalTypeId::DECIMAL:
 		return type;
 	case LogicalTypeId::LIST:
@@ -572,6 +572,7 @@ static void CreateValues(const StructNames &names, yyjson_mut_doc *doc, yyjson_m
 	case LogicalTypeId::DATE:
 	case LogicalTypeId::INTERVAL:
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_NS:
 	case LogicalTypeId::TIME_TZ:
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_TZ:
@@ -584,7 +585,7 @@ static void CreateValues(const StructNames &names, yyjson_mut_doc *doc, yyjson_m
 		TemplatedCreateValues<string_t, string_t>(doc, vals, string_vector, count);
 		break;
 	}
-	case LogicalTypeId::VARINT: {
+	case LogicalTypeId::BIGNUM: {
 		Vector string_vector(LogicalTypeId::VARCHAR, count);
 		VectorOperations::DefaultCast(value_v, string_vector, count);
 		CreateRawValues(doc, vals, string_vector, count);
@@ -606,6 +607,8 @@ static void CreateValues(const StructNames &names, yyjson_mut_doc *doc, yyjson_m
 	case LogicalTypeId::UNKNOWN:
 	case LogicalTypeId::ANY:
 	case LogicalTypeId::USER:
+	case LogicalTypeId::TEMPLATE:
+	case LogicalTypeId::VARIANT:
 	case LogicalTypeId::CHAR:
 	case LogicalTypeId::STRING_LITERAL:
 	case LogicalTypeId::INTEGER_LITERAL:
@@ -791,7 +794,7 @@ BoundCastInfo AnyToJSONCastBind(BindCastInput &input, const LogicalType &source,
 	return BoundCastInfo(AnyToJSONCast, std::move(cast_data), JSONFunctionLocalState::InitCastLocalState);
 }
 
-void JSONFunctions::RegisterJSONCreateCastFunctions(CastFunctionSet &casts) {
+void JSONFunctions::RegisterJSONCreateCastFunctions(ExtensionLoader &loader) {
 	// Anything can be cast to JSON
 	for (const auto &type : LogicalType::AllTypes()) {
 		LogicalType source_type;
@@ -818,9 +821,9 @@ void JSONFunctions::RegisterJSONCreateCastFunctions(CastFunctionSet &casts) {
 			source_type = type;
 		}
 		// We prefer going to JSON over going to VARCHAR if a function can do either
-		const auto source_to_json_cost =
-		    MaxValue<int64_t>(casts.ImplicitCastCost(source_type, LogicalType::VARCHAR) - 1, 0);
-		casts.RegisterCastFunction(source_type, LogicalType::JSON(), AnyToJSONCastBind, source_to_json_cost);
+		const auto source_to_json_cost = MaxValue<int64_t>(
+		    CastFunctionSet::ImplicitCastCost(loader.GetDatabaseInstance(), source_type, LogicalType::VARCHAR) - 1, 0);
+		loader.RegisterCastFunction(source_type, LogicalType::JSON(), AnyToJSONCastBind, source_to_json_cost);
 	}
 }
 

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

@@ -3,23 +3,6 @@
 
 namespace duckdb {
 
-static unique_ptr<FunctionData> JSONMergePatchBind(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-	if (arguments.size() < 2) {
-		throw InvalidInputException("json_merge_patch requires at least two parameters");
-	}
-	bound_function.arguments.reserve(arguments.size());
-	for (auto &arg : arguments) {
-		const auto &arg_type = arg->return_type;
-		if (arg_type == LogicalTypeId::SQLNULL || arg_type == LogicalType::VARCHAR || arg_type.IsJSONType()) {
-			bound_function.arguments.push_back(arg_type);
-		} else {
-			throw InvalidInputException("Arguments to json_merge_patch must be of type VARCHAR or JSON");
-		}
-	}
-	return nullptr;
-}
-
 static inline yyjson_mut_val *MergePatch(yyjson_mut_doc *doc, yyjson_mut_val *orig, yyjson_mut_val *patch) {
 	if ((yyjson_mut_get_tag(orig) != (YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE)) ||
 	    (yyjson_mut_get_tag(patch) != (YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE))) {
@@ -98,9 +81,9 @@ static void MergePatchFunction(DataChunk &args, ExpressionState &state, Vector &
 }
 
 ScalarFunctionSet JSONFunctions::GetMergePatchFunction() {
-	ScalarFunction fun("json_merge_patch", {}, LogicalType::JSON(), MergePatchFunction, JSONMergePatchBind, nullptr,
-	                   nullptr, JSONFunctionLocalState::Init);
-	fun.varargs = LogicalType::ANY;
+	ScalarFunction fun("json_merge_patch", {LogicalType::JSON(), LogicalType::JSON()}, LogicalType::JSON(),
+	                   MergePatchFunction, nullptr, nullptr, nullptr, JSONFunctionLocalState::Init);
+	fun.varargs = LogicalType::JSON();
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 
 	return ScalarFunctionSet(fun);

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

@@ -5,9 +5,9 @@ namespace duckdb {
 //! Pretty Print a given JSON Document
 string_t PrettyPrint(yyjson_val *val, yyjson_alc *alc, Vector &, ValidityMask &, idx_t) {
 	D_ASSERT(alc);
-	idx_t len;
-	auto data =
-	    yyjson_val_write_opts(val, JSONCommon::WRITE_PRETTY_FLAG, alc, reinterpret_cast<size_t *>(&len), nullptr);
+	size_t len_size_t;
+	auto data = yyjson_val_write_opts(val, JSONCommon::WRITE_PRETTY_FLAG, alc, &len_size_t, nullptr);
+	idx_t len = len_size_t;
 	return string_t(data, len);
 }
 

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

@@ -162,10 +162,11 @@ static void JsonSerializePlanFunction(DataChunk &args, ExpressionState &state, V
 			yyjson_mut_obj_add_false(doc, result_obj, "error");
 			yyjson_mut_obj_add_val(doc, result_obj, "plans", plans_arr);
 
-			idx_t len;
+			size_t len_size_t;
 			auto data = yyjson_mut_val_write_opts(result_obj,
 			                                      info.format ? JSONCommon::WRITE_PRETTY_FLAG : JSONCommon::WRITE_FLAG,
-			                                      alc, reinterpret_cast<size_t *>(&len), nullptr);
+			                                      alc, &len_size_t, nullptr);
+			idx_t len = len_size_t;
 			if (data == nullptr) {
 				throw SerializationException(
 				    "Failed to serialize json, perhaps the query contains invalid utf8 characters?");
@@ -185,10 +186,11 @@ static void JsonSerializePlanFunction(DataChunk &args, ExpressionState &state, V
 				yyjson_mut_obj_add_strcpy(doc, result_obj, entry.first.c_str(), entry.second.c_str());
 			}
 
-			idx_t len;
+			size_t len_size_t;
 			auto data = yyjson_mut_val_write_opts(result_obj,
 			                                      info.format ? JSONCommon::WRITE_PRETTY_FLAG : JSONCommon::WRITE_FLAG,
-			                                      alc, reinterpret_cast<size_t *>(&len), nullptr);
+			                                      alc, &len_size_t, nullptr);
+			idx_t len = len_size_t;
 			return StringVector::AddString(result, data, len);
 		}
 	});

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

@@ -114,10 +114,11 @@ static void JsonSerializeFunction(DataChunk &args, ExpressionState &state, Vecto
 
 			yyjson_mut_obj_add_false(doc, result_obj, "error");
 			yyjson_mut_obj_add_val(doc, result_obj, "statements", statements_arr);
-			idx_t len;
+			size_t len_size_t;
 			auto data = yyjson_mut_val_write_opts(result_obj,
 			                                      info.format ? JSONCommon::WRITE_PRETTY_FLAG : JSONCommon::WRITE_FLAG,
-			                                      alc, reinterpret_cast<size_t *>(&len), nullptr);
+			                                      alc, &len_size_t, nullptr);
+			idx_t len = len_size_t;
 			if (data == nullptr) {
 				throw SerializationException(
 				    "Failed to serialize json, perhaps the query contains invalid utf8 characters?");
@@ -135,10 +136,11 @@ static void JsonSerializeFunction(DataChunk &args, ExpressionState &state, Vecto
 				yyjson_mut_obj_add_strcpy(doc, result_obj, entry.first.c_str(), entry.second.c_str());
 			}
 
-			idx_t len;
+			size_t len_size_t;
 			auto data = yyjson_mut_val_write_opts(result_obj,
 			                                      info.format ? JSONCommon::WRITE_PRETTY_FLAG : JSONCommon::WRITE_FLAG,
-			                                      alc, reinterpret_cast<size_t *>(&len), nullptr);
+			                                      alc, &len_size_t, nullptr);
+			idx_t len = len_size_t;
 			return StringVector::AddString(result, data, len);
 		}
 	});

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

@@ -155,7 +155,7 @@ template <class T>
 struct JSONTableInOutResultVector {
 	explicit JSONTableInOutResultVector(DataChunk &output, const optional_idx &output_column_index)
 	    : enabled(output_column_index.IsValid()), vector(output.data[enabled ? output_column_index.GetIndex() : 0]),
-	      data(FlatVector::GetData<T>(vector)), validity(FlatVector::Validity(vector)) {
+	      data(enabled ? FlatVector::GetData<T>(vector) : nullptr), validity(FlatVector::Validity(vector)) {
 	}
 	const bool enabled;
 	Vector &vector;
@@ -244,7 +244,11 @@ static void InitializeLocalState(JSONTableInOutLocalState &lstate, DataChunk &in
 	// Parse path, default to root if not given
 	Value path_value("$");
 	if (input.data.size() > 1) {
-		path_value = ConstantVector::GetData<string_t>(input.data[1])[0];
+		auto &path_vector = input.data[1];
+		if (ConstantVector::IsNull(path_vector)) {
+			return;
+		}
+		path_value = ConstantVector::GetData<string_t>(path_vector)[0];
 	}
 
 	if (JSONReadFunctionData::CheckPath(path_value, lstate.path, lstate.len) == JSONCommon::JSONPathType::WILDCARD) {

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

@@ -915,6 +915,7 @@ bool JSONTransform::Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &resul
 	case LogicalTypeId::DATE:
 	case LogicalTypeId::INTERVAL:
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_NS:
 	case LogicalTypeId::TIME_TZ:
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_TZ:
@@ -1027,7 +1028,7 @@ BoundCastInfo JSONToAnyCastBind(BindCastInput &input, const LogicalType &source,
 	return BoundCastInfo(JSONToAnyCast, nullptr, JSONFunctionLocalState::InitCastLocalState);
 }
 
-void JSONFunctions::RegisterJSONTransformCastFunctions(CastFunctionSet &casts) {
+void JSONFunctions::RegisterJSONTransformCastFunctions(ExtensionLoader &loader) {
 	// JSON can be cast to anything
 	for (const auto &type : LogicalType::AllTypes()) {
 		LogicalType target_type;
@@ -1054,8 +1055,9 @@ void JSONFunctions::RegisterJSONTransformCastFunctions(CastFunctionSet &casts) {
 			target_type = type;
 		}
 		// Going from JSON to another type has the same cost as going from VARCHAR to that type
-		const auto json_to_target_cost = casts.ImplicitCastCost(LogicalType::VARCHAR, target_type);
-		casts.RegisterCastFunction(LogicalType::JSON(), target_type, JSONToAnyCastBind, json_to_target_cost);
+		const auto json_to_target_cost =
+		    CastFunctionSet::ImplicitCastCost(loader.GetDatabaseInstance(), LogicalType::VARCHAR, target_type);
+		loader.RegisterCastFunction(LogicalType::JSON(), target_type, JSONToAnyCastBind, json_to_target_cost);
 	}
 }
 

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

@@ -162,15 +162,16 @@ void JSONScan::AutoDetect(ClientContext &context, MultiFileBindData &bind_data,
 	AutoDetectState auto_detect_state(context, bind_data, files, date_format_map);
 	const auto num_threads = NumericCast<idx_t>(TaskScheduler::GetScheduler(context).NumberOfThreads());
 	const auto files_per_task = (file_count + num_threads - 1) / num_threads;
-	const auto num_tasks = file_count / files_per_task;
+	const auto num_tasks = (file_count + files_per_task - 1) / files_per_task;
 	vector<JSONStructureNode> task_nodes(num_tasks);
 
 	// Same idea as in union_by_name.hpp
 	TaskExecutor executor(context);
 	for (idx_t task_idx = 0; task_idx < num_tasks; task_idx++) {
 		const auto file_idx_start = task_idx * files_per_task;
-		auto task = make_uniq<JSONSchemaTask>(executor, auto_detect_state, task_nodes[task_idx], file_idx_start,
-		                                      file_idx_start + files_per_task);
+		const auto file_idx_end = MinValue(file_idx_start + files_per_task, file_count);
+		auto task =
+		    make_uniq<JSONSchemaTask>(executor, auto_detect_state, task_nodes[task_idx], file_idx_start, file_idx_end);
 		executor.ScheduleTask(std::move(task));
 	}
 	executor.WorkOnTasks();

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

@@ -259,20 +259,147 @@ static bool CastVarcharToJSON(Vector &source, Vector &result, idx_t count, CastP
 	return success;
 }
 
-void JSONFunctions::RegisterSimpleCastFunctions(CastFunctionSet &casts) {
+static bool CastJSONListToVarchar(Vector &source, Vector &result, idx_t count, CastParameters &) {
+	UnifiedVectorFormat child_format;
+	ListVector::GetEntry(source).ToUnifiedFormat(ListVector::GetListSize(source), child_format);
+	const auto input_jsons = UnifiedVectorFormat::GetData<string_t>(child_format);
+
+	static constexpr char const *NULL_STRING = "NULL";
+	static constexpr idx_t NULL_STRING_LENGTH = 4;
+
+	UnaryExecutor::Execute<list_entry_t, string_t>(
+	    source, result, count,
+	    [&](const list_entry_t &input) {
+		    // Compute len (start with [] and ,)
+		    idx_t len = 2;
+		    len += input.length == 0 ? 0 : (input.length - 1) * 2;
+		    for (idx_t json_idx = input.offset; json_idx < input.offset + input.length; json_idx++) {
+			    const auto sel_json_idx = child_format.sel->get_index(json_idx);
+			    if (child_format.validity.RowIsValid(sel_json_idx)) {
+				    len += input_jsons[sel_json_idx].GetSize();
+			    } else {
+				    len += NULL_STRING_LENGTH;
+			    }
+		    }
+
+		    // Allocate string
+		    auto res = StringVector::EmptyString(result, len);
+		    auto ptr = res.GetDataWriteable();
+
+		    // Populate string
+		    *ptr++ = '[';
+		    for (idx_t json_idx = input.offset; json_idx < input.offset + input.length; json_idx++) {
+			    const auto sel_json_idx = child_format.sel->get_index(json_idx);
+			    if (child_format.validity.RowIsValid(sel_json_idx)) {
+				    auto &input_json = input_jsons[sel_json_idx];
+				    memcpy(ptr, input_json.GetData(), input_json.GetSize());
+				    ptr += input_json.GetSize();
+			    } else {
+				    memcpy(ptr, NULL_STRING, NULL_STRING_LENGTH);
+				    ptr += NULL_STRING_LENGTH;
+			    }
+			    if (json_idx != input.offset + input.length - 1) {
+				    *ptr++ = ',';
+				    *ptr++ = ' ';
+			    }
+		    }
+		    *ptr = ']';
+
+		    res.Finalize();
+		    return res;
+	    },
+	    FunctionErrors::CANNOT_ERROR);
+	return true;
+}
+
+static bool CastVarcharToJSONList(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+	auto &lstate = parameters.local_state->Cast<JSONFunctionLocalState>();
+	lstate.json_allocator->Reset();
+	auto alc = lstate.json_allocator->GetYYAlc();
+
+	bool success = true;
+	UnaryExecutor::ExecuteWithNulls<string_t, list_entry_t>(
+	    source, result, count, [&](const string_t &input, ValidityMask &mask, idx_t idx) -> list_entry_t {
+		    // Figure out if the cast can succeed
+		    yyjson_read_err error;
+		    const auto doc = JSONCommon::ReadDocumentUnsafe(input.GetDataWriteable(), input.GetSize(),
+		                                                    JSONCommon::READ_FLAG, alc, &error);
+		    if (!doc || !unsafe_yyjson_is_arr(doc->root)) {
+			    mask.SetInvalid(idx);
+			    if (success) {
+				    if (!doc) {
+					    HandleCastError::AssignError(
+					        JSONCommon::FormatParseError(input.GetDataWriteable(), input.GetSize(), error), parameters);
+				    } else if (!unsafe_yyjson_is_arr(doc->root)) {
+					    auto truncated_input =
+					        input.GetSize() > 50 ? string(input.GetData(), 47) + "..." : input.GetString();
+					    HandleCastError::AssignError(
+					        StringUtil::Format("Cannot cast to list of JSON. Input \"%s\"", truncated_input),
+					        parameters);
+				    }
+				    success = false;
+			    }
+			    return {};
+		    }
+
+		    auto current_size = ListVector::GetListSize(result);
+		    const auto arr_len = unsafe_yyjson_get_len(doc->root);
+		    const auto new_size = current_size + arr_len;
+
+		    // Grow list if needed
+		    if (ListVector::GetListCapacity(result) < new_size) {
+			    ListVector::Reserve(result, new_size);
+		    }
+
+		    // Populate list
+		    const auto result_jsons = FlatVector::GetData<string_t>(ListVector::GetEntry(result));
+		    size_t arr_idx, max;
+		    yyjson_val *val;
+		    yyjson_arr_foreach(doc->root, arr_idx, max, val) {
+			    result_jsons[current_size + arr_idx] = JSONCommon::WriteVal(val, alc);
+		    }
+
+		    // Update size
+		    ListVector::SetListSize(result, current_size + arr_len);
+
+		    return {current_size, arr_len};
+	    });
+
+	JSONAllocator::AddBuffer(ListVector::GetEntry(result), alc);
+	return success;
+}
+
+void JSONFunctions::RegisterSimpleCastFunctions(ExtensionLoader &loader) {
+	auto &db = loader.GetDatabaseInstance();
+
 	// JSON to VARCHAR is basically free
-	casts.RegisterCastFunction(LogicalType::JSON(), LogicalType::VARCHAR, DefaultCasts::ReinterpretCast, 1);
+	loader.RegisterCastFunction(LogicalType::JSON(), LogicalType::VARCHAR, DefaultCasts::ReinterpretCast, 1);
 
 	// VARCHAR to JSON requires a parse so it's not free. Let's make it 1 more than a cast to STRUCT
-	auto varchar_to_json_cost = casts.ImplicitCastCost(LogicalType::SQLNULL, LogicalTypeId::STRUCT) + 1;
+	const auto varchar_to_json_cost =
+	    CastFunctionSet::ImplicitCastCost(db, LogicalType::SQLNULL, LogicalTypeId::STRUCT) + 1;
 	BoundCastInfo varchar_to_json_info(CastVarcharToJSON, nullptr, JSONFunctionLocalState::InitCastLocalState);
-	casts.RegisterCastFunction(LogicalType::VARCHAR, LogicalType::JSON(), std::move(varchar_to_json_info),
-	                           varchar_to_json_cost);
+	loader.RegisterCastFunction(LogicalType::VARCHAR, LogicalType::JSON(), std::move(varchar_to_json_info),
+	                            varchar_to_json_cost);
 
 	// Register NULL to JSON with a different cost than NULL to VARCHAR so the binder can disambiguate functions
-	auto null_to_json_cost = casts.ImplicitCastCost(LogicalType::SQLNULL, LogicalTypeId::VARCHAR) + 1;
-	casts.RegisterCastFunction(LogicalType::SQLNULL, LogicalType::JSON(), DefaultCasts::TryVectorNullCast,
-	                           null_to_json_cost);
+	const auto null_to_json_cost =
+	    CastFunctionSet::ImplicitCastCost(db, LogicalType::SQLNULL, LogicalTypeId::VARCHAR) + 1;
+	loader.RegisterCastFunction(LogicalType::SQLNULL, LogicalType::JSON(), DefaultCasts::TryVectorNullCast,
+	                            null_to_json_cost);
+
+	// JSON[] to VARCHAR (this needs a special case otherwise the cast will escape quotes)
+	const auto json_list_to_varchar_cost =
+	    CastFunctionSet::ImplicitCastCost(db, LogicalType::LIST(LogicalType::JSON()), LogicalTypeId::VARCHAR) - 1;
+	loader.RegisterCastFunction(LogicalType::LIST(LogicalType::JSON()), LogicalTypeId::VARCHAR, CastJSONListToVarchar,
+	                            json_list_to_varchar_cost);
+
+	// VARCHAR to JSON[] (also needs a special case otherwise get a VARCHAR -> VARCHAR[] cast first)
+	const auto varchar_to_json_list_cost =
+	    CastFunctionSet::ImplicitCastCost(db, LogicalType::VARCHAR, LogicalType::LIST(LogicalType::JSON())) - 1;
+	BoundCastInfo varchar_to_json_list_info(CastVarcharToJSONList, nullptr, JSONFunctionLocalState::InitCastLocalState);
+	loader.RegisterCastFunction(LogicalType::VARCHAR, LogicalType::LIST(LogicalType::JSON()),
+	                            std::move(varchar_to_json_list_info), varchar_to_json_list_cost);
 }
 
 } // namespace duckdb

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

@@ -4,8 +4,7 @@
 
 namespace duckdb {
 
-unique_ptr<MultiFileReaderInterface>
-JSONMultiFileInfo::InitializeInterface(ClientContext &context, MultiFileReader &reader, MultiFileList &file_list) {
+unique_ptr<MultiFileReaderInterface> JSONMultiFileInfo::CreateInterface(ClientContext &context) {
 	return make_uniq<JSONMultiFileInfo>();
 }
 
@@ -579,4 +578,8 @@ optional_idx JSONMultiFileInfo::MaxThreads(const MultiFileBindData &bind_data, c
 	return json_data.max_threads;
 }
 
+FileGlobInput JSONMultiFileInfo::GetGlobInput() {
+	return FileGlobInput(FileGlobOptions::FALLBACK_GLOB, "json");
+}
+
 } // namespace duckdb

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

@@ -14,10 +14,10 @@ JSONBufferHandle::JSONBufferHandle(JSONReader &reader, idx_t buffer_index_p, idx
       buffer_size(buffer_size_p), buffer_start(buffer_start_p) {
 }
 
-JSONFileHandle::JSONFileHandle(unique_ptr<FileHandle> file_handle_p, Allocator &allocator_p)
-    : file_handle(std::move(file_handle_p)), allocator(allocator_p), can_seek(file_handle->CanSeek()),
-      file_size(file_handle->GetFileSize()), read_position(0), requested_reads(0), actual_reads(0),
-      last_read_requested(false), cached_size(0) {
+JSONFileHandle::JSONFileHandle(QueryContext context_p, unique_ptr<FileHandle> file_handle_p, Allocator &allocator_p)
+    : context(context_p), file_handle(std::move(file_handle_p)), allocator(allocator_p),
+      can_seek(file_handle->CanSeek()), file_size(file_handle->GetFileSize()), read_position(0), requested_reads(0),
+      actual_reads(0), last_read_requested(false), cached_size(0) {
 }
 
 bool JSONFileHandle::IsOpen() const {
@@ -95,7 +95,7 @@ void JSONFileHandle::ReadAtPosition(char *pointer, idx_t size, idx_t position,
 	}
 	if (size != 0) {
 		auto &handle = override_handle ? *override_handle.get() : *file_handle.get();
-		handle.Read(pointer, size, position);
+		handle.Read(context, pointer, size, position);
 	}
 
 	const auto incremented_actual_reads = ++actual_reads;
@@ -184,7 +184,8 @@ void JSONReader::OpenJSONFile() {
 	if (!IsOpen()) {
 		auto &fs = FileSystem::GetFileSystem(context);
 		auto regular_file_handle = fs.OpenFile(file, FileFlags::FILE_FLAGS_READ | options.compression);
-		file_handle = make_uniq<JSONFileHandle>(std::move(regular_file_handle), BufferAllocator::Get(context));
+		file_handle = make_uniq<JSONFileHandle>(QueryContext(context), std::move(regular_file_handle),
+		                                        BufferAllocator::Get(context));
 	}
 	Reset();
 }