duckdb 0.9.3-dev2.0 → 0.10.0

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

@@ -19,11 +19,11 @@ static inline LogicalTypeId MaxNumericType(LogicalTypeId &a, LogicalTypeId &b) {
 	return LogicalTypeId::BIGINT;
 }
 
-JSONStructureNode::JSONStructureNode() : initialized(false) {
+JSONStructureNode::JSONStructureNode() : initialized(false), count(0) {
 }
 
 JSONStructureNode::JSONStructureNode(yyjson_val *key_p, yyjson_val *val_p)
-    : key(make_uniq<string>(unsafe_yyjson_get_str(key_p), unsafe_yyjson_get_len(key_p))), initialized(false) {
+    : key(make_uniq<string>(unsafe_yyjson_get_str(key_p), unsafe_yyjson_get_len(key_p))), initialized(false), count(0) {
 	D_ASSERT(yyjson_is_str(key_p));
 	JSONStructure::ExtractStructure(val_p, *this);
 }
@@ -32,12 +32,14 @@ JSONStructureNode::JSONStructureNode(JSONStructureNode &&other) noexcept {
 	std::swap(key, other.key);
 	std::swap(initialized, other.initialized);
 	std::swap(descriptions, other.descriptions);
+	std::swap(count, other.count);
 }
 
 JSONStructureNode &JSONStructureNode::operator=(JSONStructureNode &&other) noexcept {
 	std::swap(key, other.key);
 	std::swap(initialized, other.initialized);
 	std::swap(descriptions, other.descriptions);
+	std::swap(count, other.count);
 	return *this;
 }
 
@@ -92,7 +94,8 @@ bool JSONStructureNode::ContainsVarchar() const {
 	return false;
 }
 
-void JSONStructureNode::InitializeCandidateTypes(const idx_t max_depth, idx_t depth) {
+void JSONStructureNode::InitializeCandidateTypes(const idx_t max_depth, const bool convert_strings_to_integers,
+                                                 idx_t depth) {
 	if (depth >= max_depth) {
 		return;
 	}
@@ -103,16 +106,21 @@ void JSONStructureNode::InitializeCandidateTypes(const idx_t max_depth, idx_t de
 	auto &description = descriptions[0];
 	if (description.type == LogicalTypeId::VARCHAR && !initialized) {
 		// We loop through the candidate types and format templates from back to front
-		description.candidate_types = {LogicalTypeId::UUID, LogicalTypeId::BIGINT, LogicalTypeId::TIMESTAMP,
-		                               LogicalTypeId::DATE, LogicalTypeId::TIME};
+		if (convert_strings_to_integers) {
+			description.candidate_types = {LogicalTypeId::UUID, LogicalTypeId::BIGINT, LogicalTypeId::TIMESTAMP,
+			                               LogicalTypeId::DATE, LogicalTypeId::TIME};
+		} else {
+			description.candidate_types = {LogicalTypeId::UUID, LogicalTypeId::TIMESTAMP, LogicalTypeId::DATE,
+			                               LogicalTypeId::TIME};
+		}
 	}
 	initialized = true;
 	for (auto &child : description.children) {
-		child.InitializeCandidateTypes(max_depth, depth + 1);
+		child.InitializeCandidateTypes(max_depth, convert_strings_to_integers, depth + 1);
 	}
 }
 
-void JSONStructureNode::RefineCandidateTypes(yyjson_val *vals[], idx_t count, Vector &string_vector,
+void JSONStructureNode::RefineCandidateTypes(yyjson_val *vals[], idx_t val_count, Vector &string_vector,
                                              ArenaAllocator &allocator, DateFormatMap &date_format_map) {
 	if (descriptions.size() != 1) {
 		// We can't refine types if we have more than 1 description (yet), defaults to JSON type for now
@@ -124,17 +132,17 @@ void JSONStructureNode::RefineCandidateTypes(yyjson_val *vals[], idx_t count, Ve
 	auto &description = descriptions[0];
 	switch (description.type) {
 	case LogicalTypeId::LIST:
-		return RefineCandidateTypesArray(vals, count, string_vector, allocator, date_format_map);
+		return RefineCandidateTypesArray(vals, val_count, string_vector, allocator, date_format_map);
 	case LogicalTypeId::STRUCT:
-		return RefineCandidateTypesObject(vals, count, string_vector, allocator, date_format_map);
+		return RefineCandidateTypesObject(vals, val_count, string_vector, allocator, date_format_map);
 	case LogicalTypeId::VARCHAR:
-		return RefineCandidateTypesString(vals, count, string_vector, date_format_map);
+		return RefineCandidateTypesString(vals, val_count, string_vector, date_format_map);
 	default:
 		return;
 	}
 }
 
-void JSONStructureNode::RefineCandidateTypesArray(yyjson_val *vals[], idx_t count, Vector &string_vector,
+void JSONStructureNode::RefineCandidateTypesArray(yyjson_val *vals[], idx_t val_count, Vector &string_vector,
                                                   ArenaAllocator &allocator, DateFormatMap &date_format_map) {
 	D_ASSERT(descriptions.size() == 1 && descriptions[0].type == LogicalTypeId::LIST);
 	auto &desc = descriptions[0];
@@ -142,7 +150,7 @@ void JSONStructureNode::RefineCandidateTypesArray(yyjson_val *vals[], idx_t coun
 	auto &child = desc.children[0];
 
 	idx_t total_list_size = 0;
-	for (idx_t i = 0; i < count; i++) {
+	for (idx_t i = 0; i < val_count; i++) {
 		if (vals[i] && !unsafe_yyjson_is_null(vals[i])) {
 			D_ASSERT(yyjson_is_arr(vals[i]));
 			total_list_size += unsafe_yyjson_get_len(vals[i]);
@@ -155,7 +163,7 @@ void JSONStructureNode::RefineCandidateTypesArray(yyjson_val *vals[], idx_t coun
 
 	size_t idx, max;
 	yyjson_val *child_val;
-	for (idx_t i = 0; i < count; i++) {
+	for (idx_t i = 0; i < val_count; i++) {
 		if (vals[i] && !unsafe_yyjson_is_null(vals[i])) {
 			yyjson_arr_foreach(vals[i], idx, max, child_val) {
 				child_vals[offset++] = child_val;
@@ -165,7 +173,7 @@ void JSONStructureNode::RefineCandidateTypesArray(yyjson_val *vals[], idx_t coun
 	child.RefineCandidateTypes(child_vals, total_list_size, string_vector, allocator, date_format_map);
 }
 
-void JSONStructureNode::RefineCandidateTypesObject(yyjson_val *vals[], idx_t count, Vector &string_vector,
+void JSONStructureNode::RefineCandidateTypesObject(yyjson_val *vals[], idx_t val_count, Vector &string_vector,
                                                    ArenaAllocator &allocator, DateFormatMap &date_format_map) {
 	D_ASSERT(descriptions.size() == 1 && descriptions[0].type == LogicalTypeId::STRUCT);
 	auto &desc = descriptions[0];
@@ -175,7 +183,7 @@ void JSONStructureNode::RefineCandidateTypesObject(yyjson_val *vals[], idx_t cou
 	child_vals.reserve(child_count);
 	for (idx_t child_idx = 0; child_idx < child_count; child_idx++) {
 		child_vals.emplace_back(
-		    reinterpret_cast<yyjson_val **>(allocator.AllocateAligned(count * sizeof(yyjson_val *))));
+		    reinterpret_cast<yyjson_val **>(allocator.AllocateAligned(val_count * sizeof(yyjson_val *))));
 	}
 
 	idx_t found_key_count;
@@ -184,7 +192,7 @@ void JSONStructureNode::RefineCandidateTypesObject(yyjson_val *vals[], idx_t cou
 	const auto &key_map = desc.key_map;
 	size_t idx, max;
 	yyjson_val *child_key, *child_val;
-	for (idx_t i = 0; i < count; i++) {
+	for (idx_t i = 0; i < val_count; i++) {
 		if (vals[i] && !unsafe_yyjson_is_null(vals[i])) {
 			found_key_count = 0;
 			memset(found_keys, false, child_count);
@@ -218,23 +226,24 @@ void JSONStructureNode::RefineCandidateTypesObject(yyjson_val *vals[], idx_t cou
 	}
 
 	for (idx_t child_idx = 0; child_idx < child_count; child_idx++) {
-		desc.children[child_idx].RefineCandidateTypes(child_vals[child_idx], count, string_vector, allocator,
+		desc.children[child_idx].RefineCandidateTypes(child_vals[child_idx], val_count, string_vector, allocator,
 		                                              date_format_map);
 	}
 }
 
-void JSONStructureNode::RefineCandidateTypesString(yyjson_val *vals[], idx_t count, Vector &string_vector,
+void JSONStructureNode::RefineCandidateTypesString(yyjson_val *vals[], idx_t val_count, Vector &string_vector,
                                                    DateFormatMap &date_format_map) {
 	D_ASSERT(descriptions.size() == 1 && descriptions[0].type == LogicalTypeId::VARCHAR);
 	if (descriptions[0].candidate_types.empty()) {
 		return;
 	}
 	static JSONTransformOptions OPTIONS;
-	JSONTransform::GetStringVector(vals, count, LogicalType::SQLNULL, string_vector, OPTIONS);
-	EliminateCandidateTypes(count, string_vector, date_format_map);
+	JSONTransform::GetStringVector(vals, val_count, LogicalType::SQLNULL, string_vector, OPTIONS);
+	EliminateCandidateTypes(val_count, string_vector, date_format_map);
 }
 
-void JSONStructureNode::EliminateCandidateTypes(idx_t count, Vector &string_vector, DateFormatMap &date_format_map) {
+void JSONStructureNode::EliminateCandidateTypes(idx_t vec_count, Vector &string_vector,
+                                                DateFormatMap &date_format_map) {
 	D_ASSERT(descriptions.size() == 1 && descriptions[0].type == LogicalTypeId::VARCHAR);
 	auto &description = descriptions[0];
 	auto &candidate_types = description.candidate_types;
@@ -243,17 +252,17 @@ void JSONStructureNode::EliminateCandidateTypes(idx_t count, Vector &string_vect
 			return;
 		}
 		const auto type = candidate_types.back();
-		Vector result_vector(type, count);
+		Vector result_vector(type, vec_count);
 		if (date_format_map.HasFormats(type)) {
 			auto &formats = date_format_map.GetCandidateFormats(type);
-			if (EliminateCandidateFormats(count, string_vector, result_vector, formats)) {
+			if (EliminateCandidateFormats(vec_count, string_vector, result_vector, formats)) {
 				return;
 			} else {
 				candidate_types.pop_back();
 			}
 		} else {
 			string error_message;
-			if (!VectorOperations::DefaultTryCast(string_vector, result_vector, count, &error_message, true)) {
+			if (!VectorOperations::DefaultTryCast(string_vector, result_vector, vec_count, &error_message, true)) {
 				candidate_types.pop_back();
 			} else {
 				return;
@@ -287,7 +296,7 @@ bool TryParse(Vector &string_vector, StrpTimeFormat &format, const idx_t count)
 	return true;
 }
 
-bool JSONStructureNode::EliminateCandidateFormats(idx_t count, Vector &string_vector, Vector &result_vector,
+bool JSONStructureNode::EliminateCandidateFormats(idx_t vec_count, Vector &string_vector, Vector &result_vector,
                                                   vector<StrpTimeFormat> &formats) {
 	D_ASSERT(descriptions.size() == 1 && descriptions[0].type == LogicalTypeId::VARCHAR);
 	const auto type = result_vector.GetType().id();
@@ -297,10 +306,10 @@ bool JSONStructureNode::EliminateCandidateFormats(idx_t count, Vector &string_ve
 		bool success;
 		switch (type) {
 		case LogicalTypeId::DATE:
-			success = TryParse<TryParseDate, date_t>(string_vector, format, count);
+			success = TryParse<TryParseDate, date_t>(string_vector, format, vec_count);
 			break;
 		case LogicalTypeId::TIMESTAMP:
-			success = TryParse<TryParseTimeStamp, timestamp_t>(string_vector, format, count);
+			success = TryParse<TryParseTimeStamp, timestamp_t>(string_vector, format, vec_count);
 			break;
 		default:
 			throw InternalException("No date/timestamp formats for %s", EnumUtil::ToString(type));
@@ -399,6 +408,7 @@ static inline void ExtractStructureVal(yyjson_val *val, JSONStructureNode &node)
 }
 
 void JSONStructure::ExtractStructure(yyjson_val *val, JSONStructureNode &node) {
+	node.count++;
 	switch (yyjson_get_tag(val)) {
 	case YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE:
 		return ExtractStructureArray(val, node);
@@ -433,7 +443,7 @@ static inline yyjson_mut_val *ConvertStructureObject(const JSONStructureNode &no
 	auto &desc = node.descriptions[0];
 	if (desc.children.empty()) {
 		// Empty struct - let's do JSON instead
-		return yyjson_mut_str(doc, JSONCommon::JSON_TYPE_NAME);
+		return yyjson_mut_str(doc, LogicalType::JSON_TYPE_NAME);
 	}
 
 	auto obj = yyjson_mut_obj(doc);
@@ -450,7 +460,7 @@ static inline yyjson_mut_val *ConvertStructure(const JSONStructureNode &node, yy
 		return yyjson_mut_str(doc, JSONCommon::TYPE_STRING_NULL);
 	}
 	if (node.descriptions.size() != 1) { // Inconsistent types, so we resort to JSON
-		return yyjson_mut_str(doc, JSONCommon::JSON_TYPE_NAME);
+		return yyjson_mut_str(doc, LogicalType::JSON_TYPE_NAME);
 	}
 	auto &desc = node.descriptions[0];
 	D_ASSERT(desc.type != LogicalTypeId::INVALID);
@@ -474,40 +484,57 @@ static void StructureFunction(DataChunk &args, ExpressionState &state, Vector &r
 }
 
 static void GetStructureFunctionInternal(ScalarFunctionSet &set, const LogicalType &input_type) {
-	set.AddFunction(ScalarFunction({input_type}, JSONCommon::JSONType(), StructureFunction, nullptr, nullptr, nullptr,
+	set.AddFunction(ScalarFunction({input_type}, LogicalType::JSON(), StructureFunction, nullptr, nullptr, nullptr,
 	                               JSONFunctionLocalState::Init));
 }
 
 ScalarFunctionSet JSONFunctions::GetStructureFunction() {
 	ScalarFunctionSet set("json_structure");
 	GetStructureFunctionInternal(set, LogicalType::VARCHAR);
-	GetStructureFunctionInternal(set, JSONCommon::JSONType());
+	GetStructureFunctionInternal(set, LogicalType::JSON());
 	return set;
 }
 
 static LogicalType StructureToTypeArray(ClientContext &context, const JSONStructureNode &node, const idx_t max_depth,
-                                        idx_t depth) {
+                                        const double field_appearance_threshold, idx_t depth,
+                                        const idx_t sample_count) {
 	D_ASSERT(node.descriptions.size() == 1 && node.descriptions[0].type == LogicalTypeId::LIST);
 	const auto &desc = node.descriptions[0];
 	D_ASSERT(desc.children.size() == 1);
 
-	return LogicalType::LIST(JSONStructure::StructureToType(context, desc.children[0], max_depth, depth + 1));
+	return LogicalType::LIST(JSONStructure::StructureToType(
+	    context, desc.children[0], max_depth, field_appearance_threshold, depth + 1, desc.children[0].count));
 }
 
 static LogicalType StructureToTypeObject(ClientContext &context, const JSONStructureNode &node, const idx_t max_depth,
-                                         idx_t depth) {
+                                         const double field_appearance_threshold, idx_t depth,
+                                         const idx_t sample_count) {
 	D_ASSERT(node.descriptions.size() == 1 && node.descriptions[0].type == LogicalTypeId::STRUCT);
 	auto &desc = node.descriptions[0];
+
+	// If it's an empty struct we do JSON instead
 	if (desc.children.empty()) {
 		// Empty struct - let's do JSON instead
-		return JSONCommon::JSONType();
+		return LogicalType::JSON();
+	}
+
+	// If it's an inconsistent object we also just do JSON
+	double total_child_counts = 0;
+	for (const auto &child : desc.children) {
+		total_child_counts += double(child.count) / sample_count;
+	}
+	const auto avg_occurrence = total_child_counts / desc.children.size();
+	if (avg_occurrence < field_appearance_threshold) {
+		return LogicalType::JSON();
 	}
 
 	child_list_t<LogicalType> child_types;
 	child_types.reserve(desc.children.size());
 	for (auto &child : desc.children) {
 		D_ASSERT(child.key);
-		child_types.emplace_back(*child.key, JSONStructure::StructureToType(context, child, max_depth, depth + 1));
+		child_types.emplace_back(*child.key,
+		                         JSONStructure::StructureToType(context, child, max_depth, field_appearance_threshold,
+		                                                        depth + 1, sample_count));
 	}
 	return LogicalType::STRUCT(child_types);
 }
@@ -522,27 +549,28 @@ static LogicalType StructureToTypeString(const JSONStructureNode &node) {
 }
 
 LogicalType JSONStructure::StructureToType(ClientContext &context, const JSONStructureNode &node, const idx_t max_depth,
-                                           idx_t depth) {
+                                           const double field_appearance_threshold, idx_t depth, idx_t sample_count) {
 	if (depth >= max_depth) {
-		return JSONCommon::JSONType();
+		return LogicalType::JSON();
 	}
 	if (node.descriptions.empty()) {
-		return JSONCommon::JSONType();
+		return LogicalType::JSON();
 	}
 	if (node.descriptions.size() != 1) { // Inconsistent types, so we resort to JSON
-		return JSONCommon::JSONType();
+		return LogicalType::JSON();
 	}
+	sample_count = sample_count == DConstants::INVALID_INDEX ? node.count : sample_count;
 	auto &desc = node.descriptions[0];
 	D_ASSERT(desc.type != LogicalTypeId::INVALID);
 	switch (desc.type) {
 	case LogicalTypeId::LIST:
-		return StructureToTypeArray(context, node, max_depth, depth);
+		return StructureToTypeArray(context, node, max_depth, field_appearance_threshold, depth, sample_count);
 	case LogicalTypeId::STRUCT:
-		return StructureToTypeObject(context, node, max_depth, depth);
+		return StructureToTypeObject(context, node, max_depth, field_appearance_threshold, depth, sample_count);
 	case LogicalTypeId::VARCHAR:
 		return StructureToTypeString(node);
 	case LogicalTypeId::SQLNULL:
-		return JSONCommon::JSONType();
+		return LogicalType::JSON();
 	case LogicalTypeId::UBIGINT:
 		return LogicalTypeId::BIGINT; // We prefer not to return UBIGINT in our type auto-detection
 	default:

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

@@ -79,7 +79,7 @@ static unique_ptr<FunctionData> JSONTransformBind(ClientContext &context, Scalar
 	if (structure_val.IsNull() || arguments[1]->return_type == LogicalTypeId::SQLNULL) {
 		bound_function.return_type = LogicalTypeId::SQLNULL;
 	} else {
-		if (!structure_val.DefaultTryCastAs(JSONCommon::JSONType())) {
+		if (!structure_val.DefaultTryCastAs(LogicalType::JSON())) {
 			throw BinderException("Cannot cast JSON structure to string");
 		}
 		auto structure_string = structure_val.GetValueUnsafe<string_t>();
@@ -489,8 +489,8 @@ static bool TransformObjectInternal(yyjson_val *objects[], yyjson_alc *alc, Vect
 	return JSONTransform::TransformObject(objects, alc, count, child_names, child_vectors, options);
 }
 
-static bool TransformArray(yyjson_val *arrays[], yyjson_alc *alc, Vector &result, const idx_t count,
-                           JSONTransformOptions &options) {
+static bool TransformArrayToList(yyjson_val *arrays[], yyjson_alc *alc, Vector &result, const idx_t count,
+                                 JSONTransformOptions &options) {
 	bool success = true;
 
 	// Initialize list vector
@@ -567,6 +567,96 @@ static bool TransformArray(yyjson_val *arrays[], yyjson_alc *alc, Vector &result
 	return success;
 }
 
+static bool TransformArrayToArray(yyjson_val *arrays[], yyjson_alc *alc, Vector &result, const idx_t count,
+                                  JSONTransformOptions &options) {
+	bool success = true;
+
+	// Initialize array vector
+	auto &result_validity = FlatVector::Validity(result);
+	auto array_size = ArrayType::GetSize(result.GetType());
+	auto child_count = count * array_size;
+
+	for (idx_t i = 0; i < count; i++) {
+		const auto &arr = arrays[i];
+		if (!arr || unsafe_yyjson_is_null(arr)) {
+			result_validity.SetInvalid(i);
+			continue;
+		}
+
+		if (!unsafe_yyjson_is_arr(arr)) {
+			result_validity.SetInvalid(i);
+			if (success && options.strict_cast) {
+				options.error_message =
+				    StringUtil::Format("Expected ARRAY, but got %s: %s", JSONCommon::ValTypeToString(arrays[i]),
+				                       JSONCommon::ValToString(arrays[i], 50));
+				options.object_index = i;
+				success = false;
+			}
+			continue;
+		}
+
+		auto json_arr_size = unsafe_yyjson_get_len(arr);
+		if (json_arr_size != array_size) {
+			result_validity.SetInvalid(i);
+			if (success && options.strict_cast) {
+				options.error_message =
+				    StringUtil::Format("Expected array of size %u, but got '%s' with size %u", array_size,
+				                       JSONCommon::ValToString(arrays[i], 50), json_arr_size);
+				options.object_index = i;
+				success = false;
+			}
+			continue;
+		}
+	}
+
+	// Initialize array for the nested values
+	auto nested_vals = JSONCommon::AllocateArray<yyjson_val *>(alc, child_count);
+
+	// Get array values
+	size_t idx, max;
+	yyjson_val *val;
+	idx_t nested_elem_idx = 0;
+	for (idx_t i = 0; i < count; i++) {
+		if (!result_validity.RowIsValid(i)) {
+			// We already marked this as invalid, but we still need to increment nested_elem_idx
+			// and set the nullptrs (otherwise indexing will break after compaction)
+			for (idx_t j = 0; j < array_size; j++) {
+				nested_vals[nested_elem_idx] = nullptr;
+				nested_elem_idx++;
+			};
+		} else {
+			yyjson_arr_foreach(arrays[i], idx, max, val) {
+				nested_vals[nested_elem_idx] = val;
+				nested_elem_idx++;
+			}
+		}
+	}
+
+	if (!success) {
+		// Set object index in case of error in nested array so we can get accurate line number information
+		for (idx_t i = 0; i < count; i++) {
+			if (!result_validity.RowIsValid(i)) {
+				continue;
+			}
+			auto offset = i * array_size;
+			if (options.object_index >= offset && options.object_index < offset + array_size) {
+				options.object_index = i;
+			}
+		}
+	}
+
+	// Transform array values
+	if (!JSONTransform::Transform(nested_vals, alc, ArrayVector::GetEntry(result), child_count, options)) {
+		success = false;
+	}
+
+	if (!options.delay_error && !success) {
+		throw InvalidInputException(options.error_message);
+	}
+
+	return success;
+}
+
 static bool TransformObjectToMap(yyjson_val *objects[], yyjson_alc *alc, Vector &result, const idx_t count,
                                  JSONTransformOptions &options) {
 	// Pre-allocate list vector
@@ -736,7 +826,7 @@ bool JSONTransform::Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &resul
 		return TransformFromStringWithFormat(vals, result, count, options);
 	}
 
-	if (JSONCommon::LogicalTypeIsJSON(result_type)) {
+	if (result_type.IsJSONType()) {
 		return TransformToJSON(vals, alc, result, count);
 	}
 
@@ -764,6 +854,8 @@ bool JSONTransform::Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &resul
 		return TransformNumerical<uint64_t>(vals, result, count, options);
 	case LogicalTypeId::HUGEINT:
 		return TransformNumerical<hugeint_t>(vals, result, count, options);
+	case LogicalTypeId::UHUGEINT:
+		return TransformNumerical<uhugeint_t>(vals, result, count, options);
 	case LogicalTypeId::FLOAT:
 		return TransformNumerical<float>(vals, result, count, options);
 	case LogicalTypeId::DOUBLE:
@@ -803,11 +895,13 @@ bool JSONTransform::Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &resul
 	case LogicalTypeId::STRUCT:
 		return TransformObjectInternal(vals, alc, result, count, options);
 	case LogicalTypeId::LIST:
-		return TransformArray(vals, alc, result, count, options);
+		return TransformArrayToList(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);
+	case LogicalTypeId::ARRAY:
+		return TransformArrayToArray(vals, alc, result, count, options);
 	default:
 		throw NotImplementedException("Cannot read a value of type %s from a json file", result_type.ToString());
 	}
@@ -862,7 +956,7 @@ static void GetTransformFunctionInternal(ScalarFunctionSet &set, const LogicalTy
 ScalarFunctionSet JSONFunctions::GetTransformFunction() {
 	ScalarFunctionSet set("json_transform");
 	GetTransformFunctionInternal(set, LogicalType::VARCHAR);
-	GetTransformFunctionInternal(set, JSONCommon::JSONType());
+	GetTransformFunctionInternal(set, LogicalType::JSON());
 	return set;
 }
 
@@ -874,7 +968,7 @@ static void GetTransformStrictFunctionInternal(ScalarFunctionSet &set, const Log
 ScalarFunctionSet JSONFunctions::GetTransformStrictFunction() {
 	ScalarFunctionSet set("json_transform_strict");
 	GetTransformStrictFunctionInternal(set, LogicalType::VARCHAR);
-	GetTransformStrictFunctionInternal(set, JSONCommon::JSONType());
+	GetTransformStrictFunctionInternal(set, LogicalType::JSON());
 	return set;
 }
 
@@ -914,6 +1008,9 @@ void JSONFunctions::RegisterJSONTransformCastFunctions(CastFunctionSet &casts) {
 		case LogicalTypeId::UNION:
 			target_type = LogicalType::UNION({{"any", LogicalType::ANY}});
 			break;
+		case LogicalTypeId::ARRAY:
+			target_type = LogicalType::ARRAY(LogicalType::ANY);
+			break;
 		case LogicalTypeId::VARCHAR:
 			// We skip this one here as it's handled in json_functions.cpp
 			continue;
@@ -922,7 +1019,7 @@ void JSONFunctions::RegisterJSONTransformCastFunctions(CastFunctionSet &casts) {
 		}
 		// 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(JSONCommon::JSONType(), target_type, JSONToAnyCastBind, json_to_target_cost);
+		casts.RegisterCastFunction(LogicalType::JSON(), target_type, JSONToAnyCastBind, json_to_target_cost);
 	}
 }
 

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

@@ -31,7 +31,7 @@ static void GetTypeFunctionsInternal(ScalarFunctionSet &set, const LogicalType &
 ScalarFunctionSet JSONFunctions::GetTypeFunction() {
 	ScalarFunctionSet set("json_type");
 	GetTypeFunctionsInternal(set, LogicalType::VARCHAR);
-	GetTypeFunctionsInternal(set, JSONCommon::JSONType());
+	GetTypeFunctionsInternal(set, LogicalType::JSON());
 	return set;
 }
 

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

@@ -19,7 +19,7 @@ static void GetValidFunctionInternal(ScalarFunctionSet &set, const LogicalType &
 ScalarFunctionSet JSONFunctions::GetValidFunction() {
 	ScalarFunctionSet set("json_valid");
 	GetValidFunctionInternal(set, LogicalType::VARCHAR);
-	GetValidFunctionInternal(set, JSONCommon::JSONType());
+	GetValidFunctionInternal(set, LogicalType::JSON());
 
 	return set;
 }