duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

package/src/duckdb/extension/icu/icu_extension.cpp

@@ -26,6 +26,7 @@
 #include "include/icu_extension.hpp"
 #include "unicode/calendar.h"
 #include "unicode/coll.h"
+#include "unicode/errorcode.h"
 #include "unicode/sortkey.h"
 #include "unicode/stringpiece.h"
 #include "unicode/timezone.h"
@@ -39,6 +40,10 @@ struct IcuBindData : public FunctionData {
 	duckdb::unique_ptr<icu::Collator> collator;
 	string language;
 	string country;
+	string tag;
+
+	explicit IcuBindData(duckdb::unique_ptr<icu::Collator> collator_p) : collator(std::move(collator_p)) {
+	}
 
 	IcuBindData(string language_p, string country_p) : language(std::move(language_p)), country(std::move(country_p)) {
 		UErrorCode status = U_ZERO_ERROR;
@@ -54,13 +59,32 @@ struct IcuBindData : public FunctionData {
 		}
 	}
 
+	explicit IcuBindData(string tag_p) : tag(std::move(tag_p)) {
+		UErrorCode status = U_ZERO_ERROR;
+		UCollator *ucollator = ucol_open(tag.c_str(), &status);
+		if (U_FAILURE(status)) {
+			auto error_name = u_errorName(status);
+			throw InvalidInputException("Failed to create ICU collator with tag %s: %s", tag, error_name);
+		}
+		collator = unique_ptr<icu::Collator>(icu::Collator::fromUCollator(ucollator));
+	}
+
+	static duckdb::unique_ptr<FunctionData> CreateInstance(string language, string country, string tag) {
+		//! give priority to tagged collation
+		if (!tag.empty()) {
+			return make_uniq<IcuBindData>(tag);
+		} else {
+			return make_uniq<IcuBindData>(language, country);
+		}
+	}
+
 	duckdb::unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<IcuBindData>(language, country);
+		return CreateInstance(language, country, tag);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
 		auto &other = other_p.Cast<IcuBindData>();
-		return language == other.language && country == other.country;
+		return language == other.language && country == other.country && tag == other.tag;
 	}
 
 	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
@@ -68,15 +92,17 @@ struct IcuBindData : public FunctionData {
 		auto &bind_data = bind_data_p->Cast<IcuBindData>();
 		serializer.WriteProperty(100, "language", bind_data.language);
 		serializer.WriteProperty(101, "country", bind_data.country);
+		serializer.WritePropertyWithDefault<string>(102, "tag", bind_data.tag);
 	}
 
 	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, ScalarFunction &function) {
 		string language;
 		string country;
+		string tag;
 		deserializer.ReadProperty(100, "language", language);
 		deserializer.ReadProperty(101, "country", country);
-
-		return make_uniq<IcuBindData>(language, country);
+		deserializer.ReadPropertyWithDefault<string>(102, "tag", tag);
+		return CreateInstance(language, country, tag);
 	}
 
 	static const string FUNCTION_PREFIX;
@@ -94,7 +120,7 @@ const string IcuBindData::FUNCTION_PREFIX = "icu_collate_";
 static int32_t ICUGetSortKey(icu::Collator &collator, string_t input, duckdb::unique_ptr<char[]> &buffer,
                              int32_t &buffer_size) {
 	icu::UnicodeString unicode_string =
-	    icu::UnicodeString::fromUTF8(icu::StringPiece(input.GetData(), input.GetSize()));
+	    icu::UnicodeString::fromUTF8(icu::StringPiece(input.GetData(), int32_t(input.GetSize())));
 	int32_t string_size = collator.getSortKey(unicode_string, reinterpret_cast<uint8_t *>(buffer.get()), buffer_size);
 	if (string_size > buffer_size) {
 		// have to resize the buffer
@@ -135,6 +161,10 @@ static void ICUCollateFunction(DataChunk &args, ExpressionState &state, Vector &
 
 static duckdb::unique_ptr<FunctionData> ICUCollateBind(ClientContext &context, ScalarFunction &bound_function,
                                                        vector<duckdb::unique_ptr<Expression>> &arguments) {
+	//! Return a tagged collator
+	if (!bound_function.extra_info.empty()) {
+		return make_uniq<IcuBindData>(bound_function.extra_info);
+	}
 
 	const auto collation = IcuBindData::DecodeFunctionName(bound_function.name);
 	auto splits = StringUtil::Split(collation, "_");
@@ -156,6 +186,10 @@ static duckdb::unique_ptr<FunctionData> ICUSortKeyBind(ClientContext &context, S
 	if (val.IsNull()) {
 		throw NotImplementedException("ICU_SORT_KEY(VARCHAR, VARCHAR) expected a non-null collation");
 	}
+	//! Verify tagged collation
+	if (!bound_function.extra_info.empty()) {
+		return make_uniq<IcuBindData>(bound_function.extra_info);
+	}
 	auto splits = StringUtil::Split(StringValue::Get(val), "_");
 	if (splits.size() == 1) {
 		return make_uniq<IcuBindData>(splits[0], "");
@@ -166,20 +200,23 @@ static duckdb::unique_ptr<FunctionData> ICUSortKeyBind(ClientContext &context, S
 	}
 }
 
-static ScalarFunction GetICUCollateFunction(const string &collation) {
+static ScalarFunction GetICUCollateFunction(const string &collation, const string &tag) {
 	string fname = IcuBindData::EncodeFunctionName(collation);
 	ScalarFunction result(fname, {LogicalType::VARCHAR}, LogicalType::VARCHAR, ICUCollateFunction, ICUCollateBind);
+	//! collation tag is added into the Function extra info
+	result.extra_info = tag;
 	result.serialize = IcuBindData::Serialize;
 	result.deserialize = IcuBindData::Deserialize;
 	return result;
 }
 
 static void SetICUTimeZone(ClientContext &context, SetScope scope, Value &parameter) {
-	icu::StringPiece utf8(StringValue::Get(parameter));
+	auto str = StringValue::Get(parameter);
+	icu::StringPiece utf8(str);
 	const auto uid = icu::UnicodeString::fromUTF8(utf8);
 	duckdb::unique_ptr<icu::TimeZone> tz(icu::TimeZone::createTimeZone(uid));
 	if (*tz == icu::TimeZone::getUnknown()) {
-		throw NotImplementedException("Unknown TimeZone setting");
+		throw NotImplementedException("Unknown TimeZone '%s'", str);
 	}
 }
 
@@ -259,9 +296,24 @@ static void LoadInternal(DuckDB &ddb) {
 		}
 		collation = StringUtil::Lower(collation);
 
-		CreateCollationInfo info(collation, GetICUCollateFunction(collation), false, false);
+		CreateCollationInfo info(collation, GetICUCollateFunction(collation, ""), false, false);
 		ExtensionUtil::RegisterCollation(db, info);
 	}
+
+	/**
+	 * This collation function is inpired on the Postgres "ignore_accents":
+	 * See: https://www.postgresql.org/docs/current/collation.html
+	 * CREATE COLLATION ignore_accents (provider = icu, locale = 'und-u-ks-level1-kc-true', deterministic = false);
+	 *
+	 * Also, according with the source file: postgres/src/backend/utils/adt/pg_locale.c.
+	 * "und-u-kc-ks-level1" is converted to the equivalent ICU format locale ID,
+	 * e.g. "und@colcaselevel=yes;colstrength=primary"
+	 *
+	 */
+	CreateCollationInfo info("icu_noaccent", GetICUCollateFunction("noaccent", "und-u-ks-level1-kc-true"), false,
+	                         false);
+	ExtensionUtil::RegisterCollation(db, info);
+
 	ScalarFunction sort_key("icu_sort_key", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                        ICUCollateFunction, ICUSortKeyBind);
 	ExtensionUtil::RegisterFunction(db, sort_key);

package/src/duckdb/extension/json/include/json_executors.hpp

@@ -13,26 +13,28 @@
 
 namespace duckdb {
 
+template <class T>
+using json_function_t = std::function<T(yyjson_val *, yyjson_alc *, Vector &, ValidityMask &, idx_t)>;
+
 struct JSONExecutors {
 public:
 	//! Single-argument JSON read function, i.e. json_type('[1, 2, 3]')
 	template <class T>
-	static void UnaryExecute(DataChunk &args, ExpressionState &state, Vector &result,
-	                         std::function<T(yyjson_val *, yyjson_alc *, Vector &)> fun) {
+	static void UnaryExecute(DataChunk &args, ExpressionState &state, Vector &result, const json_function_t<T> fun) {
 		auto &lstate = JSONFunctionLocalState::ResetAndGet(state);
 		auto alc = lstate.json_allocator.GetYYAlc();
 
 		auto &inputs = args.data[0];
-		UnaryExecutor::Execute<string_t, T>(inputs, result, args.size(), [&](string_t input) {
-			auto doc = JSONCommon::ReadDocument(input, JSONCommon::READ_FLAG, alc);
-			return fun(doc->root, alc, result);
-		});
+		UnaryExecutor::ExecuteWithNulls<string_t, T>(
+		    inputs, result, args.size(), [&](string_t input, ValidityMask &mask, idx_t idx) {
+			    auto doc = JSONCommon::ReadDocument(input, JSONCommon::READ_FLAG, alc);
+			    return fun(doc->root, alc, result, mask, idx);
+		    });
 	}
 
 	//! Two-argument JSON read function (with path query), i.e. json_type('[1, 2, 3]', '$[0]')
-	template <class T, bool NULL_IF_NULL = true>
-	static void BinaryExecute(DataChunk &args, ExpressionState &state, Vector &result,
-	                          std::function<T(yyjson_val *, yyjson_alc *, Vector &)> fun) {
+	template <class T, bool SET_NULL_IF_NOT_FOUND = true>
+	static void BinaryExecute(DataChunk &args, ExpressionState &state, Vector &result, const json_function_t<T> fun) {
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		const auto &info = func_expr.bind_info->Cast<JSONReadFunctionData>();
 		auto &lstate = JSONFunctionLocalState::ResetAndGet(state);
@@ -48,11 +50,11 @@ public:
 					    auto doc =
 					        JSONCommon::ReadDocument(input, JSONCommon::READ_FLAG, lstate.json_allocator.GetYYAlc());
 					    auto val = JSONCommon::GetUnsafe(doc->root, ptr, len);
-					    if (!val || (NULL_IF_NULL && unsafe_yyjson_is_null(val))) {
+					    if (SET_NULL_IF_NOT_FOUND && !val) {
 						    mask.SetInvalid(idx);
 						    return T {};
 					    } else {
-						    return fun(val, alc, result);
+						    return fun(val, alc, result, mask, idx);
 					    }
 				    });
 			} else {
@@ -76,11 +78,7 @@ public:
 					for (idx_t i = 0; i < vals.size(); i++) {
 						auto &val = vals[i];
 						D_ASSERT(val != nullptr); // Wildcard extract shouldn't give back nullptrs
-						if (NULL_IF_NULL && unsafe_yyjson_is_null(val)) {
-							child_validity.SetInvalid(current_size + i);
-						} else {
-							child_vals[current_size + i] = fun(val, alc, result);
-						}
+						child_vals[current_size + i] = fun(val, alc, result, child_validity, current_size + i);
 					}
 
 					ListVector::SetListSize(result, new_size);
@@ -95,11 +93,11 @@ public:
 			    inputs, paths, result, args.size(), [&](string_t input, string_t path, ValidityMask &mask, idx_t idx) {
 				    auto doc = JSONCommon::ReadDocument(input, JSONCommon::READ_FLAG, lstate.json_allocator.GetYYAlc());
 				    auto val = JSONCommon::Get(doc->root, path);
-				    if (!val || unsafe_yyjson_is_null(val)) {
+				    if (SET_NULL_IF_NOT_FOUND && !val) {
 					    mask.SetInvalid(idx);
 					    return T {};
 				    } else {
-					    return fun(val, alc, result);
+					    return fun(val, alc, result, mask, idx);
 				    }
 			    });
 		}
@@ -109,9 +107,8 @@ public:
 	}
 
 	//! JSON read function with list of path queries, i.e. json_type('[1, 2, 3]', ['$[0]', '$[1]'])
-	template <class T, bool NULL_IF_NULL = true>
-	static void ExecuteMany(DataChunk &args, ExpressionState &state, Vector &result,
-	                        std::function<T(yyjson_val *, yyjson_alc *, Vector &)> fun) {
+	template <class T, bool SET_NULL_IF_NOT_FOUND = true>
+	static void ExecuteMany(DataChunk &args, ExpressionState &state, Vector &result, const json_function_t<T> fun) {
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		const auto &info = func_expr.bind_info->Cast<JSONReadManyFunctionData>();
 		auto &lstate = JSONFunctionLocalState::ResetAndGet(state);
@@ -148,10 +145,10 @@ public:
 			for (idx_t path_i = 0; path_i < num_paths; path_i++) {
 				auto child_idx = offset + path_i;
 				val = JSONCommon::GetUnsafe(doc->root, info.ptrs[path_i], info.lens[path_i]);
-				if (!val || (NULL_IF_NULL && unsafe_yyjson_is_null(val))) {
+				if (SET_NULL_IF_NOT_FOUND && !val) {
 					child_validity.SetInvalid(child_idx);
 				} else {
-					child_data[child_idx] = fun(val, alc, child);
+					child_data[child_idx] = fun(val, alc, child, child_validity, child_idx);
 				}
 			}
 

package/src/duckdb/extension/json/include/json_functions.hpp

@@ -96,13 +96,17 @@ private:
 
 	static ScalarFunctionSet GetArrayLengthFunction();
 	static ScalarFunctionSet GetContainsFunction();
+	static ScalarFunctionSet GetExistsFunction();
 	static ScalarFunctionSet GetKeysFunction();
 	static ScalarFunctionSet GetTypeFunction();
 	static ScalarFunctionSet GetValidFunction();
+	static ScalarFunctionSet GetValueFunction();
 	static ScalarFunctionSet GetSerializeSqlFunction();
 	static ScalarFunctionSet GetDeserializeSqlFunction();
 	static ScalarFunctionSet GetSerializePlanFunction();
 
+	static ScalarFunctionSet GetPrettyPrintFunction();
+
 	static PragmaFunctionSet GetExecuteJsonSerializedSqlPragmaFunction();
 
 	template <class FUNCTION_INFO>

package/src/duckdb/extension/json/include/json_scan.hpp

@@ -124,12 +124,15 @@ public:
 	idx_t max_depth = NumericLimits<idx_t>::Maximum();
 	//! We divide the number of appearances of each JSON field by the auto-detection sample size
 	//! If the average over the fields of an object is less than this threshold,
-	//! we default to the JSON type for this object rather than the shredded type
+	//! we default to the MAP type with value type of merged field types
 	double field_appearance_threshold = 0.1;
 	//! The maximum number of files we sample to sample sample_size rows
 	idx_t maximum_sample_files = 32;
 	//! Whether we auto-detect and convert JSON strings to integers
 	bool convert_strings_to_integers = false;
+	//! If a struct contains more fields than this threshold with at least 80% similar types,
+	//! we infer it as MAP type
+	idx_t map_inference_threshold = 25;
 
 	//! All column names (in order)
 	vector<string> names;
@@ -237,7 +240,8 @@ private:
 
 	void SkipOverArrayStart();
 
-	void ReadAndAutoDetect(JSONScanGlobalState &gstate, AllocatedData &buffer, optional_idx &buffer_index);
+	void ReadAndAutoDetect(JSONScanGlobalState &gstate, AllocatedData &buffer, optional_idx &buffer_index,
+	                       bool &file_done);
 	bool ReconstructFirstObject(JSONScanGlobalState &gstate);
 	void ParseNextChunk(JSONScanGlobalState &gstate);
 

package/src/duckdb/extension/json/include/json_structure.hpp

@@ -19,7 +19,8 @@ struct StrpTimeFormat;
 struct JSONStructureNode {
 public:
 	JSONStructureNode();
-	JSONStructureNode(yyjson_val *key_p, yyjson_val *val_p, const bool ignore_errors);
+	JSONStructureNode(const char *key_ptr, const size_t key_len);
+	JSONStructureNode(yyjson_val *key_p, yyjson_val *val_p, bool ignore_errors);
 
 	//! Disable copy constructors
 	JSONStructureNode(const JSONStructureNode &other) = delete;
@@ -31,7 +32,7 @@ public:
 	JSONStructureDescription &GetOrCreateDescription(LogicalTypeId type);
 
 	bool ContainsVarchar() const;
-	void InitializeCandidateTypes(const idx_t max_depth, const bool convert_strings_to_integers, idx_t depth = 0);
+	void InitializeCandidateTypes(idx_t max_depth, bool convert_strings_to_integers, idx_t depth = 0);
 	void RefineCandidateTypes(yyjson_val *vals[], idx_t val_count, Vector &string_vector, ArenaAllocator &allocator,
 	                          DateFormatMap &date_format_map);
 
@@ -43,14 +44,15 @@ private:
 	void RefineCandidateTypesString(yyjson_val *vals[], idx_t val_count, Vector &string_vector,
 	                                DateFormatMap &date_format_map);
 	void EliminateCandidateTypes(idx_t vec_count, Vector &string_vector, DateFormatMap &date_format_map);
-	bool EliminateCandidateFormats(idx_t vec_count, Vector &string_vector, Vector &result_vector,
+	bool EliminateCandidateFormats(idx_t vec_count, Vector &string_vector, const Vector &result_vector,
 	                               vector<StrpTimeFormat> &formats);
 
 public:
-	duckdb::unique_ptr<string> key;
+	unique_ptr<string> key;
 	bool initialized = false;
 	vector<JSONStructureDescription> descriptions;
 	idx_t count;
+	idx_t null_count;
 };
 
 struct JSONStructureDescription {
@@ -64,7 +66,8 @@ public:
 	JSONStructureDescription &operator=(JSONStructureDescription &&) noexcept;
 
 	JSONStructureNode &GetOrCreateChild();
-	JSONStructureNode &GetOrCreateChild(yyjson_val *key, yyjson_val *val, const bool ignore_errors);
+	JSONStructureNode &GetOrCreateChild(const char *key_ptr, size_t key_size);
+	JSONStructureNode &GetOrCreateChild(yyjson_val *key, yyjson_val *val, bool ignore_errors);
 
 public:
 	//! Type of this description
@@ -80,10 +83,10 @@ public:
 
 struct JSONStructure {
 public:
-	static void ExtractStructure(yyjson_val *val, JSONStructureNode &node, const bool ignore_errors);
-	static LogicalType StructureToType(ClientContext &context, const JSONStructureNode &node, const idx_t max_depth,
-	                                   const double field_appearance_threshold, idx_t depth = 0,
-	                                   idx_t sample_count = DConstants::INVALID_INDEX);
+	static void ExtractStructure(yyjson_val *val, JSONStructureNode &node, bool ignore_errors);
+	static LogicalType StructureToType(ClientContext &context, const JSONStructureNode &node, idx_t max_depth,
+	                                   double field_appearance_threshold, idx_t map_inference_threshold,
+	                                   idx_t depth = 0, const LogicalType &null_type = LogicalType::JSON());
 };
 
 } // namespace duckdb

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

@@ -35,15 +35,23 @@ string ThrowPathError(const char *ptr, const char *end, const bool binder) {
 struct JSONKeyReadResult {
 public:
 	static inline JSONKeyReadResult Empty() {
-		return {idx_t(0), string()};
+		return {idx_t(0), false, string()};
 	}
 
 	static inline JSONKeyReadResult WildCard() {
-		return {1, "*"};
+		return {1, false, "*"};
+	}
+
+	static inline JSONKeyReadResult RecWildCard() {
+		return {2, true, "*"};
+	}
+
+	static inline JSONKeyReadResult RecWildCardShortcut() {
+		return {1, true, "*"};
 	}
 
 	inline bool IsValid() {
-		return chars_read != 0;
+		return (chars_read != 0);
 	}
 
 	inline bool IsWildCard() {
@@ -52,13 +60,14 @@ public:
 
 public:
 	idx_t chars_read;
+	bool recursive;
 	string key;
 };
 
 static inline JSONKeyReadResult ReadString(const char *ptr, const char *const end, const bool escaped) {
 	const char *const before = ptr;
 	if (escaped) {
-		auto key = make_unsafe_uniq_array<char>(end - ptr);
+		auto key = make_unsafe_uniq_array_uninitialized<char>(end - ptr);
 		idx_t key_len = 0;
 
 		bool backslash = false;
@@ -82,7 +91,7 @@ static inline JSONKeyReadResult ReadString(const char *ptr, const char *const en
 		if (ptr == end || backslash) {
 			return JSONKeyReadResult::Empty();
 		} else {
-			return {idx_t(ptr - before), string(key.get(), key_len)};
+			return {idx_t(ptr - before), false, string(key.get(), key_len)};
 		}
 	} else {
 		while (ptr != end) {
@@ -91,7 +100,7 @@ static inline JSONKeyReadResult ReadString(const char *ptr, const char *const en
 			}
 			ptr++;
 		}
-		return {idx_t(ptr - before), string(before, ptr - before)};
+		return {idx_t(ptr - before), false, string(before, ptr - before)};
 	}
 }
 
@@ -125,8 +134,23 @@ static inline idx_t ReadInteger(const char *ptr, const char *const end, idx_t &i
 static inline JSONKeyReadResult ReadKey(const char *ptr, const char *const end) {
 	D_ASSERT(ptr != end);
 	if (*ptr == '*') { // Wildcard
+		if (*(ptr + 1) == '*') {
+			return JSONKeyReadResult::RecWildCard();
+		}
 		return JSONKeyReadResult::WildCard();
 	}
+	bool recursive = false;
+	if (*ptr == '.') {
+		char next = *(ptr + 1);
+		if (next == '*') {
+			return JSONKeyReadResult::RecWildCard();
+		}
+		if (next == '[') {
+			return JSONKeyReadResult::RecWildCardShortcut();
+		}
+		ptr++;
+		recursive = true;
+	}
 	bool escaped = false;
 	if (*ptr == '"') {
 		ptr++; // Skip past opening '"'
@@ -139,6 +163,10 @@ static inline JSONKeyReadResult ReadKey(const char *ptr, const char *const end)
 	if (escaped) {
 		result.chars_read += 2; // Account for surrounding quotes
 	}
+	if (recursive) {
+		result.chars_read += 1;
+		result.recursive = true;
+	}
 	return result;
 }
 
@@ -197,7 +225,7 @@ JSONPathType JSONCommon::ValidatePath(const char *ptr, const idx_t &len, const b
 			auto key = ReadKey(ptr, end);
 			if (!key.IsValid()) {
 				ThrowPathError(ptr, end, binder);
-			} else if (key.IsWildCard()) {
+			} else if (key.IsWildCard() || key.recursive) {
 				path_type = JSONPathType::WILDCARD;
 			}
 			ptr += key.chars_read;
@@ -272,12 +300,39 @@ void GetWildcardPathInternal(yyjson_val *val, const char *ptr, const char *const
 		D_ASSERT(ptr != end);
 		switch (c) {
 		case '.': { // Object field
-			if (!unsafe_yyjson_is_obj(val)) {
-				return;
-			}
 			auto key_result = ReadKey(ptr, end);
 			D_ASSERT(key_result.IsValid());
+			if (key_result.recursive) {
+				if (key_result.IsWildCard()) {
+					ptr += key_result.chars_read;
+				}
+				vector<yyjson_val *> rec_vals;
+				rec_vals.emplace_back(val);
+				for (idx_t i = 0; i < rec_vals.size(); i++) {
+					yyjson_val *rec_val = rec_vals[i];
+					if (yyjson_is_arr(rec_val)) {
+						size_t idx, max;
+						yyjson_val *element;
+						yyjson_arr_foreach(rec_val, idx, max, element) {
+							rec_vals.emplace_back(element);
+						}
+					} else if (yyjson_is_obj(rec_val)) {
+						size_t idx, max;
+						yyjson_val *key, *element;
+						yyjson_obj_foreach(rec_val, idx, max, key, element) {
+							rec_vals.emplace_back(element);
+						}
+					}
+					if (i > 0 || ptr != end) {
+						GetWildcardPathInternal(rec_val, ptr, end, vals);
+					}
+				}
+				return;
+			}
 			ptr += key_result.chars_read;
+			if (!unsafe_yyjson_is_obj(val)) {
+				return;
+			}
 			if (key_result.IsWildCard()) { // Wildcard
 				size_t idx, max;
 				yyjson_val *key, *obj_val;
@@ -325,6 +380,7 @@ void GetWildcardPathInternal(yyjson_val *val, const char *ptr, const char *const
 	if (val != nullptr) {
 		vals.emplace_back(val);
 	}
+	return;
 }
 
 void JSONCommon::GetWildcardPath(yyjson_val *val, const char *ptr, const idx_t &len, vector<yyjson_val *> &vals) {

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

@@ -17,11 +17,19 @@
 namespace duckdb {
 
 static DefaultMacro json_macros[] = {
-    {DEFAULT_SCHEMA, "json_group_array", {"x", nullptr}, "to_json(list(x))"},
-    {DEFAULT_SCHEMA, "json_group_object", {"name", "value", nullptr}, "to_json(map(list(name), list(value)))"},
-    {DEFAULT_SCHEMA, "json_group_structure", {"x", nullptr}, "json_structure(json_group_array(x))->'0'"},
-    {DEFAULT_SCHEMA, "json", {"x", nullptr}, "json_extract(x, '$')"},
-    {nullptr, nullptr, {nullptr}, nullptr}};
+    {DEFAULT_SCHEMA, "json_group_array", {"x", nullptr}, {{nullptr, nullptr}}, "to_json(list(x))"},
+    {DEFAULT_SCHEMA,
+     "json_group_object",
+     {"name", "value", nullptr},
+     {{nullptr, nullptr}},
+     "to_json(map(list(name), list(value)))"},
+    {DEFAULT_SCHEMA,
+     "json_group_structure",
+     {"x", nullptr},
+     {{nullptr, nullptr}},
+     "json_structure(json_group_array(x))->'0'"},
+    {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;

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

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-static inline uint64_t GetArrayLength(yyjson_val *val, yyjson_alc *alc, Vector &result) {
+static inline uint64_t GetArrayLength(yyjson_val *val, yyjson_alc *, Vector &, ValidityMask &, idx_t) {
 	return yyjson_arr_size(val);
 }
 

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

@@ -223,6 +223,12 @@ struct CreateJSONValue<uhugeint_t, string_t> {
 	}
 };
 
+template <class T>
+inline yyjson_mut_val *CreateJSONValueFromJSON(yyjson_mut_doc *doc, const T &value) {
+	return nullptr; // This function should only be called with string_t as template
+}
+
+template <>
 inline yyjson_mut_val *CreateJSONValueFromJSON(yyjson_mut_doc *doc, const string_t &value) {
 	auto value_doc = JSONCommon::ReadDocument(value, JSONCommon::READ_FLAG, &doc->alc);
 	auto result = yyjson_val_mut_copy(doc, value_doc->root);
@@ -273,7 +279,7 @@ static void TemplatedCreateValues(yyjson_mut_doc *doc, yyjson_mut_val *vals[], V
 		if (!value_data.validity.RowIsValid(val_idx)) {
 			vals[i] = yyjson_mut_null(doc);
 		} else if (type_is_json) {
-			vals[i] = CreateJSONValueFromJSON(doc, (string_t &)values[val_idx]);
+			vals[i] = CreateJSONValueFromJSON(doc, values[val_idx]);
 		} else {
 			vals[i] = CreateJSONValue<INPUT_TYPE, TARGET_TYPE>::Operation(doc, values[val_idx]);
 		}
@@ -544,6 +550,7 @@ static void CreateValues(const StructNames &names, yyjson_mut_doc *doc, yyjson_m
 	case LogicalTypeId::TIMESTAMP_NS:
 	case LogicalTypeId::TIMESTAMP_MS:
 	case LogicalTypeId::TIMESTAMP_SEC:
+	case LogicalTypeId::VARINT:
 	case LogicalTypeId::UUID: {
 		Vector string_vector(LogicalTypeId::VARCHAR, count);
 		VectorOperations::DefaultCast(value_v, string_vector, count);
@@ -556,7 +563,17 @@ static void CreateValues(const StructNames &names, yyjson_mut_doc *doc, yyjson_m
 		TemplatedCreateValues<double, double>(doc, vals, double_vector, count);
 		break;
 	}
-	default:
+	case LogicalTypeId::INVALID:
+	case LogicalTypeId::UNKNOWN:
+	case LogicalTypeId::ANY:
+	case LogicalTypeId::USER:
+	case LogicalTypeId::CHAR:
+	case LogicalTypeId::STRING_LITERAL:
+	case LogicalTypeId::INTEGER_LITERAL:
+	case LogicalTypeId::POINTER:
+	case LogicalTypeId::VALIDITY:
+	case LogicalTypeId::TABLE:
+	case LogicalTypeId::LAMBDA:
 		throw InternalException("Unsupported type arrived at JSON create function");
 	}
 }
@@ -647,7 +664,7 @@ static void ToJSONFunctionInternal(const StructNames &names, Vector &input, cons
 		}
 	}
 
-	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR || count == 1) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	}
 }
@@ -749,7 +766,7 @@ void JSONFunctions::RegisterJSONCreateCastFunctions(CastFunctionSet &casts) {
 			source_type = LogicalType::UNION({{"any", LogicalType::ANY}});
 			break;
 		case LogicalTypeId::ARRAY:
-			source_type = LogicalType::ARRAY(LogicalType::ANY);
+			source_type = LogicalType::ARRAY(LogicalType::ANY, optional_idx());
 			break;
 		case LogicalTypeId::VARCHAR:
 			// We skip this one here as it's handled in json_functions.cpp

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

@@ -0,0 +1,32 @@
+#include "json_executors.hpp"
+
+namespace duckdb {
+
+static inline bool JSONExists(yyjson_val *val, yyjson_alc *, Vector &, ValidityMask &, idx_t) {
+	return val;
+}
+
+static void BinaryExistsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	JSONExecutors::BinaryExecute<bool, false>(args, state, result, JSONExists);
+}
+
+static void ManyExistsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	JSONExecutors::ExecuteMany<bool, false>(args, state, result, JSONExists);
+}
+
+static void GetExistsFunctionsInternal(ScalarFunctionSet &set, const LogicalType &input_type) {
+	set.AddFunction(ScalarFunction({input_type, LogicalType::VARCHAR}, LogicalType::BOOLEAN, BinaryExistsFunction,
+	                               JSONReadFunctionData::Bind, nullptr, nullptr, JSONFunctionLocalState::Init));
+	set.AddFunction(ScalarFunction({input_type, LogicalType::LIST(LogicalType::VARCHAR)},
+	                               LogicalType::LIST(LogicalType::BOOLEAN), ManyExistsFunction,
+	                               JSONReadManyFunctionData::Bind, nullptr, nullptr, JSONFunctionLocalState::Init));
+}
+
+ScalarFunctionSet JSONFunctions::GetExistsFunction() {
+	ScalarFunctionSet set("json_exists");
+	GetExistsFunctionsInternal(set, LogicalType::VARCHAR);
+	GetExistsFunctionsInternal(set, LogicalType::JSON());
+	return set;
+}
+
+} // namespace duckdb

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

@@ -2,11 +2,11 @@
 
 namespace duckdb {
 
-static inline string_t ExtractFromVal(yyjson_val *val, yyjson_alc *alc, Vector &) {
+static inline string_t ExtractFromVal(yyjson_val *val, yyjson_alc *alc, Vector &, ValidityMask &, idx_t) {
 	return JSONCommon::WriteVal<yyjson_val>(val, alc);
 }
 
-static inline string_t ExtractStringFromVal(yyjson_val *val, yyjson_alc *alc, Vector &) {
+static inline string_t ExtractStringFromVal(yyjson_val *val, yyjson_alc *alc, Vector &, ValidityMask &, idx_t) {
 	return yyjson_is_str(val) ? string_t(unsafe_yyjson_get_str(val), unsafe_yyjson_get_len(val))
 	                          : JSONCommon::WriteVal<yyjson_val>(val, alc);
 }