duckdb 0.10.2 → 0.10.3-dev10.0

package/.github/workflows/NodeJS.yml

@@ -115,15 +115,77 @@ jobs:
         shell: bash
         run: ./scripts/node_build.sh ${{ matrix.node }}
 
-  osx-nodejs:
-    if: startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' || github.repository != 'duckdb/duckdb-node'
+  osx-nodejs-arm64:
     name: node.js OSX
-    runs-on: macos-latest
+    runs-on: macos-14
     needs: set-up-npm
     continue-on-error: ${{ matrix.node != '18' && matrix.node != '20' && matrix.node != '21' }}
     strategy:
       matrix:
-        target_arch: [ x64, arm64 ]
+        target_arch: [ arm64 ]
+        node: [ '16', '17', '18', '19', '20', '21', '22']
+        isRelease:
+          - ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' }}
+        exclude:
+          - isRelease: false
+            node: 12
+          - isRelease: false
+            node: 14
+          - isRelease: false
+            node: 16
+          - isRelease: false
+            node: 17
+          - isRelease: false
+            node: 19
+          - target_arch: arm64
+            node: 12
+          - target_arch: arm64
+            node: 14
+        # these older versions of NodeJS don't have M1 support
+
+    env:
+      TARGET_ARCH: ${{ matrix.target_arch }}
+      DUCKDB_NODE_BUILD_CACHE: 0
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      # Default Python (3.12) doesn't have support for distutils
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.11'
+
+      - name: Setup Ccache
+        uses: hendrikmuhs/ccache-action@main
+        with:
+          key: ${{ github.job }}-${{ matrix.target_arch }}
+          save: ${{ ( github.ref == 'refs/heads/main' || github.repository != 'duckdb/duckdb-node' ) && ( matrix.node == '19' ) }}
+
+      - name: Downgrade curl # fixes a bug with the brew curl that lead to failed downloads
+        shell: bash
+        run: |
+          brew uninstall --ignore-dependencies curl
+          which curl
+
+      - name: Setup
+        shell: bash
+        run: ./scripts/node_version.sh
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NODE_AUTH_TOKEN}}
+
+      - name: Node ${{ matrix.node }}
+        shell: bash
+        run: ./scripts/node_build.sh ${{ matrix.node }}
+
+  osx-nodejs-x64:
+    name: node.js OSX
+    runs-on: macos-13
+    needs: set-up-npm
+    continue-on-error: ${{ matrix.node != '18' && matrix.node != '20' && matrix.node != '21' }}
+    strategy:
+      matrix:
+        target_arch: [ x64 ]
         node: [ '16', '17', '18', '19', '20', '21', '22']
         isRelease:
           - ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' }}
@@ -251,3 +313,32 @@ jobs:
       - name: Node
         shell: bash
         run: ./scripts/node_build_win.sh
+
+  test_matrix:
+    needs:
+      - linux-nodejs
+      - osx-nodejs-arm64
+      - osx-nodejs-x64
+      - win-nodejs
+    strategy:
+      matrix:
+        os: [windows-latest, ubuntu-latest, ubuntu-22.04, ubuntu-20.04, windows-2019, macos-12, macos-13, macos-14]
+        version: [20]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.version }}
+
+      - uses: actions/checkout@v3
+        with:
+          sparse-checkout: examples
+
+      - name: Install duckdb
+        run: |
+          npm install duckdb@next
+
+      - name: Run minor test
+        shell: bash
+        run: |
+          node examples/example.js

package/binding.gyp

@@ -58,7 +58,6 @@
                 "src/duckdb/ub_src_core_functions_scalar_math.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_operators.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_random.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_secret.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_string.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_struct.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_union.cpp", 
@@ -232,6 +231,7 @@
                 "src/duckdb/third_party/mbedtls/library/sha256.cpp", 
                 "src/duckdb/third_party/mbedtls/library/sha512.cpp", 
                 "src/duckdb/third_party/mbedtls/mbedtls_wrapper.cpp", 
+                "src/duckdb/third_party/yyjson/yyjson.cpp", 
                 "src/duckdb/extension/parquet/column_reader.cpp", 
                 "src/duckdb/extension/parquet/column_writer.cpp", 
                 "src/duckdb/extension/parquet/parquet_crypto.cpp", 
@@ -296,8 +296,7 @@
                 "src/duckdb/extension/json/json_serializer.cpp", 
                 "src/duckdb/extension/json/json_deserializer.cpp", 
                 "src/duckdb/extension/json/serialize_json.cpp", 
-                "src/duckdb/ub_extension_json_json_functions.cpp", 
-                "src/duckdb/extension/json/yyjson/yyjson.cpp"
+                "src/duckdb/ub_extension_json_json_functions.cpp"
             ], 
             "include_dirs": [
                 "<!(node -p \"require('node-addon-api').include_dir\")", 
@@ -324,6 +323,7 @@
                 "src/duckdb/third_party/tdigest", 
                 "src/duckdb/third_party/utf8proc", 
                 "src/duckdb/third_party/utf8proc/include", 
+                "src/duckdb/third_party/yyjson/include", 
                 "src/duckdb/extension/parquet/include", 
                 "src/duckdb/third_party/parquet", 
                 "src/duckdb/third_party/thrift", 
@@ -335,8 +335,7 @@
                 "src/duckdb/extension/icu/include", 
                 "src/duckdb/extension/icu/third_party/icu/common", 
                 "src/duckdb/extension/icu/third_party/icu/i18n", 
-                "src/duckdb/extension/json/include", 
-                "src/duckdb/extension/json/yyjson/include"
+                "src/duckdb/extension/json/include"
             ], 
             "defines": [
                 "NAPI_VERSION=6", 

package/examples/example.js

@@ -0,0 +1,10 @@
+var duckdb = require('duckdb');
+
+var db = new duckdb.Database(':memory:'); // or a file name for a persistent DB
+
+db.all('SELECT 42 AS fortytwo', function(err, res) {
+  if (err) {
+    console.warn(err);
+  }
+  console.log(res[0].fortytwo)
+});

package/lib/duckdb.js

@@ -530,6 +530,17 @@ Database.prototype.each = function () {
     return this;
 }
 
+
+/**
+ * @arg sql
+ * @param {...*} params
+ * @yields row chunks
+ */
+Database.prototype.stream = function() {
+    return default_connection(this).stream.apply(this.default_connection, arguments);
+}
+
+
 /**
  * Convenience method for Connection#apply using a built-in default connection
  * @arg sql

package/package.json

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

package/src/database.cpp

@@ -309,10 +309,10 @@ void DuckDBNodeRSLauncher(Napi::Env env, Napi::Function jsrs, std::nullptr_t *,
 }
 
 static duckdb::unique_ptr<duckdb::TableRef>
-ScanReplacement(duckdb::ClientContext &context, const std::string &table_name, duckdb::ReplacementScanData *data) {
+ScanReplacement(duckdb::ClientContext &context, duckdb::ReplacementScanInput& info, duckdb::optional_ptr<duckdb::ReplacementScanData> data) {
 	JSRSArgs jsargs;
-	jsargs.table = table_name;
-	((NodeReplacementScanData *)data)->rs.BlockingCall(&jsargs);
+	jsargs.table = info.table_name;
+	((NodeReplacementScanData *)data.get())->rs.BlockingCall(&jsargs);
 	while (!jsargs.done) {
 		std::this_thread::yield();
 	}

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

@@ -62,8 +62,35 @@ struct IcuBindData : public FunctionData {
 		auto &other = other_p.Cast<IcuBindData>();
 		return language == other.language && country == other.country;
 	}
+
+	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                      const ScalarFunction &function) {
+		auto &bind_data = bind_data_p->Cast<IcuBindData>();
+		serializer.WriteProperty(100, "language", bind_data.language);
+		serializer.WriteProperty(101, "country", bind_data.country);
+	}
+
+	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, ScalarFunction &function) {
+		string language;
+		string country;
+		deserializer.ReadProperty(100, "language", language);
+		deserializer.ReadProperty(101, "country", country);
+
+		return make_uniq<IcuBindData>(language, country);
+	}
+
+	static const string FUNCTION_PREFIX;
+
+	static string EncodeFunctionName(const string &collation) {
+		return FUNCTION_PREFIX + collation;
+	}
+	static string DecodeFunctionName(const string &fname) {
+		return fname.substr(FUNCTION_PREFIX.size());
+	}
 };
 
+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 =
@@ -108,7 +135,9 @@ 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) {
-	auto splits = StringUtil::Split(bound_function.name, "_");
+
+	const auto collation = IcuBindData::DecodeFunctionName(bound_function.name);
+	auto splits = StringUtil::Split(collation, "_");
 	if (splits.size() == 1) {
 		return make_uniq<IcuBindData>(splits[0], "");
 	} else if (splits.size() == 2) {
@@ -137,19 +166,11 @@ static duckdb::unique_ptr<FunctionData> ICUSortKeyBind(ClientContext &context, S
 	}
 }
 
-static void ICUCollateSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-                                const ScalarFunction &function) {
-	throw NotImplementedException("FIXME: serialize icu-collate");
-}
-
-static duckdb::unique_ptr<FunctionData> ICUCollateDeserialize(Deserializer &deserializer, ScalarFunction &function) {
-	throw NotImplementedException("FIXME: serialize icu-collate");
-}
-
-static ScalarFunction GetICUFunction(const string &collation) {
-	ScalarFunction result(collation, {LogicalType::VARCHAR}, LogicalType::VARCHAR, ICUCollateFunction, ICUCollateBind);
-	result.serialize = ICUCollateSerialize;
-	result.deserialize = ICUCollateDeserialize;
+static ScalarFunction GetICUCollateFunction(const string &collation) {
+	string fname = IcuBindData::EncodeFunctionName(collation);
+	ScalarFunction result(fname, {LogicalType::VARCHAR}, LogicalType::VARCHAR, ICUCollateFunction, ICUCollateBind);
+	result.serialize = IcuBindData::Serialize;
+	result.deserialize = IcuBindData::Deserialize;
 	return result;
 }
 
@@ -238,7 +259,7 @@ static void LoadInternal(DuckDB &ddb) {
 		}
 		collation = StringUtil::Lower(collation);
 
-		CreateCollationInfo info(collation, GetICUFunction(collation), false, false);
+		CreateCollationInfo info(collation, GetICUCollateFunction(collation), false, false);
 		ExtensionUtil::RegisterCollation(db, info);
 	}
 	ScalarFunction sort_key("icu_sort_key", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
@@ -283,6 +304,14 @@ std::string IcuExtension::Name() {
 	return "icu";
 }
 
+std::string IcuExtension::Version() const {
+#ifdef EXT_VERSION_ICU
+	return EXT_VERSION_ICU;
+#else
+	return "";
+#endif
+}
+
 } // namespace duckdb
 
 extern "C" {

package/src/duckdb/extension/icu/include/icu_extension.hpp

@@ -16,6 +16,7 @@ class IcuExtension : public Extension {
 public:
 	void Load(DuckDB &db) override;
 	std::string Name() override;
+	std::string Version() const override;
 };
 
 } // namespace duckdb

package/src/duckdb/extension/icu/third_party/icu/i18n/basictz.cpp

@@ -63,7 +63,7 @@ BasicTimeZone::hasEquivalentTransitions(const BasicTimeZone& tz, UDate start, UD
     } else {
         if (raw1 != raw2 || dst1 != dst2) {
             return FALSE;
-        }            
+        }
     }
     // Check transitions in the range
     UDate time = start;
@@ -159,7 +159,7 @@ BasicTimeZone::getSimpleRulesNear(UDate date, InitialTimeZoneRule*& initial,
         if (((tr.getFrom()->getDSTSavings() == 0 && tr.getTo()->getDSTSavings() != 0)
               || (tr.getFrom()->getDSTSavings() != 0 && tr.getTo()->getDSTSavings() == 0))
             && (date + MILLIS_PER_YEAR > nextTransitionTime)) {
- 
+
             int32_t year, month, dom, dow, doy, mid;
             UDate d;
 
@@ -375,13 +375,13 @@ BasicTimeZone::getTimeZoneRulesAfter(UDate start, InitialTimeZoneRule*& initial,
         UDate updatedTime = tzt.getTime();
         if (updatedTime == time) {
             // Can get here if rules for start & end of daylight time have exactly
-            // the same time.  
+            // the same time.
             // TODO:  fix getNextTransition() to prevent it?
             status = U_INVALID_STATE_ERROR;
             goto error;
         }
         time = updatedTime;
- 
+
         const TimeZoneRule *toRule = tzt.getTo();
         for (i = 0; i < ruleCount; i++) {
             r = (TimeZoneRule*)orgRules->elementAt(i);
@@ -408,7 +408,7 @@ BasicTimeZone::getTimeZoneRulesAfter(UDate start, InitialTimeZoneRule*& initial,
                 if (!avail) {
                     break;
                 }
-                if (*(tzt0.getTo()) == *tar) {
+                if (*tar == *(tzt0.getTo())) {
                     break;
                 }
                 t = tzt0.getTime();

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

@@ -14,6 +14,8 @@
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "yyjson.hpp"
 
+using namespace duckdb_yyjson; // NOLINT
+
 namespace duckdb {
 
 //! JSON allocator is a custom allocator for yyjson that prevents many tiny allocations
@@ -108,6 +110,7 @@ public:
 		switch (yyjson_get_tag(val)) {
 		case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:
 			return JSONCommon::TYPE_STRING_NULL;
+		case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NOESC:
 		case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE:
 			return JSONCommon::TYPE_STRING_VARCHAR;
 		case YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE:
@@ -136,6 +139,7 @@ public:
 		switch (yyjson_get_tag(val)) {
 		case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:
 			return LogicalTypeId::SQLNULL;
+		case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NOESC:
 		case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE:
 			return LogicalTypeId::VARCHAR;
 		case YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE:
@@ -286,7 +290,8 @@ public:
 private:
 	//! Get JSON pointer (/field/index/... syntax)
 	static inline yyjson_val *GetPointer(yyjson_val *val, const char *ptr, const idx_t &len) {
-		return len == 1 ? val : unsafe_yyjson_get_pointer(val, ptr, len);
+		yyjson_ptr_err err;
+		return len == 1 ? val : unsafe_yyjson_ptr_getx(val, ptr, len, &err);
 	}
 	//! Get JSON path ($.field[index]... syntax)
 	static yyjson_val *GetPath(yyjson_val *val, const char *ptr, const idx_t &len);

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

@@ -30,7 +30,7 @@ public:
 	}
 
 	//! Two-argument JSON read function (with path query), i.e. json_type('[1, 2, 3]', '$[0]')
-	template <class T>
+	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) {
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
@@ -48,7 +48,7 @@ public:
 					    auto doc =
 					        JSONCommon::ReadDocument(input, JSONCommon::READ_FLAG, lstate.json_allocator.GetYYAlc());
 					    auto val = JSONCommon::GetUnsafe(doc->root, ptr, len);
-					    if (!val || unsafe_yyjson_is_null(val)) {
+					    if (!val || (NULL_IF_NULL && unsafe_yyjson_is_null(val))) {
 						    mask.SetInvalid(idx);
 						    return T {};
 					    } else {
@@ -76,7 +76,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 (unsafe_yyjson_is_null(val)) {
+						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);
@@ -109,7 +109,7 @@ public:
 	}
 
 	//! JSON read function with list of path queries, i.e. json_type('[1, 2, 3]', ['$[0]', '$[1]'])
-	template <class T>
+	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) {
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
@@ -148,7 +148,7 @@ 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 || unsafe_yyjson_is_null(val)) {
+				if (!val || (NULL_IF_NULL && unsafe_yyjson_is_null(val))) {
 					child_validity.SetInvalid(child_idx);
 				} else {
 					child_data[child_idx] = fun(val, alc, child);

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

@@ -16,6 +16,7 @@ class JsonExtension : public Extension {
 public:
 	void Load(DuckDB &db) override;
 	std::string Name() override;
+	std::string Version() const override;
 };
 
 } // namespace duckdb

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

@@ -70,8 +70,8 @@ public:
 	static vector<ScalarFunctionSet> GetScalarFunctions();
 	static vector<PragmaFunctionSet> GetPragmaFunctions();
 	static vector<TableFunctionSet> GetTableFunctions();
-	static unique_ptr<TableRef> ReadJSONReplacement(ClientContext &context, const string &table_name,
-	                                                ReplacementScanData *data);
+	static unique_ptr<TableRef> ReadJSONReplacement(ClientContext &context, ReplacementScanInput &input,
+	                                                optional_ptr<ReplacementScanData> data);
 	static TableFunction GetReadJSONTableFunction(shared_ptr<JSONScanInfo> function_info);
 	static CopyFunction GetJSONCopyFunction();
 	static void RegisterSimpleCastFunctions(CastFunctionSet &casts);

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

@@ -27,8 +27,8 @@ private:
 public:
 	explicit JsonSerializer(yyjson_mut_doc *doc, bool skip_if_null, bool skip_if_empty, bool skip_if_default)
 	    : doc(doc), stack({yyjson_mut_obj(doc)}), skip_if_null(skip_if_null), skip_if_empty(skip_if_empty) {
-		serialize_enum_as_string = true;
-		serialize_default_values = !skip_if_default;
+		options.serialize_enum_as_string = true;
+		options.serialize_default_values = !skip_if_default;
 	}
 
 	template <class T>

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

@@ -1,4 +1,5 @@
 #include "json_common.hpp"
+
 #include "duckdb/common/exception/binder_exception.hpp"
 
 namespace duckdb {
@@ -31,16 +32,58 @@ string ThrowPathError(const char *ptr, const char *end, const bool binder) {
 	}
 }
 
-static inline idx_t ReadString(const char *ptr, const char *const end, const bool escaped) {
+struct JSONKeyReadResult {
+public:
+	static inline JSONKeyReadResult Empty() {
+		return {idx_t(0), string()};
+	}
+
+	static inline JSONKeyReadResult WildCard() {
+		return {1, "*"};
+	}
+
+	inline bool IsValid() {
+		return chars_read != 0;
+	}
+
+	inline bool IsWildCard() {
+		return key == "*";
+	}
+
+public:
+	idx_t chars_read;
+	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);
+		idx_t key_len = 0;
+
+		bool backslash = false;
 		while (ptr != end) {
-			if (*ptr == '"') {
-				break;
+			if (backslash) {
+				if (*ptr != '"' && *ptr != '\\') {
+					key[key_len++] = '\\';
+				}
+				backslash = false;
+			} else {
+				if (*ptr == '"') {
+					break;
+				} else if (*ptr == '\\') {
+					backslash = true;
+					ptr++;
+					continue;
+				}
 			}
-			ptr++;
+			key[key_len++] = *ptr++;
+		}
+		if (ptr == end || backslash) {
+			return JSONKeyReadResult::Empty();
+		} else {
+			return {idx_t(ptr - before), string(key.get(), key_len)};
 		}
-		return ptr == end ? 0 : ptr - before;
 	} else {
 		while (ptr != end) {
 			if (*ptr == '.' || *ptr == '[') {
@@ -48,7 +91,7 @@ static inline idx_t ReadString(const char *ptr, const char *const end, const boo
 			}
 			ptr++;
 		}
-		return ptr - before;
+		return {idx_t(ptr - before), string(before, ptr - before)};
 	}
 }
 
@@ -79,28 +122,24 @@ static inline idx_t ReadInteger(const char *ptr, const char *const end, idx_t &i
 	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) {
+static inline JSONKeyReadResult ReadKey(const char *ptr, const char *const end) {
 	D_ASSERT(ptr != end);
 	if (*ptr == '*') { // Wildcard
-		ptr++;
-		key_len = DConstants::INVALID_INDEX;
-		return true;
+		return JSONKeyReadResult::WildCard();
 	}
 	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;
+	auto result = ReadString(ptr, end, escaped);
+	if (!result.IsValid()) {
+		return result;
 	}
-	ptr += key_len;
 	if (escaped) {
-		ptr++; // Skip past closing '"'
+		result.chars_read += 2; // Account for surrounding quotes
 	}
-	return true;
+	return result;
 }
 
 static inline bool ReadArrayIndex(const char *&ptr, const char *const end, idx_t &array_index, bool &from_back) {
@@ -155,14 +194,13 @@ JSONPathType JSONCommon::ValidatePath(const char *ptr, const idx_t &len, const b
 		}
 		switch (c) {
 		case '.': { // Object field
-			const char *key_ptr;
-			idx_t key_len;
-			if (!ReadKey(ptr, end, key_ptr, key_len)) {
+			auto key = ReadKey(ptr, end);
+			if (!key.IsValid()) {
 				ThrowPathError(ptr, end, binder);
-			}
-			if (key_len == DConstants::INVALID_INDEX) {
+			} else if (key.IsWildCard()) {
 				path_type = JSONPathType::WILDCARD;
 			}
+			ptr += key.chars_read;
 			break;
 		}
 		case '[': { // Array index
@@ -195,16 +233,10 @@ yyjson_val *JSONCommon::GetPath(yyjson_val *val, const char *ptr, const idx_t &l
 			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);
+			auto key_result = ReadKey(ptr, end);
+			D_ASSERT(key_result.IsValid());
+			ptr += key_result.chars_read;
+			val = yyjson_obj_getn(val, key_result.key.c_str(), key_result.key.size());
 			break;
 		}
 		case '[': { // Array index
@@ -243,16 +275,10 @@ void GetWildcardPathInternal(yyjson_val *val, const char *ptr, const char *const
 			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
+			auto key_result = ReadKey(ptr, end);
+			D_ASSERT(key_result.IsValid());
+			ptr += key_result.chars_read;
+			if (key_result.IsWildCard()) { // Wildcard
 				size_t idx, max;
 				yyjson_val *key, *obj_val;
 				yyjson_obj_foreach(val, idx, max, key, obj_val) {
@@ -260,7 +286,7 @@ void GetWildcardPathInternal(yyjson_val *val, const char *ptr, const char *const
 				}
 				return;
 			}
-			val = yyjson_obj_getn(val, key_ptr, key_len);
+			val = yyjson_obj_getn(val, key_result.key.c_str(), key_result.key.size());
 			break;
 		}
 		case '[': { // Array index

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

@@ -68,6 +68,14 @@ std::string JsonExtension::Name() {
 	return "json";
 }
 
+std::string JsonExtension::Version() const {
+#ifdef EXT_VERSION_JSON
+	return EXT_VERSION_JSON;
+#else
+	return "";
+#endif
+}
+
 } // namespace duckdb
 
 extern "C" {