duckdb 0.6.2-dev1376.0 → 0.6.2-dev1568.0

package/binding.gyp

@@ -235,8 +235,11 @@
                 "src/duckdb/ub_extension_icu_third_party_icu_common.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp", 
                 "src/duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp", 
+                "src/duckdb/extension/json/buffered_json_reader.cpp", 
                 "src/duckdb/extension/json/json-extension.cpp", 
                 "src/duckdb/extension/json/json_common.cpp", 
+                "src/duckdb/extension/json/json_functions.cpp", 
+                "src/duckdb/extension/json/json_scan.cpp", 
                 "src/duckdb/ub_extension_json_json_functions.cpp", 
                 "src/duckdb/extension/json/yyjson/yyjson.cpp"
             ], 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.6.2-dev1376.0",
+  "version": "0.6.2-dev1568.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

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

@@ -0,0 +1,127 @@
+#include "buffered_json_reader.hpp"
+
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/file_opener.hpp"
+#include "duckdb/common/file_system.hpp"
+#include "duckdb/common/printer.hpp"
+
+namespace duckdb {
+
+void BufferedJSONReaderOptions::Serialize(FieldWriter &writer) {
+	writer.WriteString(file_path);
+	writer.WriteField<JSONFormat>(format);
+	writer.WriteField<FileCompressionType>(compression);
+}
+
+void BufferedJSONReaderOptions::Deserialize(FieldReader &reader) {
+	file_path = reader.ReadRequired<string>();
+	format = reader.ReadRequired<JSONFormat>();
+	compression = reader.ReadRequired<FileCompressionType>();
+}
+
+JSONBufferHandle::JSONBufferHandle(idx_t buffer_index_p, idx_t readers_p, AllocatedData &&buffer_p, idx_t buffer_size_p)
+    : buffer_index(buffer_index_p), readers(readers_p), buffer(move(buffer_p)), buffer_size(buffer_size_p) {
+}
+
+JSONFileHandle::JSONFileHandle(unique_ptr<FileHandle> file_handle_p)
+    : file_handle(move(file_handle_p)), can_seek(file_handle->CanSeek()),
+      plain_file_source(file_handle->OnDiskFile() && can_seek), file_size(file_handle->GetFileSize()),
+      read_position(0) {
+}
+
+idx_t JSONFileHandle::FileSize() const {
+	return file_size;
+}
+
+idx_t JSONFileHandle::Remaining() const {
+	return file_size - read_position;
+}
+
+bool JSONFileHandle::CanSeek() const {
+	return can_seek;
+}
+
+bool JSONFileHandle::PlainFileSource() const {
+	return plain_file_source;
+}
+
+idx_t JSONFileHandle::GetPositionAndSize(idx_t &position, idx_t requested_size) {
+	D_ASSERT(requested_size != 0);
+	position = read_position;
+	auto actual_size = MinValue<idx_t>(requested_size, Remaining());
+	read_position += actual_size;
+	return actual_size;
+}
+
+void JSONFileHandle::ReadAtPosition(const char *pointer, idx_t size, idx_t position) {
+	D_ASSERT(size != 0);
+	file_handle->Read((void *)pointer, size, position);
+}
+
+idx_t JSONFileHandle::Read(const char *pointer, idx_t requested_size) {
+	D_ASSERT(requested_size != 0);
+	auto actual_size = file_handle->Read((void *)pointer, requested_size);
+	read_position += actual_size;
+	return actual_size;
+}
+
+BufferedJSONReader::BufferedJSONReader(ClientContext &context, BufferedJSONReaderOptions options_p, idx_t file_index_p,
+                                       string file_path_p)
+    : file_index(file_index_p), file_path(std::move(file_path_p)), context(context), options(std::move(options_p)),
+      buffer_index(0) {
+}
+
+void BufferedJSONReader::OpenJSONFile() {
+	lock_guard<mutex> guard(lock);
+	auto &file_system = FileSystem::GetFileSystem(context);
+	auto file_opener = FileOpener::Get(context);
+	auto regular_file_handle = file_system.OpenFile(file_path.c_str(), FileFlags::FILE_FLAGS_READ,
+	                                                FileLockType::NO_LOCK, options.compression, file_opener);
+	file_handle = make_unique<JSONFileHandle>(std::move(regular_file_handle));
+}
+
+bool BufferedJSONReader::IsOpen() {
+	return file_handle != nullptr;
+}
+
+BufferedJSONReaderOptions &BufferedJSONReader::GetOptions() {
+	return options;
+}
+
+JSONFileHandle &BufferedJSONReader::GetFileHandle() const {
+	return *file_handle;
+}
+
+void BufferedJSONReader::InsertBuffer(idx_t buffer_idx, unique_ptr<JSONBufferHandle> &&buffer) {
+	lock_guard<mutex> guard(lock);
+	buffer_map.insert(make_pair(buffer_idx, std::move(buffer)));
+}
+
+JSONBufferHandle *BufferedJSONReader::GetBuffer(idx_t buffer_idx) {
+	lock_guard<mutex> guard(lock);
+	auto it = buffer_map.find(buffer_idx);
+	return it == buffer_map.end() ? nullptr : it->second.get();
+}
+
+AllocatedData BufferedJSONReader::RemoveBuffer(idx_t buffer_idx) {
+	lock_guard<mutex> guard(lock);
+	auto it = buffer_map.find(buffer_idx);
+	D_ASSERT(it != buffer_map.end());
+	auto result = std::move(it->second->buffer);
+	buffer_map.erase(it);
+	return result;
+}
+
+idx_t BufferedJSONReader::GetBufferIndex() {
+	return buffer_index++;
+}
+
+double BufferedJSONReader::GetProgress() const {
+	if (file_handle) {
+		return 100.0 * double(file_handle->Remaining()) / double(file_handle->FileSize());
+	} else {
+		return 0;
+	}
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,123 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// buffered_json_reader.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/atomic.hpp"
+#include "duckdb/common/enums/file_compression_type.hpp"
+#include "duckdb/common/mutex.hpp"
+#include "json_common.hpp"
+
+namespace duckdb {
+
+struct FileHandle;
+
+enum class JSONFormat : uint8_t {
+	//! Auto-detect format (UNSTRUCTURED / NEWLINE_DELIMITED)
+	AUTO_DETECT = 0,
+	//! One object after another, newlines can be anywhere
+	UNSTRUCTURED = 1,
+	//! Objects are separated by newlines, newlines do not occur within objects (NDJSON)
+	NEWLINE_DELIMITED = 2,
+};
+
+struct BufferedJSONReaderOptions {
+public:
+	//! The file path of the JSON file to read
+	string file_path;
+	//! The format of the JSON
+	JSONFormat format = JSONFormat::AUTO_DETECT;
+	//! Whether file is compressed or not, and if so which compression type
+	FileCompressionType compression = FileCompressionType::AUTO_DETECT;
+
+public:
+	void Serialize(FieldWriter &writer);
+	void Deserialize(FieldReader &reader);
+};
+
+struct JSONBufferHandle {
+public:
+	JSONBufferHandle(idx_t buffer_index, idx_t readers, AllocatedData &&buffer, idx_t buffer_size);
+
+public:
+	//! Buffer index (within same file)
+	const idx_t buffer_index;
+
+	//! Number of readers for this buffer
+	atomic<idx_t> readers;
+	//! The buffer
+	AllocatedData buffer;
+	//! The size of the data in the buffer (can be less than buffer.GetSize())
+	const idx_t buffer_size;
+};
+
+struct JSONFileHandle {
+public:
+	explicit JSONFileHandle(unique_ptr<FileHandle> file_handle);
+
+	idx_t FileSize() const;
+	idx_t Remaining() const;
+
+	bool CanSeek() const;
+	bool PlainFileSource() const;
+
+	idx_t GetPositionAndSize(idx_t &position, idx_t requested_size);
+	void ReadAtPosition(const char *pointer, idx_t size, idx_t position);
+	idx_t Read(const char *pointer, idx_t requested_size);
+
+private:
+	//! The JSON file handle
+	unique_ptr<FileHandle> file_handle;
+
+	//! File properties
+	const bool can_seek;
+	const bool plain_file_source;
+	const idx_t file_size;
+
+	//! Read properties
+	idx_t read_position;
+};
+
+class BufferedJSONReader {
+public:
+	BufferedJSONReader(ClientContext &context, BufferedJSONReaderOptions options, idx_t file_index, string file_path);
+
+	void OpenJSONFile();
+	bool IsOpen();
+
+	BufferedJSONReaderOptions &GetOptions();
+	JSONFileHandle &GetFileHandle() const;
+
+	void InsertBuffer(idx_t buffer_idx, unique_ptr<JSONBufferHandle> &&buffer);
+	JSONBufferHandle *GetBuffer(idx_t buffer_idx);
+	AllocatedData RemoveBuffer(idx_t buffer_idx);
+	idx_t GetBufferIndex();
+
+	double GetProgress() const;
+
+public:
+	mutex lock;
+
+	//! File index / path
+	const idx_t file_index;
+	const string file_path;
+
+private:
+	ClientContext &context;
+	BufferedJSONReaderOptions options;
+
+	//! File handle
+	unique_ptr<JSONFileHandle> file_handle;
+
+	//! Next buffer index within the file
+	idx_t buffer_index;
+	//! Mapping from batch index to currently held buffers
+	unordered_map<idx_t, unique_ptr<JSONBufferHandle>> buffer_map;
+};
+
+} // namespace duckdb

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

@@ -11,112 +11,75 @@
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/operator/decimal_cast_operators.hpp"
 #include "duckdb/common/operator/string_cast.hpp"
-#include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "yyjson.hpp"
 
 namespace duckdb {
 
-struct JSONReadFunctionData : public FunctionData {
+class JSONAllocator {
 public:
-	JSONReadFunctionData(bool constant, string path_p, idx_t len);
-	unique_ptr<FunctionData> Copy() const override;
-	bool Equals(const FunctionData &other_p) const override;
-	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
-	                                     vector<unique_ptr<Expression>> &arguments);
-
-public:
-	const bool constant;
-	const string path;
-	const char *ptr;
-	const size_t len;
-};
-
-struct JSONReadManyFunctionData : public FunctionData {
-public:
-	JSONReadManyFunctionData(vector<string> paths_p, vector<size_t> lens_p);
-	unique_ptr<FunctionData> Copy() const override;
-	bool Equals(const FunctionData &other_p) const override;
-	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
-	                                     vector<unique_ptr<Expression>> &arguments);
-
-public:
-	const vector<string> paths;
-	vector<const char *> ptrs;
-	const vector<size_t> lens;
-};
-
-template <class YYJSON_DOC_T>
-static inline void CleanupDoc(YYJSON_DOC_T *doc) {
-	throw InternalException("Unknown yyjson document type");
-}
+	explicit JSONAllocator(Allocator &allocator)
+	    : arena_allocator(allocator), yyjson_allocator({Allocate, Reallocate, Free, &arena_allocator}) {
+	}
 
-template <>
-inline void CleanupDoc(yyjson_doc *doc) {
-	yyjson_doc_free(doc);
-}
+	inline yyjson_alc *GetYYJSONAllocator() {
+		return &yyjson_allocator;
+	}
 
-template <>
-inline void CleanupDoc(yyjson_mut_doc *doc) {
-	yyjson_mut_doc_free(doc);
-}
+	void Reset() {
+		arena_allocator.Reset();
+	}
 
-template <class YYJSON_DOC_T>
-class DocPointer {
 private:
-	YYJSON_DOC_T *doc;
-
-public:
-	explicit DocPointer(YYJSON_DOC_T *doc) : doc(doc) {
+	static inline void *Allocate(void *ctx, size_t size) {
+		auto alloc = (ArenaAllocator *)ctx;
+		return alloc->AllocateAligned(size);
 	}
 
-	DocPointer(const DocPointer &obj) = delete;
-	DocPointer &operator=(const DocPointer &obj) = delete;
-
-	DocPointer(DocPointer &&other) noexcept {
-		this->doc = other.doc;
-		other.doc = nullptr;
+	static inline void *Reallocate(void *ctx, void *ptr, size_t old_size, size_t size) {
+		auto alloc = (ArenaAllocator *)ctx;
+		return alloc->ReallocateAligned((data_ptr_t)ptr, old_size, size);
 	}
 
-	void operator=(DocPointer &&other) noexcept {
-		CleanupDoc<YYJSON_DOC_T>(doc);
-		this->ptr = other.ptr;
-		other.ptr = nullptr;
+	static inline void Free(void *ctx, void *ptr) {
+		// NOP because ArenaAllocator can't free
 	}
 
-	inline YYJSON_DOC_T *operator*() const {
-		return doc;
-	}
+private:
+	ArenaAllocator arena_allocator;
+	yyjson_alc yyjson_allocator;
+};
 
-	inline YYJSON_DOC_T *operator->() const {
-		return doc;
-	}
+struct JSONCommon {
+public:
+	static constexpr auto JSON_TYPE_NAME = "JSON";
 
-	inline bool IsNull() const {
-		return doc == nullptr;
+	static const LogicalType JSONType() {
+		auto json_type = LogicalType(LogicalTypeId::VARCHAR);
+		json_type.SetAlias(JSON_TYPE_NAME);
+		return json_type;
 	}
 
-	~DocPointer() {
-		CleanupDoc<YYJSON_DOC_T>(doc);
+	static bool LogicalTypeIsJSON(const LogicalType &type) {
+		return type.id() == LogicalTypeId::VARCHAR && type.HasAlias() && type.GetAlias() == JSON_TYPE_NAME;
 	}
-};
 
-struct JSONCommon {
-private:
-	//! Read/Write flag that make sense for us
+public:
+	//! Read/Write flags
 	static constexpr auto READ_FLAG = YYJSON_READ_ALLOW_INF_AND_NAN | YYJSON_READ_ALLOW_TRAILING_COMMAS;
+	static constexpr auto STOP_READ_FLAG = READ_FLAG | YYJSON_READ_STOP_WHEN_DONE | YYJSON_READ_INSITU;
 	static constexpr auto WRITE_FLAG = YYJSON_WRITE_ALLOW_INF_AND_NAN;
 
 public:
 	//! Constant JSON type strings
-	static constexpr auto TYPE_STRING_NULL = "NULL";
-	static constexpr auto TYPE_STRING_BOOLEAN = "BOOLEAN";
-	static constexpr auto TYPE_STRING_BIGINT = "BIGINT";
-	static constexpr auto TYPE_STRING_UBIGINT = "UBIGINT";
-	static constexpr auto TYPE_STRING_DOUBLE = "DOUBLE";
-	static constexpr auto TYPE_STRING_VARCHAR = "VARCHAR";
-	static constexpr auto TYPE_STRING_ARRAY = "ARRAY";
-	static constexpr auto TYPE_STRING_OBJECT = "OBJECT";
+	static constexpr char const *TYPE_STRING_NULL = "NULL";
+	static constexpr char const *TYPE_STRING_BOOLEAN = "BOOLEAN";
+	static constexpr char const *TYPE_STRING_BIGINT = "BIGINT";
+	static constexpr char const *TYPE_STRING_UBIGINT = "UBIGINT";
+	static constexpr char const *TYPE_STRING_DOUBLE = "DOUBLE";
+	static constexpr char const *TYPE_STRING_VARCHAR = "VARCHAR";
+	static constexpr char const *TYPE_STRING_ARRAY = "ARRAY";
+	static constexpr char const *TYPE_STRING_OBJECT = "OBJECT";
 
 	template <class YYJSON_VAL_T>
 	static inline const char *const ValTypeToString(YYJSON_VAL_T *val) {
@@ -143,59 +106,62 @@ public:
 		}
 	}
 
-public:
-	static inline DocPointer<yyjson_mut_doc> CreateDocument() {
-		return DocPointer<yyjson_mut_doc>(yyjson_mut_doc_new(nullptr));
+	template <class YYJSON_VAL_T>
+	static inline constexpr string_t ValTypeToStringT(YYJSON_VAL_T *val) {
+		return string_t(ValTypeToString<YYJSON_VAL_T>(val));
 	}
 
-	//! Read JSON document (returns nullptr if invalid JSON)
-	static inline DocPointer<yyjson_doc> ReadDocumentUnsafe(const string_t &input) {
-		return DocPointer<yyjson_doc>(yyjson_read(input.GetDataUnsafe(), input.GetSize(), READ_FLAG));
-	}
-	//! Read JSON document (throws error if malformed JSON)
-	static inline DocPointer<yyjson_doc> ReadDocument(const string_t &input) {
-		auto result = ReadDocumentUnsafe(input);
-		if (result.IsNull()) {
-			throw InvalidInputException("malformed JSON");
+public:
+	static inline yyjson_mut_doc *CreateDocument(yyjson_alc *alc) {
+		D_ASSERT(alc);
+		return yyjson_mut_doc_new(alc);
+	}
+	static inline yyjson_doc *ReadDocumentUnsafe(char *data, idx_t size, const yyjson_read_flag flg, yyjson_alc *alc,
+	                                             yyjson_read_err *err = nullptr) {
+		D_ASSERT(alc);
+		return yyjson_read_opts(data, size, flg, alc, err);
+	}
+	static inline yyjson_doc *ReadDocumentUnsafe(const string_t &input, const yyjson_read_flag flg, yyjson_alc *alc,
+	                                             yyjson_read_err *err = nullptr) {
+		return ReadDocumentUnsafe(input.GetDataWriteable(), input.GetSize(), flg, alc, err);
+	}
+	static inline yyjson_doc *ReadDocument(char *data, idx_t size, const yyjson_read_flag flg, yyjson_alc *alc) {
+		yyjson_read_err error;
+		auto result = ReadDocumentUnsafe(data, size, flg, alc, &error);
+		if (error.code != YYJSON_READ_SUCCESS) {
+			ThrowParseError(data, size, error);
 		}
 		return result;
 	}
-	//! Some wrappers around writes so we don't have to free the malloc'ed char[]
-	static inline unique_ptr<char, void (*)(void *)> WriteVal(yyjson_val *val, idx_t &len) {
-		return unique_ptr<char, decltype(free) *>(
-		    reinterpret_cast<char *>(yyjson_val_write(val, WRITE_FLAG, (size_t *)&len)), free);
-	}
-	static inline unique_ptr<char, void (*)(void *)> WriteVal(yyjson_mut_val *val, idx_t &len) {
-		return unique_ptr<char, decltype(free) *>(
-		    reinterpret_cast<char *>(yyjson_mut_val_write(val, WRITE_FLAG, (size_t *)&len)), free);
+	static inline yyjson_doc *ReadDocument(const string_t &input, const yyjson_read_flag flg, yyjson_alc *alc) {
+		return ReadDocument(input.GetDataWriteable(), input.GetSize(), flg, alc);
 	}
-	static unique_ptr<char, void (*)(void *)> WriteMutDoc(yyjson_mut_doc *doc, idx_t &len) {
-		return unique_ptr<char, decltype(free) *>(
-		    reinterpret_cast<char *>(yyjson_mut_write(doc, WRITE_FLAG, (size_t *)&len)), free);
+	static string FormatParseError(const char *data, idx_t length, yyjson_read_err &error, const string &extra = "") {
+		D_ASSERT(error.code != YYJSON_READ_SUCCESS);
+		// Truncate, so we don't print megabytes worth of JSON
+		string input = length > 50 ? string(data, 47) + "..." : string(data, length);
+		// Have to replace \r, otherwise output is unreadable
+		input = StringUtil::Replace(input, "\r", "\\r");
+		return StringUtil::Format("Malformed JSON at byte %lld of input: %s. %s Input: %s", error.pos, error.msg, extra,
+		                          input);
 	}
-	//! Vector writes
-	static inline string_t WriteVal(yyjson_val *val, Vector &vector) {
-		idx_t len;
-		auto data = WriteVal(val, len);
-		return StringVector::AddString(vector, data.get(), len);
+	static void ThrowParseError(const char *data, idx_t length, yyjson_read_err &error, const string &extra = "") {
+		throw InvalidInputException(FormatParseError(data, length, error, extra));
 	}
-	static inline string_t WriteVal(yyjson_mut_val *val, Vector &vector) {
-		idx_t len;
-		auto data = WriteVal(val, len);
-		return StringVector::AddString(vector, data.get(), len);
+
+	template <class YYJSON_VAL_T>
+	static inline char *WriteVal(YYJSON_VAL_T *val, yyjson_alc *alc, idx_t &len) {
+		throw InternalException("Unknown yyjson val type");
 	}
-	static inline string_t WriteDoc(yyjson_mut_doc *doc, Vector &vector) {
+	template <class YYJSON_VAL_T>
+	static inline string_t WriteVal(YYJSON_VAL_T *val, yyjson_alc *alc) {
+		D_ASSERT(alc);
 		idx_t len;
-		auto data = WriteMutDoc(doc, len);
-		return StringVector::AddString(vector, data.get(), len);
+		auto data = WriteVal<YYJSON_VAL_T>(val, alc, len);
+		return string_t(data, len);
 	}
 	//! Throw an error with the printed yyjson_val
-	static void ThrowValFormatError(string error_string, yyjson_val *val) {
-		idx_t len;
-		auto data = WriteVal(val, len);
-		error_string = StringUtil::Format(error_string, string(data.get(), len));
-		throw InvalidInputException(error_string);
-	}
+	static void ThrowValFormatError(string error_string, yyjson_val *val);
 
 public:
 	//! Validate path with $ syntax
@@ -241,116 +207,6 @@ public:
 		}
 	}
 
-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 *, Vector &)> fun) {
-		auto &inputs = args.data[0];
-		UnaryExecutor::Execute<string_t, T>(inputs, result, args.size(), [&](string_t input) {
-			auto doc = JSONCommon::ReadDocument(input);
-			return fun(doc->root, result);
-		});
-	}
-
-	//! Two-argument JSON read function (with path query), i.e. json_type('[1, 2, 3]', '$[0]')
-	template <class T>
-	static void BinaryExecute(DataChunk &args, ExpressionState &state, Vector &result,
-	                          std::function<T(yyjson_val *, Vector &)> fun) {
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
-		const auto &info = (JSONReadFunctionData &)*func_expr.bind_info;
-
-		auto &inputs = args.data[0];
-		if (info.constant) {
-			// Constant path
-			const char *ptr = info.ptr;
-			const idx_t &len = info.len;
-			UnaryExecutor::ExecuteWithNulls<string_t, T>(
-			    inputs, result, args.size(), [&](string_t input, ValidityMask &mask, idx_t idx) {
-				    auto doc = ReadDocument(input);
-				    yyjson_val *val;
-				    if (!(val = GetPointerUnsafe<yyjson_val>(doc->root, ptr, len))) {
-					    mask.SetInvalid(idx);
-					    return T {};
-				    } else {
-					    return fun(val, result);
-				    }
-			    });
-		} else {
-			// Columnref path
-			auto &paths = args.data[1];
-			BinaryExecutor::ExecuteWithNulls<string_t, string_t, T>(
-			    inputs, paths, result, args.size(), [&](string_t input, string_t path, ValidityMask &mask, idx_t idx) {
-				    auto doc = ReadDocument(input);
-				    yyjson_val *val;
-				    if (!(val = GetPointer<yyjson_val>(doc->root, path))) {
-					    mask.SetInvalid(idx);
-					    return T {};
-				    } else {
-					    return fun(val, result);
-				    }
-			    });
-		}
-		if (args.AllConstant()) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		}
-	}
-
-	//! JSON read function with list of path queries, i.e. json_type('[1, 2, 3]', ['$[0]', '$[1]'])
-	template <class T>
-	static void ExecuteMany(DataChunk &args, ExpressionState &state, Vector &result,
-	                        std::function<T(yyjson_val *, Vector &)> fun) {
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
-		const auto &info = (JSONReadManyFunctionData &)*func_expr.bind_info;
-		D_ASSERT(info.ptrs.size() == info.lens.size());
-
-		const auto count = args.size();
-		const idx_t num_paths = info.ptrs.size();
-		const idx_t list_size = count * num_paths;
-
-		UnifiedVectorFormat input_data;
-		auto &input_vector = args.data[0];
-		input_vector.ToUnifiedFormat(count, input_data);
-		auto inputs = (string_t *)input_data.data;
-
-		ListVector::Reserve(result, list_size);
-		auto list_entries = FlatVector::GetData<list_entry_t>(result);
-		auto &list_validity = FlatVector::Validity(result);
-
-		auto &child = ListVector::GetEntry(result);
-		auto child_data = FlatVector::GetData<T>(child);
-		auto &child_validity = FlatVector::Validity(child);
-
-		idx_t offset = 0;
-		yyjson_val *val;
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = input_data.sel->get_index(i);
-			if (!input_data.validity.RowIsValid(idx)) {
-				list_validity.SetInvalid(i);
-				continue;
-			}
-
-			auto doc = ReadDocument(inputs[idx]);
-			for (idx_t path_i = 0; path_i < num_paths; path_i++) {
-				auto child_idx = offset + path_i;
-				if (!(val = GetPointerUnsafe<yyjson_val>(doc->root, info.ptrs[path_i], info.lens[path_i]))) {
-					child_validity.SetInvalid(child_idx);
-				} else {
-					child_data[child_idx] = fun(val, child);
-				}
-			}
-
-			list_entries[i].offset = offset;
-			list_entries[i].length = num_paths;
-			offset += num_paths;
-		}
-		ListVector::SetListSize(result, offset);
-
-		if (args.AllConstant()) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		}
-	}
-
 private:
 	//! Get JSON pointer using /field/index/... notation
 	template <class YYJSON_VAL_T>
@@ -502,6 +358,15 @@ private:
 	}
 };
 
+template <>
+inline char *JSONCommon::WriteVal(yyjson_val *val, yyjson_alc *alc, idx_t &len) {
+	return yyjson_val_write_opts(val, JSONCommon::WRITE_FLAG, alc, (size_t *)&len, nullptr);
+}
+template <>
+inline char *JSONCommon::WriteVal(yyjson_mut_val *val, yyjson_alc *alc, idx_t &len) {
+	return yyjson_mut_val_write_opts(val, JSONCommon::WRITE_FLAG, alc, (size_t *)&len, nullptr);
+}
+
 template <>
 inline yyjson_val *JSONCommon::TemplatedGetPointer(yyjson_val *root, const char *ptr, const idx_t &len) {
 	return len == 1 ? root : unsafe_yyjson_get_pointer(root, ptr, len);