duckdb 0.7.2-dev3353.0 → 0.7.2-dev3402.0

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

@@ -1,17 +1,21 @@
+#include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "json_common.hpp"
 #include "json_functions.hpp"
 
 namespace duckdb {
 
+using StructNames = unordered_map<string, unique_ptr<Vector>>;
+
 struct JSONCreateFunctionData : public FunctionData {
 public:
-	explicit JSONCreateFunctionData(unordered_map<string, duckdb::unique_ptr<Vector>> const_struct_names)
+	explicit JSONCreateFunctionData(unordered_map<string, unique_ptr<Vector>> const_struct_names)
 	    : const_struct_names(std::move(const_struct_names)) {
 	}
-	duckdb::unique_ptr<FunctionData> Copy() const override {
+	unique_ptr<FunctionData> Copy() const override {
 		// Have to do this because we can't implicitly copy Vector
-		unordered_map<string, duckdb::unique_ptr<Vector>> map_copy;
+		unordered_map<string, unique_ptr<Vector>> map_copy;
 		for (const auto &kv : const_struct_names) {
 			// The vectors are const vectors of the key value
 			map_copy[kv.first] = make_uniq<Vector>(Value(kv.first));
@@ -24,11 +28,10 @@ public:
 
 public:
 	// Const struct name vectors live here so they don't have to be re-initialized for every DataChunk
-	unordered_map<string, duckdb::unique_ptr<Vector>> const_struct_names;
+	StructNames const_struct_names;
 };
 
-static LogicalType GetJSONType(unordered_map<string, duckdb::unique_ptr<Vector>> &const_struct_names,
-                               const LogicalType &type) {
+static LogicalType GetJSONType(StructNames &const_struct_names, const LogicalType &type) {
 	if (JSONCommon::LogicalTypeIsJSON(type)) {
 		return type;
 	}
@@ -86,9 +89,9 @@ static LogicalType GetJSONType(unordered_map<string, duckdb::unique_ptr<Vector>>
 	}
 }
 
-static duckdb::unique_ptr<FunctionData>
-JSONCreateBindParams(ScalarFunction &bound_function, vector<duckdb::unique_ptr<Expression>> &arguments, bool object) {
-	unordered_map<string, duckdb::unique_ptr<Vector>> const_struct_names;
+static unique_ptr<FunctionData> JSONCreateBindParams(ScalarFunction &bound_function,
+                                                     vector<unique_ptr<Expression>> &arguments, bool object) {
+	unordered_map<string, unique_ptr<Vector>> const_struct_names;
 	for (idx_t i = 0; i < arguments.size(); i++) {
 		auto &type = arguments[i]->return_type;
 		if (arguments[i]->HasParameter()) {
@@ -107,29 +110,29 @@ JSONCreateBindParams(ScalarFunction &bound_function, vector<duckdb::unique_ptr<E
 	return make_uniq<JSONCreateFunctionData>(std::move(const_struct_names));
 }
 
-static duckdb::unique_ptr<FunctionData> JSONObjectBind(ClientContext &context, ScalarFunction &bound_function,
-                                                       vector<duckdb::unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> JSONObjectBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
 	if (arguments.size() % 2 != 0) {
 		throw InvalidInputException("json_object() requires an even number of arguments");
 	}
 	return JSONCreateBindParams(bound_function, arguments, true);
 }
 
-static duckdb::unique_ptr<FunctionData> JSONArrayBind(ClientContext &context, ScalarFunction &bound_function,
-                                                      vector<duckdb::unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> JSONArrayBind(ClientContext &context, ScalarFunction &bound_function,
+                                              vector<unique_ptr<Expression>> &arguments) {
 	return JSONCreateBindParams(bound_function, arguments, false);
 }
 
-static duckdb::unique_ptr<FunctionData> ToJSONBind(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<duckdb::unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> ToJSONBind(ClientContext &context, ScalarFunction &bound_function,
+                                           vector<unique_ptr<Expression>> &arguments) {
 	if (arguments.size() != 1) {
 		throw InvalidInputException("to_json() takes exactly one argument");
 	}
 	return JSONCreateBindParams(bound_function, arguments, false);
 }
 
-static duckdb::unique_ptr<FunctionData> ArrayToJSONBind(ClientContext &context, ScalarFunction &bound_function,
-                                                        vector<duckdb::unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> ArrayToJSONBind(ClientContext &context, ScalarFunction &bound_function,
+                                                vector<unique_ptr<Expression>> &arguments) {
 	if (arguments.size() != 1) {
 		throw InvalidInputException("array_to_json() takes exactly one argument");
 	}
@@ -143,8 +146,8 @@ static duckdb::unique_ptr<FunctionData> ArrayToJSONBind(ClientContext &context,
 	return JSONCreateBindParams(bound_function, arguments, false);
 }
 
-static duckdb::unique_ptr<FunctionData> RowToJSONBind(ClientContext &context, ScalarFunction &bound_function,
-                                                      vector<duckdb::unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> RowToJSONBind(ClientContext &context, ScalarFunction &bound_function,
+                                              vector<unique_ptr<Expression>> &arguments) {
 	if (arguments.size() != 1) {
 		throw InvalidInputException("row_to_json() takes exactly one argument");
 	}
@@ -158,35 +161,55 @@ static duckdb::unique_ptr<FunctionData> RowToJSONBind(ClientContext &context, Sc
 	return JSONCreateBindParams(bound_function, arguments, false);
 }
 
-template <class T>
-static inline yyjson_mut_val *CreateJSONValue(yyjson_mut_doc *doc, const T &value) {
-	throw NotImplementedException("Unsupported type for CreateJSONValue");
-}
+template <class INPUT_TYPE, class RESULT_TYPE>
+struct CreateJSONValue {
+	static inline RESULT_TYPE Operation(const INPUT_TYPE &input) {
+		throw NotImplementedException("Unsupported type for CreateJSONValue");
+	}
+};
 
-template <>
-inline yyjson_mut_val *CreateJSONValue(yyjson_mut_doc *doc, const bool &value) {
-	return yyjson_mut_bool(doc, value);
-}
+template <class INPUT_TYPE>
+struct CreateJSONValue<INPUT_TYPE, bool> {
+	static inline yyjson_mut_val *Operation(yyjson_mut_doc *doc, const INPUT_TYPE &input) {
+		return yyjson_mut_bool(doc, input);
+	}
+};
 
-template <>
-inline yyjson_mut_val *CreateJSONValue(yyjson_mut_doc *doc, const uint64_t &value) {
-	return yyjson_mut_uint(doc, value);
-}
+template <class INPUT_TYPE>
+struct CreateJSONValue<INPUT_TYPE, uint64_t> {
+	static inline yyjson_mut_val *Operation(yyjson_mut_doc *doc, const INPUT_TYPE &input) {
+		return yyjson_mut_uint(doc, input);
+	}
+};
 
-template <>
-inline yyjson_mut_val *CreateJSONValue(yyjson_mut_doc *doc, const int64_t &value) {
-	return yyjson_mut_sint(doc, value);
-}
+template <class INPUT_TYPE>
+struct CreateJSONValue<INPUT_TYPE, int64_t> {
+	static inline yyjson_mut_val *Operation(yyjson_mut_doc *doc, const INPUT_TYPE &input) {
+		return yyjson_mut_sint(doc, input);
+	}
+};
+
+template <class INPUT_TYPE>
+struct CreateJSONValue<INPUT_TYPE, double> {
+	static inline yyjson_mut_val *Operation(yyjson_mut_doc *doc, const INPUT_TYPE &input) {
+		return yyjson_mut_real(doc, input);
+	}
+};
 
 template <>
-inline yyjson_mut_val *CreateJSONValue(yyjson_mut_doc *doc, const double &value) {
-	return yyjson_mut_real(doc, value);
-}
+struct CreateJSONValue<string_t, string_t> {
+	static inline yyjson_mut_val *Operation(yyjson_mut_doc *doc, const string_t &input) {
+		return yyjson_mut_strncpy(doc, input.GetData(), input.GetSize());
+	}
+};
 
 template <>
-inline yyjson_mut_val *CreateJSONValue(yyjson_mut_doc *doc, const string_t &value) {
-	return yyjson_mut_strn(doc, value.GetData(), value.GetSize());
-}
+struct CreateJSONValue<hugeint_t, string_t> {
+	static inline yyjson_mut_val *Operation(yyjson_mut_doc *doc, const hugeint_t &input) {
+		const auto input_string = input.ToString();
+		return yyjson_mut_strncpy(doc, input_string.c_str(), input_string.length());
+	}
+};
 
 inline yyjson_mut_val *CreateJSONValueFromJSON(yyjson_mut_doc *doc, const string_t &value) {
 	auto value_doc = JSONCommon::ReadDocument(value, JSONCommon::READ_FLAG, &doc->alc);
@@ -195,8 +218,8 @@ inline yyjson_mut_val *CreateJSONValueFromJSON(yyjson_mut_doc *doc, const string
 }
 
 // Forward declaration so we can recurse for nested types
-static void CreateValues(const JSONCreateFunctionData &info, yyjson_mut_doc *doc, yyjson_mut_val *vals[],
-                         Vector &value_v, idx_t count);
+static void CreateValues(const StructNames &names, yyjson_mut_doc *doc, yyjson_mut_val *vals[], Vector &value_v,
+                         idx_t count);
 
 static void AddKeyValuePairs(yyjson_mut_doc *doc, yyjson_mut_val *objs[], Vector &key_v, yyjson_mut_val *vals[],
                              idx_t count) {
@@ -209,14 +232,14 @@ static void AddKeyValuePairs(yyjson_mut_doc *doc, yyjson_mut_val *objs[], Vector
 		if (!key_data.validity.RowIsValid(key_idx)) {
 			continue;
 		}
-		auto key = CreateJSONValue<string_t>(doc, keys[key_idx]);
+		auto key = CreateJSONValue<string_t, string_t>::Operation(doc, keys[key_idx]);
 		yyjson_mut_obj_add(objs[i], key, vals[i]);
 	}
 }
 
-static void CreateKeyValuePairs(const JSONCreateFunctionData &info, yyjson_mut_doc *doc, yyjson_mut_val *objs[],
+static void CreateKeyValuePairs(const StructNames &names, yyjson_mut_doc *doc, yyjson_mut_val *objs[],
                                 yyjson_mut_val *vals[], Vector &key_v, Vector &value_v, idx_t count) {
-	CreateValues(info, doc, vals, value_v, count);
+	CreateValues(names, doc, vals, value_v, count);
 	AddKeyValuePairs(doc, objs, key_v, vals, count);
 }
 
@@ -226,11 +249,11 @@ static void CreateValuesNull(yyjson_mut_doc *doc, yyjson_mut_val *vals[], idx_t
 	}
 }
 
-template <class T>
+template <class INPUT_TYPE, class TARGET_TYPE>
 static void TemplatedCreateValues(yyjson_mut_doc *doc, yyjson_mut_val *vals[], Vector &value_v, idx_t count) {
 	UnifiedVectorFormat value_data;
 	value_v.ToUnifiedFormat(count, value_data);
-	auto values = (T *)value_data.data;
+	auto values = (INPUT_TYPE *)value_data.data;
 
 	const auto type_is_json = JSONCommon::LogicalTypeIsJSON(value_v.GetType());
 	for (idx_t i = 0; i < count; i++) {
@@ -240,14 +263,14 @@ static void TemplatedCreateValues(yyjson_mut_doc *doc, yyjson_mut_val *vals[], V
 		} else if (type_is_json) {
 			vals[i] = CreateJSONValueFromJSON(doc, (string_t &)values[val_idx]);
 		} else {
-			vals[i] = CreateJSONValue<T>(doc, values[val_idx]);
+			vals[i] = CreateJSONValue<INPUT_TYPE, TARGET_TYPE>::Operation(doc, values[val_idx]);
 		}
 		D_ASSERT(vals[i] != nullptr);
 	}
 }
 
-static void CreateValuesStruct(const JSONCreateFunctionData &info, yyjson_mut_doc *doc, yyjson_mut_val *vals[],
-                               Vector &value_v, idx_t count) {
+static void CreateValuesStruct(const StructNames &names, yyjson_mut_doc *doc, yyjson_mut_val *vals[], Vector &value_v,
+                               idx_t count) {
 	// Structs become values, therefore we initialize vals to JSON values
 	for (idx_t i = 0; i < count; i++) {
 		vals[i] = yyjson_mut_obj(doc);
@@ -258,9 +281,9 @@ static void CreateValuesStruct(const JSONCreateFunctionData &info, yyjson_mut_do
 	// Add the key/value pairs to the values
 	auto &entries = StructVector::GetEntries(value_v);
 	for (idx_t entry_i = 0; entry_i < entries.size(); entry_i++) {
-		auto &struct_key_v = *info.const_struct_names.at(StructType::GetChildName(value_v.GetType(), entry_i));
+		auto &struct_key_v = *names.at(StructType::GetChildName(value_v.GetType(), entry_i));
 		auto &struct_val_v = *entries[entry_i];
-		CreateKeyValuePairs(info, doc, vals, nested_vals, struct_key_v, struct_val_v, count);
+		CreateKeyValuePairs(names, doc, vals, nested_vals, struct_key_v, struct_val_v, count);
 	}
 	// Whole struct can be NULL
 	UnifiedVectorFormat struct_data;
@@ -273,18 +296,18 @@ static void CreateValuesStruct(const JSONCreateFunctionData &info, yyjson_mut_do
 	}
 }
 
-static void CreateValuesMap(const JSONCreateFunctionData &info, yyjson_mut_doc *doc, yyjson_mut_val *vals[],
-                            Vector &value_v, idx_t count) {
+static void CreateValuesMap(const StructNames &names, yyjson_mut_doc *doc, yyjson_mut_val *vals[], Vector &value_v,
+                            idx_t count) {
 	// Create nested keys
 	auto &map_key_v = MapVector::GetKeys(value_v);
 	auto map_key_count = ListVector::GetListSize(value_v);
 	auto nested_keys = (yyjson_mut_val **)doc->alc.malloc(doc->alc.ctx, sizeof(yyjson_mut_val *) * map_key_count);
-	TemplatedCreateValues<string_t>(doc, nested_keys, map_key_v, map_key_count);
+	TemplatedCreateValues<string_t, string_t>(doc, nested_keys, map_key_v, map_key_count);
 	// Create nested values
 	auto &map_val_v = MapVector::GetValues(value_v);
 	auto map_val_count = ListVector::GetListSize(value_v);
 	auto nested_vals = (yyjson_mut_val **)doc->alc.malloc(doc->alc.ctx, sizeof(yyjson_mut_val *) * map_val_count);
-	CreateValues(info, doc, nested_vals, map_val_v, map_val_count);
+	CreateValues(names, doc, nested_vals, map_val_v, map_val_count);
 	// Add the key/value pairs to the values
 	UnifiedVectorFormat map_data;
 	value_v.ToUnifiedFormat(count, map_data);
@@ -307,8 +330,8 @@ static void CreateValuesMap(const JSONCreateFunctionData &info, yyjson_mut_doc *
 	}
 }
 
-static void CreateValuesUnion(const JSONCreateFunctionData &info, yyjson_mut_doc *doc, yyjson_mut_val *vals[],
-                              Vector &value_v, idx_t count) {
+static void CreateValuesUnion(const StructNames &names, yyjson_mut_doc *doc, yyjson_mut_val *vals[], Vector &value_v,
+                              idx_t count) {
 	// Structs become values, therefore we initialize vals to JSON values
 	for (idx_t i = 0; i < count; i++) {
 		vals[i] = yyjson_mut_obj(doc);
@@ -324,12 +347,12 @@ static void CreateValuesUnion(const JSONCreateFunctionData &info, yyjson_mut_doc
 	// Add the key/value pairs to the values
 	for (idx_t member_idx = 0; member_idx < UnionType::GetMemberCount(value_v.GetType()); member_idx++) {
 		auto &member_val_v = UnionVector::GetMember(value_v, member_idx);
-		auto &member_key_v = *info.const_struct_names.at(UnionType::GetMemberName(value_v.GetType(), member_idx));
+		auto &member_key_v = *names.at(UnionType::GetMemberName(value_v.GetType(), member_idx));
 
 		// This implementation is not optimal since we convert the entire member vector,
 		// and then skip the rows not matching the tag afterwards.
 
-		CreateValues(info, doc, nested_vals, member_val_v, count);
+		CreateValues(names, doc, nested_vals, member_val_v, count);
 
 		// This is a inlined copy of AddKeyValuePairs but we also skip null tags
 		// and the rows where the member is not matching the tag
@@ -350,20 +373,20 @@ static void CreateValuesUnion(const JSONCreateFunctionData &info, yyjson_mut_doc
 			if (!key_data.validity.RowIsValid(key_idx)) {
 				continue;
 			}
-			auto key = CreateJSONValue<string_t>(doc, keys[key_idx]);
+			auto key = CreateJSONValue<string_t, string_t>::Operation(doc, keys[key_idx]);
 			yyjson_mut_obj_add(vals[i], key, nested_vals[i]);
 		}
 	}
 }
 
-static void CreateValuesList(const JSONCreateFunctionData &info, yyjson_mut_doc *doc, yyjson_mut_val *vals[],
-                             Vector &value_v, idx_t count) {
+static void CreateValuesList(const StructNames &names, yyjson_mut_doc *doc, yyjson_mut_val *vals[], Vector &value_v,
+                             idx_t count) {
 	// Initialize array for the nested values
 	auto &child_v = ListVector::GetEntry(value_v);
 	auto child_count = ListVector::GetListSize(value_v);
 	auto nested_vals = (yyjson_mut_val **)doc->alc.malloc(doc->alc.ctx, sizeof(yyjson_mut_val *) * child_count);
 	// Fill nested_vals with list values
-	CreateValues(info, doc, nested_vals, child_v, child_count);
+	CreateValues(names, doc, nested_vals, child_v, child_count);
 	// Now we add the values to the appropriate JSON arrays
 	UnifiedVectorFormat list_data;
 	value_v.ToUnifiedFormat(count, list_data);
@@ -382,39 +405,88 @@ static void CreateValuesList(const JSONCreateFunctionData &info, yyjson_mut_doc
 	}
 }
 
-static void CreateValues(const JSONCreateFunctionData &info, yyjson_mut_doc *doc, yyjson_mut_val *vals[],
-                         Vector &value_v, idx_t count) {
+static void CreateValues(const StructNames &names, yyjson_mut_doc *doc, yyjson_mut_val *vals[], Vector &value_v,
+                         idx_t count) {
 	switch (value_v.GetType().id()) {
 	case LogicalTypeId::SQLNULL:
 		CreateValuesNull(doc, vals, count);
 		break;
 	case LogicalTypeId::BOOLEAN:
-		TemplatedCreateValues<bool>(doc, vals, value_v, count);
+		TemplatedCreateValues<bool, bool>(doc, vals, value_v, count);
+		break;
+	case LogicalTypeId::TINYINT:
+		TemplatedCreateValues<int8_t, int64_t>(doc, vals, value_v, count);
+		break;
+	case LogicalTypeId::SMALLINT:
+		TemplatedCreateValues<int16_t, int64_t>(doc, vals, value_v, count);
+		break;
+	case LogicalTypeId::INTEGER:
+		TemplatedCreateValues<int32_t, int64_t>(doc, vals, value_v, count);
 		break;
 	case LogicalTypeId::BIGINT:
-		TemplatedCreateValues<int64_t>(doc, vals, value_v, count);
+		TemplatedCreateValues<int64_t, int64_t>(doc, vals, value_v, count);
+		break;
+	case LogicalTypeId::HUGEINT:
+		TemplatedCreateValues<hugeint_t, string_t>(doc, vals, value_v, count);
+		break;
+	case LogicalTypeId::UTINYINT:
+		TemplatedCreateValues<uint8_t, uint64_t>(doc, vals, value_v, count);
+		break;
+	case LogicalTypeId::USMALLINT:
+		TemplatedCreateValues<uint16_t, uint64_t>(doc, vals, value_v, count);
+		break;
+	case LogicalTypeId::UINTEGER:
+		TemplatedCreateValues<uint32_t, uint64_t>(doc, vals, value_v, count);
 		break;
 	case LogicalTypeId::UBIGINT:
-		TemplatedCreateValues<uint64_t>(doc, vals, value_v, count);
+		TemplatedCreateValues<uint64_t, uint64_t>(doc, vals, value_v, count);
+		break;
+	case LogicalTypeId::FLOAT:
+		TemplatedCreateValues<float, double>(doc, vals, value_v, count);
 		break;
 	case LogicalTypeId::DOUBLE:
-		TemplatedCreateValues<double>(doc, vals, value_v, count);
+		TemplatedCreateValues<double, double>(doc, vals, value_v, count);
 		break;
+	case LogicalTypeId::BIT:
+	case LogicalTypeId::BLOB:
 	case LogicalTypeId::VARCHAR:
-		TemplatedCreateValues<string_t>(doc, vals, value_v, count);
+		TemplatedCreateValues<string_t, string_t>(doc, vals, value_v, count);
 		break;
 	case LogicalTypeId::STRUCT:
-		CreateValuesStruct(info, doc, vals, value_v, count);
+		CreateValuesStruct(names, doc, vals, value_v, count);
 		break;
 	case LogicalTypeId::MAP:
-		CreateValuesMap(info, doc, vals, value_v, count);
+		CreateValuesMap(names, doc, vals, value_v, count);
 		break;
 	case LogicalTypeId::LIST:
-		CreateValuesList(info, doc, vals, value_v, count);
+		CreateValuesList(names, doc, vals, value_v, count);
 		break;
 	case LogicalTypeId::UNION:
-		CreateValuesUnion(info, doc, vals, value_v, count);
+		CreateValuesUnion(names, doc, vals, value_v, count);
 		break;
+	case LogicalTypeId::AGGREGATE_STATE:
+	case LogicalTypeId::ENUM:
+	case LogicalTypeId::DATE:
+	case LogicalTypeId::INTERVAL:
+	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
+	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
+	case LogicalTypeId::TIMESTAMP_NS:
+	case LogicalTypeId::TIMESTAMP_MS:
+	case LogicalTypeId::TIMESTAMP_SEC:
+	case LogicalTypeId::UUID: {
+		Vector string_vector(LogicalTypeId::VARCHAR, count);
+		VectorOperations::DefaultCast(value_v, string_vector, count);
+		TemplatedCreateValues<string_t, string_t>(doc, vals, string_vector, count);
+		break;
+	}
+	case LogicalTypeId::DECIMAL: {
+		Vector double_vector(LogicalType::DOUBLE, count);
+		VectorOperations::DefaultCast(value_v, double_vector, count);
+		TemplatedCreateValues<double, double>(doc, vals, double_vector, count);
+		break;
+	}
 	default:
 		throw InternalException("Unsupported type arrived at JSON create function");
 	}
@@ -429,17 +501,17 @@ static void ObjectFunction(DataChunk &args, ExpressionState &state, Vector &resu
 	// Initialize values
 	const idx_t count = args.size();
 	auto doc = JSONCommon::CreateDocument(alc);
-	yyjson_mut_val *objs[STANDARD_VECTOR_SIZE];
+	auto objs = (yyjson_mut_val **)alc->malloc(alc->ctx, sizeof(yyjson_mut_val *) * count);
 	for (idx_t i = 0; i < count; i++) {
 		objs[i] = yyjson_mut_obj(doc);
 	}
 	// Initialize a re-usable value array
-	yyjson_mut_val *vals[STANDARD_VECTOR_SIZE];
+	auto vals = (yyjson_mut_val **)alc->malloc(alc->ctx, sizeof(yyjson_mut_val *) * count);
 	// Loop through key/value pairs
 	for (idx_t pair_idx = 0; pair_idx < args.data.size() / 2; pair_idx++) {
 		Vector &key_v = args.data[pair_idx * 2];
 		Vector &value_v = args.data[pair_idx * 2 + 1];
-		CreateKeyValuePairs(info, doc, objs, vals, key_v, value_v, count);
+		CreateKeyValuePairs(info.const_struct_names, doc, objs, vals, key_v, value_v, count);
 	}
 	// Write JSON values to string
 	auto objects = FlatVector::GetData<string_t>(result);
@@ -461,15 +533,15 @@ static void ArrayFunction(DataChunk &args, ExpressionState &state, Vector &resul
 	// Initialize arrays
 	const idx_t count = args.size();
 	auto doc = JSONCommon::CreateDocument(alc);
-	yyjson_mut_val *arrs[STANDARD_VECTOR_SIZE];
+	auto arrs = (yyjson_mut_val **)alc->malloc(alc->ctx, sizeof(yyjson_mut_val *) * count);
 	for (idx_t i = 0; i < count; i++) {
 		arrs[i] = yyjson_mut_arr(doc);
 	}
 	// Initialize a re-usable value array
-	yyjson_mut_val *vals[STANDARD_VECTOR_SIZE];
+	auto vals = (yyjson_mut_val **)alc->malloc(alc->ctx, sizeof(yyjson_mut_val *) * count);
 	// Loop through args
 	for (auto &v : args.data) {
-		CreateValues(info, doc, vals, v, count);
+		CreateValues(info.const_struct_names, doc, vals, v, count);
 		for (idx_t i = 0; i < count; i++) {
 			yyjson_mut_arr_append(arrs[i], vals[i]);
 		}
@@ -485,22 +557,18 @@ static void ArrayFunction(DataChunk &args, ExpressionState &state, Vector &resul
 	}
 }
 
-static void ToJSONFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	const auto &info = (JSONCreateFunctionData &)*func_expr.bind_info;
-	auto &lstate = JSONFunctionLocalState::ResetAndGet(state);
-	auto alc = lstate.json_allocator.GetYYJSONAllocator();
-
+static void ToJSONFunctionInternal(const StructNames &names, Vector &input, const idx_t count, Vector &result,
+                                   yyjson_alc *alc) {
 	// Initialize array for values
-	const idx_t count = args.size();
 	auto doc = JSONCommon::CreateDocument(alc);
-	yyjson_mut_val *vals[STANDARD_VECTOR_SIZE];
-	CreateValues(info, doc, vals, args.data[0], count);
+	auto vals = (yyjson_mut_val **)alc->malloc(alc->ctx, sizeof(yyjson_mut_val *) * count);
+	CreateValues(names, doc, vals, input, count);
+
 	// Write JSON values to string
 	auto objects = FlatVector::GetData<string_t>(result);
 	auto &result_validity = FlatVector::Validity(result);
 	UnifiedVectorFormat input_data;
-	args.data[0].ToUnifiedFormat(count, input_data);
+	input.ToUnifiedFormat(count, input_data);
 	for (idx_t i = 0; i < count; i++) {
 		idx_t idx = input_data.sel->get_index(i);
 		if (input_data.validity.RowIsValid(idx)) {
@@ -510,11 +578,20 @@ static void ToJSONFunction(DataChunk &args, ExpressionState &state, Vector &resu
 		}
 	}
 
-	if (args.AllConstant()) {
+	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	}
 }
 
+static void ToJSONFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	const auto &info = (JSONCreateFunctionData &)*func_expr.bind_info;
+	auto &lstate = JSONFunctionLocalState::ResetAndGet(state);
+	auto alc = lstate.json_allocator.GetYYJSONAllocator();
+
+	ToJSONFunctionInternal(info.const_struct_names, args.data[0], args.size(), result, alc);
+}
+
 ScalarFunctionSet JSONFunctions::GetObjectFunction() {
 	ScalarFunction fun("json_object", {}, JSONCommon::JSONType(), ObjectFunction, JSONObjectBind, nullptr, nullptr,
 	                   JSONFunctionLocalState::Init);
@@ -552,4 +629,54 @@ ScalarFunctionSet JSONFunctions::GetRowToJSONFunction() {
 	return ScalarFunctionSet(fun);
 }
 
+struct NestedToJSONCastData : public BoundCastData {
+public:
+	NestedToJSONCastData() {
+	}
+
+	unique_ptr<BoundCastData> Copy() const override {
+		auto result = make_uniq<NestedToJSONCastData>();
+		for (auto &csn : const_struct_names) {
+			result->const_struct_names.emplace(csn.first, make_uniq<Vector>(csn.second->GetValue(0)));
+		}
+		return result;
+	}
+
+public:
+	StructNames const_struct_names;
+};
+
+static bool AnyToJSONCast(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.GetYYJSONAllocator();
+	const auto &names = parameters.cast_data->Cast<NestedToJSONCastData>().const_struct_names;
+
+	ToJSONFunctionInternal(names, source, count, result, alc);
+	return true;
+}
+
+BoundCastInfo AnyToJSONCastBind(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
+	auto cast_data = make_uniq<NestedToJSONCastData>();
+	GetJSONType(cast_data->const_struct_names, source);
+	return BoundCastInfo(AnyToJSONCast, std::move(cast_data), JSONFunctionLocalState::InitCastLocalState);
+}
+
+void JSONFunctions::RegisterJSONCreateCastFunctions(CastFunctionSet &casts) {
+	auto json_to_any_cost = casts.ImplicitCastCost(LogicalType::ANY, JSONCommon::JSONType());
+	casts.RegisterCastFunction(LogicalType::ANY, JSONCommon::JSONType(), AnyToJSONCastBind, json_to_any_cost);
+
+	const auto struct_type = LogicalType::STRUCT({{"any", LogicalType::ANY}});
+	auto struct_to_json_cost = casts.ImplicitCastCost(struct_type, LogicalType::VARCHAR) - 2;
+	casts.RegisterCastFunction(struct_type, JSONCommon::JSONType(), AnyToJSONCastBind, struct_to_json_cost);
+
+	const auto list_type = LogicalType::LIST(LogicalType::ANY);
+	auto list_to_json_cost = casts.ImplicitCastCost(list_type, LogicalType::VARCHAR) - 2;
+	casts.RegisterCastFunction(list_type, JSONCommon::JSONType(), AnyToJSONCastBind, list_to_json_cost);
+
+	const auto map_type = LogicalType::MAP(LogicalType::ANY, LogicalType::ANY);
+	auto map_to_json_cost = casts.ImplicitCastCost(map_type, LogicalType::VARCHAR) - 2;
+	casts.RegisterCastFunction(map_type, JSONCommon::JSONType(), AnyToJSONCastBind, map_to_json_cost);
+}
+
 } // namespace duckdb

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

@@ -59,11 +59,11 @@ static void MergePatchFunction(DataChunk &args, ExpressionState &state, Vector &
 	const auto count = args.size();
 
 	// Read the first json arg
-	yyjson_mut_val *origs[STANDARD_VECTOR_SIZE];
+	auto origs = (yyjson_mut_val **)alc->malloc(alc->ctx, sizeof(yyjson_mut_val *) * count);
 	ReadObjects(doc, args.data[0], origs, count);
 
 	// Read the next json args one by one and merge them into the first json arg
-	yyjson_mut_val *patches[STANDARD_VECTOR_SIZE];
+	auto patches = (yyjson_mut_val **)alc->malloc(alc->ctx, sizeof(yyjson_mut_val *) * count);
 	for (idx_t arg_idx = 1; arg_idx < args.data.size(); arg_idx++) {
 		ReadObjects(doc, args.data[arg_idx], patches, count);
 		for (idx_t i = 0; i < count; i++) {