duckdb 0.8.2-dev150.0 → 0.8.2-dev1549.0

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

@@ -2,6 +2,8 @@
 
 namespace duckdb {
 
+using JSONPathType = JSONCommon::JSONPathType;
+
 string JSONCommon::ValToString(yyjson_val *val, idx_t max_len) {
 	JSONAllocator json_allocator(Allocator::DefaultAllocator());
 	idx_t len;
@@ -18,61 +20,291 @@ void JSONCommon::ThrowValFormatError(string error_string, yyjson_val *val) {
 	throw InvalidInputException(error_string);
 }
 
-string ThrowPathError(const char *ptr, const char *end) {
+string ThrowPathError(const char *ptr, const char *end, const bool binder) {
 	ptr--;
-	throw InvalidInputException("JSON path error near '%s'", string(ptr, end - ptr));
+	auto msg = StringUtil::Format("JSON path error near '%s'", string(ptr, end - ptr));
+	if (binder) {
+		throw BinderException(msg);
+	} else {
+		throw InvalidInputException(msg);
+	}
+}
+
+static inline idx_t ReadString(const char *ptr, const char *const end, const bool escaped) {
+	const char *const before = ptr;
+	if (escaped) {
+		while (ptr != end) {
+			if (*ptr == '"') {
+				break;
+			}
+			ptr++;
+		}
+		return ptr == end ? 0 : ptr - before;
+	} else {
+		while (ptr != end) {
+			if (*ptr == '.' || *ptr == '[') {
+				break;
+			}
+			ptr++;
+		}
+		return ptr - before;
+	}
+}
+
+static inline idx_t ReadInteger(const char *ptr, const char *const end, idx_t &idx) {
+	static constexpr auto IDX_T_SAFE_DIG = 19;
+	static constexpr auto IDX_T_MAX = ((idx_t)(~(idx_t)0));
+
+	const char *const before = ptr;
+	idx = 0;
+	for (idx_t i = 0; i < IDX_T_SAFE_DIG; i++) {
+		if (ptr == end) {
+			// No closing ']'
+			return 0;
+		}
+		if (*ptr == ']') {
+			break;
+		}
+		uint8_t add = (uint8_t)(*ptr - '0');
+		if (add <= 9) {
+			idx = add + idx * 10;
+		} else {
+			// Not a digit
+			return 0;
+		}
+		ptr++;
+	}
+	// Invalid if overflow
+	return idx >= (idx_t)IDX_T_MAX ? 0 : ptr - before;
+}
+
+static inline bool ReadKey(const char *&ptr, const char *const end, const char *&key_ptr, idx_t &key_len) {
+	D_ASSERT(ptr != end);
+	if (*ptr == '*') { // Wildcard
+		ptr++;
+		key_len = DConstants::INVALID_INDEX;
+		return true;
+	}
+	bool escaped = false;
+	if (*ptr == '"') {
+		ptr++; // Skip past opening '"'
+		escaped = true;
+	}
+	key_ptr = ptr;
+	key_len = ReadString(ptr, end, escaped);
+	if (key_len == 0) {
+		return false;
+	}
+	ptr += key_len;
+	if (escaped) {
+		ptr++; // Skip past closing '"'
+	}
+	return true;
 }
 
-void JSONCommon::ValidatePathDollar(const char *ptr, const idx_t &len) {
+static inline bool ReadArrayIndex(const char *&ptr, const char *const end, idx_t &array_index, bool &from_back) {
+	D_ASSERT(ptr != end);
+	from_back = false;
+	if (*ptr == '*') { // Wildcard
+		ptr++;
+		if (ptr == end || *ptr != ']') {
+			return false;
+		}
+		array_index = DConstants::INVALID_INDEX;
+	} else {
+		if (*ptr == '#') { // SQLite syntax to index from back of array
+			ptr++;         // Skip over '#'
+			if (ptr == end) {
+				return false;
+			}
+			if (*ptr == ']') {
+				// [#] always returns NULL in SQLite, so we return an array index that will do the same
+				array_index = NumericLimits<uint32_t>::Maximum();
+				ptr++;
+				return true;
+			}
+			if (*ptr != '-') {
+				return false;
+			}
+			from_back = true;
+		}
+		if (*ptr == '-') {
+			ptr++; // Skip over '-'
+			from_back = true;
+		}
+		auto idx_len = ReadInteger(ptr, end, array_index);
+		if (idx_len == 0) {
+			return false;
+		}
+		ptr += idx_len;
+	}
+	ptr++; // Skip past closing ']'
+	return true;
+}
+
+JSONPathType JSONCommon::ValidatePath(const char *ptr, const idx_t &len, const bool binder) {
+	D_ASSERT(len >= 1 && *ptr == '$');
+	JSONPathType path_type = JSONPathType::REGULAR;
 	const char *const end = ptr + len;
-	// Skip past '$'
-	ptr++;
+	ptr++; // Skip past '$'
 	while (ptr != end) {
 		const auto &c = *ptr++;
-		if (c == '.') {
-			// Object
-			bool escaped = false;
-			if (*ptr == '"') {
-				// Skip past opening '"'
-				ptr++;
-				escaped = true;
+		if (ptr == end) {
+			ThrowPathError(ptr, end, binder);
+		}
+		switch (c) {
+		case '.': { // Object field
+			const char *key_ptr;
+			idx_t key_len;
+			if (!ReadKey(ptr, end, key_ptr, key_len)) {
+				ThrowPathError(ptr, end, binder);
 			}
-			auto key_len = ReadString(ptr, end, escaped);
-			if (key_len == 0) {
-				ThrowPathError(ptr, end);
+			if (key_len == DConstants::INVALID_INDEX) {
+				path_type = JSONPathType::WILDCARD;
 			}
-			ptr += key_len;
-			if (escaped) {
-				// Skip past closing '"'
-				ptr++;
+			break;
+		}
+		case '[': { // Array index
+			idx_t array_index;
+			bool from_back;
+			if (!ReadArrayIndex(ptr, end, array_index, from_back)) {
+				ThrowPathError(ptr, end, binder);
 			}
-		} else if (c == '[') {
-			// Array
-			if (*ptr == '#') {
-				// Index from back of array
-				ptr++;
-				if (*ptr == ']') {
-					ptr++;
-					continue;
+			if (array_index == DConstants::INVALID_INDEX) {
+				path_type = JSONPathType::WILDCARD;
+			}
+			break;
+		}
+		default:
+			ThrowPathError(ptr, end, binder);
+		}
+	}
+	return path_type;
+}
+
+yyjson_val *JSONCommon::GetPath(yyjson_val *val, const char *ptr, const idx_t &len) {
+	// Path has been validated at this point
+	const char *const end = ptr + len;
+	ptr++; // Skip past '$'
+	while (val != nullptr && ptr != end) {
+		const auto &c = *ptr++;
+		D_ASSERT(ptr != end);
+		switch (c) {
+		case '.': { // Object field
+			if (!unsafe_yyjson_is_obj(val)) {
+				return nullptr;
+			}
+			const char *key_ptr;
+			idx_t key_len;
+#ifdef DEBUG
+			bool success =
+#endif
+			    ReadKey(ptr, end, key_ptr, key_len);
+#ifdef DEBUG
+			D_ASSERT(success);
+#endif
+			val = yyjson_obj_getn(val, key_ptr, key_len);
+			break;
+		}
+		case '[': { // Array index
+			if (!unsafe_yyjson_is_arr(val)) {
+				return nullptr;
+			}
+			idx_t array_index;
+			bool from_back;
+#ifdef DEBUG
+			bool success =
+#endif
+			    ReadArrayIndex(ptr, end, array_index, from_back);
+#ifdef DEBUG
+			D_ASSERT(success);
+#endif
+			if (from_back && array_index != 0) {
+				array_index = unsafe_yyjson_get_len(val) - array_index;
+			}
+			val = yyjson_arr_get(val, array_index);
+			break;
+		}
+		default: // LCOV_EXCL_START
+			throw InternalException(
+			    "Invalid JSON Path encountered in JSONCommon::GetPath, call JSONCommon::ValidatePath first!");
+		} // LCOV_EXCL_STOP
+	}
+	return val;
+}
+
+void GetWildcardPathInternal(yyjson_val *val, const char *ptr, const char *const end, vector<yyjson_val *> &vals) {
+	while (val != nullptr && ptr != end) {
+		const auto &c = *ptr++;
+		D_ASSERT(ptr != end);
+		switch (c) {
+		case '.': { // Object field
+			if (!unsafe_yyjson_is_obj(val)) {
+				return;
+			}
+			const char *key_ptr;
+			idx_t key_len;
+#ifdef DEBUG
+			bool success =
+#endif
+			    ReadKey(ptr, end, key_ptr, key_len);
+#ifdef DEBUG
+			D_ASSERT(success);
+#endif
+			if (key_len == DConstants::INVALID_INDEX) { // Wildcard
+				size_t idx, max;
+				yyjson_val *key, *obj_val;
+				yyjson_obj_foreach(val, idx, max, key, obj_val) {
+					GetWildcardPathInternal(obj_val, ptr, end, vals);
 				}
-				if (*ptr != '-') {
-					ThrowPathError(ptr, end);
+				return;
+			}
+			val = yyjson_obj_getn(val, key_ptr, key_len);
+			break;
+		}
+		case '[': { // Array index
+			if (!unsafe_yyjson_is_arr(val)) {
+				return;
+			}
+			idx_t array_index;
+			bool from_back;
+#ifdef DEBUG
+			bool success =
+#endif
+			    ReadArrayIndex(ptr, end, array_index, from_back);
+#ifdef DEBUG
+			D_ASSERT(success);
+#endif
+
+			if (array_index == DConstants::INVALID_INDEX) { // Wildcard
+				size_t idx, max;
+				yyjson_val *arr_val;
+				yyjson_arr_foreach(val, idx, max, arr_val) {
+					GetWildcardPathInternal(arr_val, ptr, end, vals);
 				}
-				// Skip past '-'
-				ptr++;
+				return;
 			}
-			idx_t idx;
-			auto idx_len = ReadIndex(ptr, end, idx);
-			if (idx_len == 0) {
-				ThrowPathError(ptr, end);
+			if (from_back && array_index != 0) {
+				array_index = unsafe_yyjson_get_len(val) - array_index;
 			}
-			ptr += idx_len;
-			// Skip past closing ']'
-			ptr++;
-		} else {
-			ThrowPathError(ptr, end);
+			val = yyjson_arr_get(val, array_index);
+			break;
 		}
+		default: // LCOV_EXCL_START
+			throw InternalException(
+			    "Invalid JSON Path encountered in GetWildcardPathInternal, call JSONCommon::ValidatePath first!");
+		} // LCOV_EXCL_STOP
 	}
+	if (val != nullptr) {
+		vals.emplace_back(val);
+	}
+}
+
+void JSONCommon::GetWildcardPath(yyjson_val *val, const char *ptr, const idx_t &len, vector<yyjson_val *> &vals) {
+	// Path has been validated at this point
+	const char *const end = ptr + len;
+	ptr++; // Skip past '$'
+	GetWildcardPathInternal(val, ptr, end, vals);
 }
 
 } // namespace duckdb

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

@@ -395,7 +395,7 @@ static inline void ExtractStructureObject(yyjson_val *obj, JSONStructureNode &no
 
 static inline void ExtractStructureVal(yyjson_val *val, JSONStructureNode &node) {
 	D_ASSERT(!yyjson_is_arr(val) && !yyjson_is_obj(val));
-	node.GetOrCreateDescription(JSONCommon::ValTypeToLogicalTypeId<yyjson_val>(val));
+	node.GetOrCreateDescription(JSONCommon::ValTypeToLogicalTypeId(val));
 }
 
 void JSONStructure::ExtractStructure(yyjson_val *val, JSONStructureNode &node) {

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

@@ -41,7 +41,7 @@ static LogicalType StructureStringToType(yyjson_val *val, ClientContext &context
 
 static LogicalType StructureStringToTypeArray(yyjson_val *arr, ClientContext &context) {
 	if (yyjson_arr_size(arr) != 1) {
-		throw InvalidInputException("Too many values in array of JSON structure");
+		throw BinderException("Too many values in array of JSON structure");
 	}
 	return LogicalType::LIST(StructureStringToType(yyjson_arr_get_first(arr), context));
 }
@@ -62,7 +62,7 @@ static LogicalType StructureToTypeObject(yyjson_val *obj, ClientContext &context
 	}
 	D_ASSERT(yyjson_obj_size(obj) == names.size());
 	if (child_types.empty()) {
-		throw InvalidInputException("Empty object in JSON structure");
+		throw BinderException("Empty object in JSON structure");
 	}
 	return LogicalType::STRUCT(child_types);
 }
@@ -76,7 +76,7 @@ static LogicalType StructureStringToType(yyjson_val *val, ClientContext &context
 	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE:
 		return TransformStringToLogicalType(unsafe_yyjson_get_str(val), context);
 	default:
-		throw InvalidInputException("invalid JSON structure");
+		throw BinderException("invalid JSON structure");
 	}
 }
 
@@ -89,20 +89,15 @@ static unique_ptr<FunctionData> JSONTransformBind(ClientContext &context, Scalar
 	if (arguments[1]->return_type == LogicalTypeId::SQLNULL) {
 		bound_function.return_type = LogicalTypeId::SQLNULL;
 	} else if (!arguments[1]->IsFoldable()) {
-		throw InvalidInputException("JSON structure must be a constant!");
+		throw BinderException("JSON structure must be a constant!");
 	} else {
 		auto structure_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
 		if (!structure_val.DefaultTryCastAs(JSONCommon::JSONType())) {
-			throw InvalidInputException("Cannot cast JSON structure to string");
+			throw BinderException("Cannot cast JSON structure to string");
 		}
 		auto structure_string = structure_val.GetValueUnsafe<string_t>();
 		JSONAllocator json_allocator(Allocator::DefaultAllocator());
-		yyjson_read_err err;
-		auto doc =
-		    JSONCommon::ReadDocumentUnsafe(structure_string, JSONCommon::READ_FLAG, json_allocator.GetYYAlc(), &err);
-		if (err.code != YYJSON_READ_SUCCESS) {
-			JSONCommon::ThrowParseError(structure_string.GetData(), structure_string.GetSize(), err);
-		}
+		auto doc = JSONCommon::ReadDocument(structure_string, JSONCommon::READ_FLAG, json_allocator.GetYYAlc());
 		bound_function.return_type = StructureStringToType(doc->root, context);
 	}
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
@@ -114,10 +109,9 @@ static inline string_t GetString(yyjson_val *val) {
 
 template <class T, class OP = TryCast>
 static inline bool GetValueNumerical(yyjson_val *val, T &result, JSONTransformOptions &options) {
+	D_ASSERT(unsafe_yyjson_get_tag(val) != (YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE));
 	bool success;
 	switch (unsafe_yyjson_get_tag(val)) {
-	case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:
-		return false;
 	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE:
 		success = OP::template Operation<string_t, T>(GetString(val), result, options.strict_cast);
 		break;
@@ -150,10 +144,9 @@ static inline bool GetValueNumerical(yyjson_val *val, T &result, JSONTransformOp
 
 template <class T, class OP = TryCastToDecimal>
 static inline bool GetValueDecimal(yyjson_val *val, T &result, uint8_t w, uint8_t s, JSONTransformOptions &options) {
+	D_ASSERT(unsafe_yyjson_get_tag(val) != (YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE));
 	bool success;
 	switch (unsafe_yyjson_get_tag(val)) {
-	case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:
-		return false;
 	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE:
 		success = OP::template Operation<string_t, T>(GetString(val), result, &options.error_message, w, s);
 		break;
@@ -186,9 +179,8 @@ static inline bool GetValueDecimal(yyjson_val *val, T &result, uint8_t w, uint8_
 }
 
 static inline bool GetValueString(yyjson_val *val, yyjson_alc *alc, string_t &result, Vector &vector) {
+	D_ASSERT(unsafe_yyjson_get_tag(val) != (YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE));
 	switch (unsafe_yyjson_get_tag(val)) {
-	case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:
-		return true;
 	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE:
 		result = string_t(unsafe_yyjson_get_str(val), unsafe_yyjson_get_len(val));
 		return true;
@@ -318,26 +310,14 @@ static bool TransformStringWithFormat(Vector &string_vector, StrpTimeFormat &for
 	auto &target_validity = FlatVector::Validity(result);
 
 	bool success = true;
-	if (source_validity.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			if (!OP::template Operation<T>(format, source_strings[i], target_vals[i], options.error_message)) {
-				target_validity.SetInvalid(i);
-				if (success && options.strict_cast) {
-					options.object_index = i;
-					success = false;
-				}
-			}
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			if (!source_validity.RowIsValid(i)) {
-				target_validity.SetInvalid(i);
-			} else if (!OP::template Operation<T>(format, source_strings[i], target_vals[i], options.error_message)) {
-				target_validity.SetInvalid(i);
-				if (success && options.strict_cast) {
-					options.object_index = i;
-					success = false;
-				}
+	for (idx_t i = 0; i < count; i++) {
+		if (!source_validity.RowIsValid(i)) {
+			target_validity.SetInvalid(i);
+		} else if (!OP::template Operation<T>(format, source_strings[i], target_vals[i], options.error_message)) {
+			target_validity.SetInvalid(i);
+			if (success && options.strict_cast) {
+				options.object_index = i;
+				success = false;
 			}
 		}
 	}

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

@@ -3,7 +3,7 @@
 namespace duckdb {
 
 static inline string_t GetType(yyjson_val *val, yyjson_alc *alc, Vector &result) {
-	return JSONCommon::ValTypeToStringT<yyjson_val>(val);
+	return JSONCommon::ValTypeToStringT(val);
 }
 
 static void UnaryTypeFunction(DataChunk &args, ExpressionState &state, Vector &result) {

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

@@ -12,24 +12,23 @@
 
 namespace duckdb {
 
-static void CheckPath(const Value &path_val, string &path, size_t &len) {
-	string error;
-	Value path_str_val;
+using JSONPathType = JSONCommon::JSONPathType;
+
+static JSONPathType CheckPath(const Value &path_val, string &path, size_t &len) {
 	if (path_val.IsNull()) {
 		throw InvalidInputException("JSON path cannot be NULL");
 	}
-	if (!path_val.DefaultTryCastAs(LogicalType::VARCHAR, path_str_val, &error)) {
-		throw InvalidInputException(error);
-	}
+	const auto path_str_val = path_val.DefaultCastAs(LogicalType::VARCHAR);
 	auto path_str = path_str_val.GetValueUnsafe<string_t>();
 	len = path_str.GetSize();
 	auto ptr = path_str.GetData();
 	// Empty strings and invalid $ paths yield an error
 	if (len == 0) {
-		throw InvalidInputException("Empty JSON path");
+		throw BinderException("Empty JSON path");
 	}
+	JSONPathType path_type = JSONPathType::REGULAR;
 	if (*ptr == '$') {
-		JSONCommon::ValidatePathDollar(ptr, len);
+		path_type = JSONCommon::ValidatePath(ptr, len, true);
 	}
 	// Copy over string to the bind data
 	if (*ptr == '/' || *ptr == '$') {
@@ -38,19 +37,20 @@ static void CheckPath(const Value &path_val, string &path, size_t &len) {
 		path = "/" + string(ptr, len);
 		len++;
 	}
+	return path_type;
 }
 
-JSONReadFunctionData::JSONReadFunctionData(bool constant, string path_p, idx_t len)
-    : constant(constant), path(std::move(path_p)), ptr(path.c_str()), len(len) {
+JSONReadFunctionData::JSONReadFunctionData(bool constant, string path_p, idx_t len, JSONPathType path_type_p)
+    : constant(constant), path(std::move(path_p)), path_type(path_type_p), ptr(path.c_str()), len(len) {
 }
 
 unique_ptr<FunctionData> JSONReadFunctionData::Copy() const {
-	return make_uniq<JSONReadFunctionData>(constant, path, len);
+	return make_uniq<JSONReadFunctionData>(constant, path, len, path_type);
 }
 
 bool JSONReadFunctionData::Equals(const FunctionData &other_p) const {
 	auto &other = (const JSONReadFunctionData &)other_p;
-	return constant == other.constant && path == other.path && len == other.len;
+	return constant == other.constant && path == other.path && len == other.len && path_type == other.path_type;
 }
 
 unique_ptr<FunctionData> JSONReadFunctionData::Bind(ClientContext &context, ScalarFunction &bound_function,
@@ -59,12 +59,16 @@ unique_ptr<FunctionData> JSONReadFunctionData::Bind(ClientContext &context, Scal
 	bool constant = false;
 	string path = "";
 	size_t len = 0;
+	JSONPathType path_type = JSONPathType::REGULAR;
 	if (arguments[1]->return_type.id() != LogicalTypeId::SQLNULL && arguments[1]->IsFoldable()) {
 		constant = true;
 		const auto path_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-		CheckPath(path_val, path, len);
+		path_type = CheckPath(path_val, path, len);
+	}
+	if (path_type == JSONCommon::JSONPathType::WILDCARD) {
+		bound_function.return_type = LogicalType::LIST(bound_function.return_type);
 	}
-	return make_uniq<JSONReadFunctionData>(constant, std::move(path), len);
+	return make_uniq<JSONReadFunctionData>(constant, std::move(path), len, path_type);
 }
 
 JSONReadManyFunctionData::JSONReadManyFunctionData(vector<string> paths_p, vector<size_t> lens_p)
@@ -90,10 +94,7 @@ unique_ptr<FunctionData> JSONReadManyFunctionData::Bind(ClientContext &context,
 		throw ParameterNotResolvedException();
 	}
 	if (!arguments[1]->IsFoldable()) {
-		throw InvalidInputException("List of paths must be constant");
-	}
-	if (arguments[1]->return_type.id() == LogicalTypeId::SQLNULL) {
-		return make_uniq<JSONReadManyFunctionData>(vector<string>(), vector<size_t>());
+		throw BinderException("List of paths must be constant");
 	}
 
 	vector<string> paths;
@@ -102,7 +103,9 @@ unique_ptr<FunctionData> JSONReadManyFunctionData::Bind(ClientContext &context,
 	for (auto &path_val : ListValue::GetChildren(paths_val)) {
 		paths.emplace_back("");
 		lens.push_back(0);
-		CheckPath(path_val, paths.back(), lens.back());
+		if (CheckPath(path_val, paths.back(), lens.back()) == JSONPathType::WILDCARD) {
+			throw BinderException("Cannot have wildcards in JSON path when supplying multiple paths");
+		}
 	}
 
 	return make_uniq<JSONReadManyFunctionData>(std::move(paths), std::move(lens));
@@ -120,11 +123,8 @@ unique_ptr<FunctionLocalState> JSONFunctionLocalState::Init(ExpressionState &sta
 }
 
 unique_ptr<FunctionLocalState> JSONFunctionLocalState::InitCastLocalState(CastLocalStateParameters &parameters) {
-	if (parameters.context) {
-		return make_uniq<JSONFunctionLocalState>(*parameters.context);
-	} else {
-		return make_uniq<JSONFunctionLocalState>(Allocator::DefaultAllocator());
-	}
+	return parameters.context ? make_uniq<JSONFunctionLocalState>(*parameters.context)
+	                          : make_uniq<JSONFunctionLocalState>(Allocator::DefaultAllocator());
 }
 
 JSONFunctionLocalState &JSONFunctionLocalState::ResetAndGet(ExpressionState &state) {

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

@@ -19,7 +19,7 @@ void JSONScanData::Bind(ClientContext &context, TableFunctionBindInput &input) {
 	auto_detect = info.auto_detect;
 
 	for (auto &kv : input.named_parameters) {
-		if (MultiFileReader::ParseOption(kv.first, kv.second, options.file_options)) {
+		if (MultiFileReader::ParseOption(kv.first, kv.second, options.file_options, context)) {
 			continue;
 		}
 		auto loption = StringUtil::Lower(kv.first);
@@ -51,10 +51,7 @@ void JSONScanData::Bind(ClientContext &context, TableFunctionBindInput &input) {
 	}
 
 	files = MultiFileReader::GetFileList(context, input.inputs[0], "JSON");
-
-	if (options.file_options.auto_detect_hive_partitioning) {
-		options.file_options.hive_partitioning = MultiFileReaderOptions::AutoDetectHivePartitioning(files);
-	}
+	options.file_options.AutoDetectHivePartitioning(files, context);
 
 	InitializeReaders(context);
 }
@@ -236,7 +233,7 @@ unique_ptr<GlobalTableFunctionState> JSONGlobalTableFunctionState::Init(ClientCo
 	for (auto &reader : gstate.json_readers) {
 		MultiFileReader::FinalizeBind(reader->GetOptions().file_options, gstate.bind_data.reader_bind,
 		                              reader->GetFileName(), gstate.names, dummy_types, bind_data.names,
-		                              input.column_ids, reader->reader_data);
+		                              input.column_ids, reader->reader_data, context);
 	}
 
 	return std::move(result);