duckdb 0.10.2-dev0.0 → 0.10.2-dev3.0

package/binding.gyp

@@ -166,9 +166,9 @@
                 "src/duckdb/src/verification/statement_verifier.cpp", 
                 "src/duckdb/src/verification/unoptimized_statement_verifier.cpp", 
                 "src/duckdb/third_party/fmt/format.cc", 
-                "src/duckdb/third_party/fsst/fsst_avx512.cpp", 
                 "src/duckdb/third_party/fsst/libfsst.cpp", 
                 "src/duckdb/third_party/miniz/miniz.cpp", 
+                "src/duckdb/third_party/re2/re2/bitmap256.cc", 
                 "src/duckdb/third_party/re2/re2/bitstate.cc", 
                 "src/duckdb/third_party/re2/re2/compile.cc", 
                 "src/duckdb/third_party/re2/re2/dfa.cc", 
@@ -271,6 +271,7 @@
                 "src/duckdb/third_party/zstd/compress/zstd_lazy.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
+                "src/duckdb/third_party/lz4/lz4.cpp", 
                 "src/duckdb/extension/icu/./icu-table-range.cpp", 
                 "src/duckdb/extension/icu/./icu-makedate.cpp", 
                 "src/duckdb/extension/icu/./icu-list-range.cpp", 
@@ -301,30 +302,32 @@
             "include_dirs": [
                 "<!(node -p \"require('node-addon-api').include_dir\")", 
                 "src/duckdb/src/include", 
+                "src/duckdb/third_party/concurrentqueue", 
+                "src/duckdb/third_party/fast_float", 
+                "src/duckdb/third_party/fastpforlib", 
                 "src/duckdb/third_party/fmt/include", 
                 "src/duckdb/third_party/fsst", 
-                "src/duckdb/third_party/re2", 
-                "src/duckdb/third_party/miniz", 
-                "src/duckdb/third_party/utf8proc/include", 
-                "src/duckdb/third_party/utf8proc", 
+                "src/duckdb/third_party/httplib", 
                 "src/duckdb/third_party/hyperloglog", 
-                "src/duckdb/third_party/skiplist", 
-                "src/duckdb/third_party/fastpforlib", 
-                "src/duckdb/third_party/tdigest", 
-                "src/duckdb/third_party/libpg_query/include", 
+                "src/duckdb/third_party/jaro_winkler", 
+                "src/duckdb/third_party/jaro_winkler/details", 
                 "src/duckdb/third_party/libpg_query", 
-                "src/duckdb/third_party/concurrentqueue", 
-                "src/duckdb/third_party/pcg", 
-                "src/duckdb/third_party/httplib", 
-                "src/duckdb/third_party/fast_float", 
+                "src/duckdb/third_party/libpg_query/include", 
+                "src/duckdb/third_party/lz4", 
                 "src/duckdb/third_party/mbedtls", 
                 "src/duckdb/third_party/mbedtls/include", 
                 "src/duckdb/third_party/mbedtls/library", 
-                "src/duckdb/third_party/jaro_winkler", 
-                "src/duckdb/third_party/jaro_winkler/details", 
+                "src/duckdb/third_party/miniz", 
+                "src/duckdb/third_party/pcg", 
+                "src/duckdb/third_party/re2", 
+                "src/duckdb/third_party/skiplist", 
+                "src/duckdb/third_party/tdigest", 
+                "src/duckdb/third_party/utf8proc", 
+                "src/duckdb/third_party/utf8proc/include", 
                 "src/duckdb/extension/parquet/include", 
                 "src/duckdb/third_party/parquet", 
                 "src/duckdb/third_party/thrift", 
+                "src/duckdb/third_party/lz4", 
                 "src/duckdb/third_party/snappy", 
                 "src/duckdb/third_party/zstd/include", 
                 "src/duckdb/third_party/mbedtls", 
@@ -389,9 +392,10 @@
                     {
                         "defines": [
                             "DUCKDB_BUILD_LIBRARY"
-                        ],
+                        ], 
                         "libraries": [
-                            "rstrtmgr.lib", "bcrypt.lib"
+                            "rstrtmgr.lib", 
+                            "bcrypt.lib"
                         ]
                     }
                 ]
@@ -414,4 +418,4 @@
             ]
         }
     ]
-}
+}

package/binding.gyp.in

@@ -62,6 +62,9 @@
                     {
                         "defines": [
                             "DUCKDB_BUILD_LIBRARY"
+                        ],
+                        "libraries": [
+                            "rstrtmgr.lib", "bcrypt.lib"
                         ]
                     }
                 ]

package/package.json

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

package/src/duckdb/extension/icu/icu-timezone.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/exception/conversion_exception.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/cast_rules.hpp"
 #include "duckdb/main/extension_util.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
@@ -183,7 +184,8 @@ struct ICUFromNaiveTimestamp : public ICUDateFunc {
 		auto &config = DBConfig::GetConfig(db);
 		auto &casts = config.GetCastFunctions();
 
-		casts.RegisterCastFunction(LogicalType::TIMESTAMP, LogicalType::TIMESTAMP_TZ, BindCastFromNaive);
+		const auto implicit_cost = CastRules::ImplicitCast(LogicalType::TIMESTAMP, LogicalType::TIMESTAMP_TZ);
+		casts.RegisterCastFunction(LogicalType::TIMESTAMP, LogicalType::TIMESTAMP_TZ, BindCastFromNaive, implicit_cost);
 		casts.RegisterCastFunction(LogicalType::TIMESTAMP_MS, LogicalType::TIMESTAMP_TZ, BindCastFromNaive);
 		casts.RegisterCastFunction(LogicalType::TIMESTAMP_NS, LogicalType::TIMESTAMP_TZ, BindCastFromNaive);
 		casts.RegisterCastFunction(LogicalType::TIMESTAMP_S, LogicalType::TIMESTAMP_TZ, BindCastFromNaive);

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

@@ -221,7 +221,7 @@ static void SetICUCalendar(ClientContext &context, SetScope scope, Value &parame
 	}
 }
 
-void IcuExtension::Load(DuckDB &ddb) {
+static void LoadInternal(DuckDB &ddb) {
 	auto &db = *ddb.instance;
 
 	// iterate over all the collations
@@ -275,6 +275,10 @@ void IcuExtension::Load(DuckDB &ddb) {
 	ExtensionUtil::RegisterFunction(db, cal_names);
 }
 
+void IcuExtension::Load(DuckDB &ddb) {
+	LoadInternal(ddb);
+}
+
 std::string IcuExtension::Name() {
 	return "icu";
 }
@@ -285,7 +289,7 @@ extern "C" {
 
 DUCKDB_EXTENSION_API void icu_init(duckdb::DatabaseInstance &db) { // NOLINT
 	duckdb::DuckDB db_wrapper(db);
-	db_wrapper.LoadExtension<duckdb::IcuExtension>();
+	duckdb::LoadInternal(db_wrapper);
 }
 
 DUCKDB_EXTENSION_API const char *icu_version() { // NOLINT

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

@@ -44,6 +44,10 @@ bool JSONFileHandle::RequestedReadsComplete() {
 	return requested_reads == actual_reads;
 }
 
+bool JSONFileHandle::LastReadRequested() const {
+	return last_read_requested;
+}
+
 idx_t JSONFileHandle::FileSize() const {
 	return file_size;
 }
@@ -56,6 +60,10 @@ bool JSONFileHandle::CanSeek() const {
 	return can_seek;
 }
 
+bool JSONFileHandle::IsPipe() const {
+	return file_handle->IsPipe();
+}
+
 FileHandle &JSONFileHandle::GetHandle() {
 	return *file_handle;
 }
@@ -193,9 +201,8 @@ BufferedJSONReader::BufferedJSONReader(ClientContext &context, BufferedJSONReade
 void BufferedJSONReader::OpenJSONFile() {
 	lock_guard<mutex> guard(lock);
 	if (!IsOpen()) {
-		auto &file_system = FileSystem::GetFileSystem(context);
-		auto regular_file_handle = file_system.OpenFile(file_name.c_str(), FileFlags::FILE_FLAGS_READ,
-		                                                FileLockType::NO_LOCK, options.compression);
+		auto &fs = FileSystem::GetFileSystem(context);
+		auto regular_file_handle = fs.OpenFile(file_name, FileFlags::FILE_FLAGS_READ | options.compression);
 		file_handle = make_uniq<JSONFileHandle>(std::move(regular_file_handle), BufferAllocator::Get(context));
 	}
 	Reset();

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

@@ -60,11 +60,13 @@ public:
 
 	void Reset();
 	bool RequestedReadsComplete();
+	bool LastReadRequested() const;
 
 	idx_t FileSize() const;
 	idx_t Remaining() const;
 
 	bool CanSeek() const;
+	bool IsPipe() const;
 
 	FileHandle &GetHandle();
 

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

@@ -9,13 +9,13 @@
 #pragma once
 
 #include "buffered_json_reader.hpp"
-#include "json_enums.hpp"
 #include "duckdb/common/multi_file_reader.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/types/type_map.hpp"
 #include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/function/table_function.hpp"
+#include "json_enums.hpp"
 #include "json_transform.hpp"
 
 namespace duckdb {
@@ -226,14 +226,20 @@ public:
 
 private:
 	bool ReadNextBuffer(JSONScanGlobalState &gstate);
-	bool ReadNextBufferInternal(JSONScanGlobalState &gstate, optional_idx &buffer_index, bool &file_done);
-	bool ReadNextBufferSeek(JSONScanGlobalState &gstate, optional_idx &buffer_index, bool &file_done);
-	bool ReadNextBufferNoSeek(JSONScanGlobalState &gstate, optional_idx &buffer_index, bool &file_done);
+	bool ReadNextBufferInternal(JSONScanGlobalState &gstate, AllocatedData &buffer, optional_idx &buffer_index,
+	                            bool &file_done);
+	bool ReadNextBufferSeek(JSONScanGlobalState &gstate, AllocatedData &buffer, optional_idx &buffer_index,
+	                        bool &file_done);
+	bool ReadNextBufferNoSeek(JSONScanGlobalState &gstate, AllocatedData &buffer, optional_idx &buffer_index,
+	                          bool &file_done);
+	AllocatedData AllocateBuffer(JSONScanGlobalState &gstate);
+	data_ptr_t GetReconstructBuffer(JSONScanGlobalState &gstate);
+
 	void SkipOverArrayStart();
 
-	void ReadAndAutoDetect(JSONScanGlobalState &gstate, optional_idx &buffer_index);
-	bool ReconstructFirstObject();
-	void ParseNextChunk();
+	void ReadAndAutoDetect(JSONScanGlobalState &gstate, AllocatedData &buffer, optional_idx &buffer_index);
+	bool ReconstructFirstObject(JSONScanGlobalState &gstate);
+	void ParseNextChunk(JSONScanGlobalState &gstate);
 
 	void ParseJSON(char *const json_start, const idx_t json_size, const idx_t remaining);
 	void ThrowObjectSizeError(const idx_t object_size);

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

@@ -25,15 +25,16 @@ private:
 	void PushValue(yyjson_mut_val *val);
 
 public:
-	explicit JsonSerializer(yyjson_mut_doc *doc, bool skip_if_null, bool skip_if_empty)
+	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 = true;
+		serialize_default_values = !skip_if_default;
 	}
 
 	template <class T>
-	static yyjson_mut_val *Serialize(T &value, yyjson_mut_doc *doc, bool skip_if_null, bool skip_if_empty) {
-		JsonSerializer serializer(doc, skip_if_null, skip_if_empty);
+	static yyjson_mut_val *Serialize(T &value, yyjson_mut_doc *doc, bool skip_if_null, bool skip_if_empty,
+	                                 bool skip_if_default) {
+		JsonSerializer serializer(doc, skip_if_null, skip_if_empty, skip_if_default);
 		value.Serialize(serializer);
 		return serializer.GetRootObject();
 	}

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

@@ -19,7 +19,7 @@ struct StrpTimeFormat;
 struct JSONStructureNode {
 public:
 	JSONStructureNode();
-	JSONStructureNode(yyjson_val *key_p, yyjson_val *val_p);
+	JSONStructureNode(yyjson_val *key_p, yyjson_val *val_p, const bool ignore_errors);
 
 	//! Disable copy constructors
 	JSONStructureNode(const JSONStructureNode &other) = delete;
@@ -64,7 +64,7 @@ public:
 	JSONStructureDescription &operator=(JSONStructureDescription &&) noexcept;
 
 	JSONStructureNode &GetOrCreateChild();
-	JSONStructureNode &GetOrCreateChild(yyjson_val *key, yyjson_val *val);
+	JSONStructureNode &GetOrCreateChild(yyjson_val *key, yyjson_val *val, const bool ignore_errors);
 
 public:
 	//! Type of this description
@@ -80,7 +80,7 @@ public:
 
 struct JSONStructure {
 public:
-	static void ExtractStructure(yyjson_val *val, JSONStructureNode &node);
+	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);

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

@@ -19,16 +19,19 @@ namespace duckdb {
 struct JsonSerializePlanBindData : public FunctionData {
 	bool skip_if_null = false;
 	bool skip_if_empty = false;
+	bool skip_if_default = false;
 	bool format = false;
 	bool optimize = false;
 
-	JsonSerializePlanBindData(bool skip_if_null_p, bool skip_if_empty_p, bool format_p, bool optimize_p)
-	    : skip_if_null(skip_if_null_p), skip_if_empty(skip_if_empty_p), format(format_p), optimize(optimize_p) {
+	JsonSerializePlanBindData(bool skip_if_null_p, bool skip_if_empty_p, bool skip_if_default_p, bool format_p,
+	                          bool optimize_p)
+	    : skip_if_null(skip_if_null_p), skip_if_empty(skip_if_empty_p), skip_if_default(skip_if_default_p),
+	      format(format_p), optimize(optimize_p) {
 	}
 
 public:
 	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<JsonSerializePlanBindData>(skip_if_null, skip_if_empty, format, optimize);
+		return make_uniq<JsonSerializePlanBindData>(skip_if_null, skip_if_empty, skip_if_default, format, optimize);
 	}
 	bool Equals(const FunctionData &other_p) const override {
 		return true;
@@ -48,6 +51,7 @@ static unique_ptr<FunctionData> JsonSerializePlanBind(ClientContext &context, Sc
 	// Optional arguments
 	bool skip_if_null = false;
 	bool skip_if_empty = false;
+	bool skip_if_default = false;
 	bool format = false;
 	bool optimize = false;
 
@@ -69,6 +73,11 @@ static unique_ptr<FunctionData> JsonSerializePlanBind(ClientContext &context, Sc
 				throw BinderException("json_serialize_plan: 'skip_empty' argument must be a boolean");
 			}
 			skip_if_empty = BooleanValue::Get(ExpressionExecutor::EvaluateScalar(context, *arg));
+		} else if (arg->alias == "skip_default") {
+			if (arg->return_type.id() != LogicalTypeId::BOOLEAN) {
+				throw BinderException("json_serialize_plan: 'skip_default' argument must be a boolean");
+			}
+			skip_if_default = BooleanValue::Get(ExpressionExecutor::EvaluateScalar(context, *arg));
 		} else if (arg->alias == "format") {
 			if (arg->return_type.id() != LogicalTypeId::BOOLEAN) {
 				throw BinderException("json_serialize_plan: 'format' argument must be a boolean");
@@ -83,7 +92,7 @@ static unique_ptr<FunctionData> JsonSerializePlanBind(ClientContext &context, Sc
 			throw BinderException(StringUtil::Format("json_serialize_plan: Unknown argument '%s'", arg->alias.c_str()));
 		}
 	}
-	return make_uniq<JsonSerializePlanBindData>(skip_if_null, skip_if_empty, format, optimize);
+	return make_uniq<JsonSerializePlanBindData>(skip_if_null, skip_if_empty, skip_if_default, format, optimize);
 }
 
 static bool OperatorSupportsSerialization(LogicalOperator &op, string &operator_name) {
@@ -144,7 +153,8 @@ static void JsonSerializePlanFunction(DataChunk &args, ExpressionState &state, V
 					throw InvalidInputException("Operator '%s' does not support serialization", operator_name);
 				}
 
-				auto plan_json = JsonSerializer::Serialize(*plan, doc, info.skip_if_null, info.skip_if_empty);
+				auto plan_json =
+				    JsonSerializer::Serialize(*plan, doc, info.skip_if_null, info.skip_if_empty, info.skip_if_default);
 				yyjson_mut_arr_append(plans_arr, plan_json);
 			}
 

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

@@ -12,15 +12,17 @@ namespace duckdb {
 struct JsonSerializeBindData : public FunctionData {
 	bool skip_if_null = false;
 	bool skip_if_empty = false;
+	bool skip_if_default = false;
 	bool format = false;
 
-	JsonSerializeBindData(bool skip_if_null_p, bool skip_if_empty_p, bool format_p)
-	    : skip_if_null(skip_if_null_p), skip_if_empty(skip_if_empty_p), format(format_p) {
+	JsonSerializeBindData(bool skip_if_null_p, bool skip_if_empty_p, bool skip_if_default_p, bool format_p)
+	    : skip_if_null(skip_if_null_p), skip_if_empty(skip_if_empty_p), skip_if_default(skip_if_default_p),
+	      format(format_p) {
 	}
 
 public:
 	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<JsonSerializeBindData>(skip_if_null, skip_if_empty, format);
+		return make_uniq<JsonSerializeBindData>(skip_if_null, skip_if_empty, skip_if_default, format);
 	}
 	bool Equals(const FunctionData &other_p) const override {
 		return true;
@@ -41,6 +43,7 @@ static unique_ptr<FunctionData> JsonSerializeBind(ClientContext &context, Scalar
 
 	bool skip_if_null = false;
 	bool skip_if_empty = false;
+	bool skip_if_default = false;
 	bool format = false;
 
 	for (idx_t i = 1; i < arguments.size(); i++) {
@@ -66,11 +69,16 @@ static unique_ptr<FunctionData> JsonSerializeBind(ClientContext &context, Scalar
 				throw BinderException("json_serialize_sql: 'format' argument must be a boolean");
 			}
 			format = BooleanValue::Get(ExpressionExecutor::EvaluateScalar(context, *arg));
+		} else if (arg->alias == "skip_default") {
+			if (arg->return_type.id() != LogicalTypeId::BOOLEAN) {
+				throw BinderException("json_serialize_sql: 'skip_default' argument must be a boolean");
+			}
+			skip_if_default = BooleanValue::Get(ExpressionExecutor::EvaluateScalar(context, *arg));
 		} else {
-			throw BinderException(StringUtil::Format("json_serialize_sql: Unknown argument '%s'", arg->alias.c_str()));
+			throw BinderException(StringUtil::Format("json_serialize_sql: Unknown argument '%s'", arg->alias));
 		}
 	}
-	return make_uniq<JsonSerializeBindData>(skip_if_null, skip_if_empty, format);
+	return make_uniq<JsonSerializeBindData>(skip_if_null, skip_if_empty, skip_if_default, format);
 }
 
 static void JsonSerializeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -97,7 +105,8 @@ static void JsonSerializeFunction(DataChunk &args, ExpressionState &state, Vecto
 					throw NotImplementedException("Only SELECT statements can be serialized to json!");
 				}
 				auto &select = statement->Cast<SelectStatement>();
-				auto json = JsonSerializer::Serialize(select, doc, info.skip_if_null, info.skip_if_empty);
+				auto json =
+				    JsonSerializer::Serialize(select, doc, info.skip_if_null, info.skip_if_empty, info.skip_if_default);
 
 				yyjson_mut_arr_append(statements_arr, json);
 			}

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

@@ -22,10 +22,10 @@ static inline LogicalTypeId MaxNumericType(LogicalTypeId &a, LogicalTypeId &b) {
 JSONStructureNode::JSONStructureNode() : initialized(false), count(0) {
 }
 
-JSONStructureNode::JSONStructureNode(yyjson_val *key_p, yyjson_val *val_p)
+JSONStructureNode::JSONStructureNode(yyjson_val *key_p, yyjson_val *val_p, const bool ignore_errors)
     : key(make_uniq<string>(unsafe_yyjson_get_str(key_p), unsafe_yyjson_get_len(key_p))), initialized(false), count(0) {
 	D_ASSERT(yyjson_is_str(key_p));
-	JSONStructure::ExtractStructure(val_p, *this);
+	JSONStructure::ExtractStructure(val_p, *this, ignore_errors);
 }
 
 JSONStructureNode::JSONStructureNode(JSONStructureNode &&other) noexcept {
@@ -351,7 +351,8 @@ JSONStructureNode &JSONStructureDescription::GetOrCreateChild() {
 	return children.back();
 }
 
-JSONStructureNode &JSONStructureDescription::GetOrCreateChild(yyjson_val *key, yyjson_val *val) {
+JSONStructureNode &JSONStructureDescription::GetOrCreateChild(yyjson_val *key, yyjson_val *val,
+                                                              const bool ignore_errors) {
 	D_ASSERT(yyjson_is_str(key));
 	// Check if there is already a child with the same key
 	idx_t child_idx;
@@ -359,18 +360,18 @@ JSONStructureNode &JSONStructureDescription::GetOrCreateChild(yyjson_val *key, y
 	auto it = key_map.find(temp_key);
 	if (it == key_map.end()) { // Didn't find, create a new child
 		child_idx = children.size();
-		children.emplace_back(key, val);
+		children.emplace_back(key, val, ignore_errors);
 		const auto &persistent_key_string = children.back().key;
 		JSONKey new_key {persistent_key_string->c_str(), persistent_key_string->length()};
 		key_map.emplace(new_key, child_idx);
 	} else { // Found it
 		child_idx = it->second;
-		JSONStructure::ExtractStructure(val, children[child_idx]);
+		JSONStructure::ExtractStructure(val, children[child_idx], ignore_errors);
 	}
 	return children[child_idx];
 }
 
-static inline void ExtractStructureArray(yyjson_val *arr, JSONStructureNode &node) {
+static inline void ExtractStructureArray(yyjson_val *arr, JSONStructureNode &node, const bool ignore_errors) {
 	D_ASSERT(yyjson_is_arr(arr));
 	auto &description = node.GetOrCreateDescription(LogicalTypeId::LIST);
 	auto &child = description.GetOrCreateChild();
@@ -378,50 +379,50 @@ static inline void ExtractStructureArray(yyjson_val *arr, JSONStructureNode &nod
 	size_t idx, max;
 	yyjson_val *val;
 	yyjson_arr_foreach(arr, idx, max, val) {
-		JSONStructure::ExtractStructure(val, child);
+		JSONStructure::ExtractStructure(val, child, ignore_errors);
 	}
 }
 
-static inline void ExtractStructureObject(yyjson_val *obj, JSONStructureNode &node) {
+static inline void ExtractStructureObject(yyjson_val *obj, JSONStructureNode &node, const bool ignore_errors) {
 	D_ASSERT(yyjson_is_obj(obj));
 	auto &description = node.GetOrCreateDescription(LogicalTypeId::STRUCT);
 
 	// Keep track of keys so we can detect duplicates
-	json_key_set_t obj_keys;
+	case_insensitive_set_t obj_keys;
 
 	size_t idx, max;
 	yyjson_val *key, *val;
 	yyjson_obj_foreach(obj, idx, max, key, val) {
 		auto key_ptr = unsafe_yyjson_get_str(key);
 		auto key_len = unsafe_yyjson_get_len(key);
-		auto insert_result = obj_keys.insert({key_ptr, key_len});
-		if (!insert_result.second) {
+		auto insert_result = obj_keys.insert(string(key_ptr, key_len));
+		if (!ignore_errors && !insert_result.second) {
 			JSONCommon::ThrowValFormatError("Duplicate key \"" + string(key_ptr, key_len) + "\" in object %s", obj);
 		}
-		description.GetOrCreateChild(key, val);
+		description.GetOrCreateChild(key, val, ignore_errors);
 	}
 }
 
-static inline void ExtractStructureVal(yyjson_val *val, JSONStructureNode &node) {
+static inline void ExtractStructureVal(yyjson_val *val, JSONStructureNode &node, const bool ignore_errors) {
 	D_ASSERT(!yyjson_is_arr(val) && !yyjson_is_obj(val));
 	node.GetOrCreateDescription(JSONCommon::ValTypeToLogicalTypeId(val));
 }
 
-void JSONStructure::ExtractStructure(yyjson_val *val, JSONStructureNode &node) {
+void JSONStructure::ExtractStructure(yyjson_val *val, JSONStructureNode &node, const bool ignore_errors) {
 	node.count++;
 	switch (yyjson_get_tag(val)) {
 	case YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE:
-		return ExtractStructureArray(val, node);
+		return ExtractStructureArray(val, node, ignore_errors);
 	case YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE:
-		return ExtractStructureObject(val, node);
+		return ExtractStructureObject(val, node, ignore_errors);
 	default:
-		return ExtractStructureVal(val, node);
+		return ExtractStructureVal(val, node, ignore_errors);
 	}
 }
 
-JSONStructureNode ExtractStructureInternal(yyjson_val *val) {
+JSONStructureNode ExtractStructureInternal(yyjson_val *val, const bool ignore_errors) {
 	JSONStructureNode node;
-	JSONStructure::ExtractStructure(val, node);
+	JSONStructure::ExtractStructure(val, node, ignore_errors);
 	return node;
 }
 
@@ -476,7 +477,7 @@ static inline yyjson_mut_val *ConvertStructure(const JSONStructureNode &node, yy
 
 static inline string_t JSONStructureFunction(yyjson_val *val, yyjson_alc *alc, Vector &result) {
 	return JSONCommon::WriteVal<yyjson_mut_val>(
-	    ConvertStructure(ExtractStructureInternal(val), yyjson_mut_doc_new(alc)), alc);
+	    ConvertStructure(ExtractStructureInternal(val, false), yyjson_mut_doc_new(alc)), alc);
 }
 
 static void StructureFunction(DataChunk &args, ExpressionState &state, Vector &result) {

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

@@ -6,6 +6,35 @@
 
 namespace duckdb {
 
+static inline LogicalType RemoveDuplicateStructKeys(const LogicalType &type, const bool ignore_errors) {
+	switch (type.id()) {
+	case LogicalTypeId::STRUCT: {
+		case_insensitive_set_t child_names;
+		child_list_t<LogicalType> child_types;
+		for (auto &child_type : StructType::GetChildTypes(type)) {
+			auto insert_success = child_names.insert(child_type.first).second;
+			if (!insert_success) {
+				if (ignore_errors) {
+					continue;
+				}
+				throw NotImplementedException(
+				    "Duplicate name \"%s\" in struct auto-detected in JSON, try ignore_errors=true", child_type.first);
+			} else {
+				child_types.emplace_back(child_type.first, RemoveDuplicateStructKeys(child_type.second, ignore_errors));
+			}
+		}
+		return LogicalType::STRUCT(child_types);
+	}
+	case LogicalTypeId::MAP:
+		return LogicalType::MAP(RemoveDuplicateStructKeys(MapType::KeyType(type), ignore_errors),
+		                        RemoveDuplicateStructKeys(MapType::ValueType(type), ignore_errors));
+	case LogicalTypeId::LIST:
+		return LogicalType::LIST(RemoveDuplicateStructKeys(ListType::GetChildType(type), ignore_errors));
+	default:
+		return type;
+	}
+}
+
 void JSONScan::AutoDetect(ClientContext &context, JSONScanData &bind_data, vector<LogicalType> &return_types,
                           vector<string> &names) {
 	// Change scan type during detection
@@ -40,7 +69,7 @@ void JSONScan::AutoDetect(ClientContext &context, JSONScanData &bind_data, vecto
 			for (idx_t i = 0; i < next; i++) {
 				const auto &val = lstate.values[i];
 				if (val) {
-					JSONStructure::ExtractStructure(val, node);
+					JSONStructure::ExtractStructure(val, node, true);
 				}
 			}
 			if (!node.ContainsVarchar()) { // Can't refine non-VARCHAR types
@@ -94,7 +123,7 @@ void JSONScan::AutoDetect(ClientContext &context, JSONScanData &bind_data, vecto
 			return_types.reserve(child_types.size());
 			names.reserve(child_types.size());
 			for (auto &child_type : child_types) {
-				return_types.emplace_back(child_type.second);
+				return_types.emplace_back(RemoveDuplicateStructKeys(child_type.second, bind_data.ignore_errors));
 				names.emplace_back(child_type.first);
 			}
 		} else {
@@ -103,7 +132,7 @@ void JSONScan::AutoDetect(ClientContext &context, JSONScanData &bind_data, vecto
 		}
 	} else {
 		D_ASSERT(bind_data.options.record_type == JSONRecordType::VALUES);
-		return_types.emplace_back(type);
+		return_types.emplace_back(RemoveDuplicateStructKeys(type, bind_data.ignore_errors));
 		names.emplace_back("json");
 	}
 }
@@ -216,6 +245,11 @@ unique_ptr<FunctionData> ReadJSONBind(ClientContext &context, TableFunctionBindI
 		}
 	}
 
+	if (bind_data->options.record_type == JSONRecordType::AUTO_DETECT && return_types.size() > 1) {
+		// More than one specified column implies records
+		bind_data->options.record_type = JSONRecordType::RECORDS;
+	}
+
 	// Specifying column names overrides auto-detect
 	if (!return_types.empty()) {
 		bind_data->auto_detect = false;

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

@@ -15,6 +15,9 @@ namespace duckdb {
 using JSONPathType = JSONCommon::JSONPathType;
 
 static JSONPathType CheckPath(const Value &path_val, string &path, size_t &len) {
+	if (path_val.IsNull()) {
+		throw InternalException("JSON path cannot be NULL");
+	}
 	const auto path_str_val = path_val.DefaultCastAs(LogicalType::VARCHAR);
 	auto path_str = path_str_val.GetValueUnsafe<string_t>();
 	len = path_str.GetSize();
@@ -58,9 +61,11 @@ unique_ptr<FunctionData> JSONReadFunctionData::Bind(ClientContext &context, Scal
 	size_t len = 0;
 	JSONPathType path_type = JSONPathType::REGULAR;
 	if (arguments[1]->IsFoldable()) {
-		constant = true;
 		const auto path_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-		path_type = CheckPath(path_val, path, len);
+		if (!path_val.IsNull()) {
+			constant = true;
+			path_type = CheckPath(path_val, path, len);
+		}
 	}
 	bound_function.arguments[1] = LogicalType::VARCHAR;
 	if (path_type == JSONCommon::JSONPathType::WILDCARD) {