duckdb 0.8.2-dev4711.0 → 0.8.2-dev4871.0

package/binding.gyp

@@ -311,7 +311,6 @@
                 "src/duckdb/extension/json/yyjson/include"
             ], 
             "defines": [
-                "NAPI_DISABLE_CPP_EXCEPTIONS=1", 
                 "NAPI_VERSION=6", 
                 "DUCKDB_EXTENSION_PARQUET_LINKED", 
                 "DUCKDB_EXTENSION_ICU_LINKED", 

package/binding.gyp.in

@@ -16,7 +16,6 @@
                 "${INCLUDE_FILES}"
             ],
             "defines": [
-                "NAPI_DISABLE_CPP_EXCEPTIONS=1",
                 "NAPI_VERSION=6",
                 "${DEFINES}"
             ],

package/package.json

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

package/src/connection.cpp

@@ -66,8 +66,7 @@ Connection::Connection(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Connec
 	int length = info.Length();
 
 	if (length <= 0 || !Database::HasInstance(info[0])) {
-		Napi::TypeError::New(env, "Database object expected").ThrowAsJavaScriptException();
-		return;
+		throw Napi::TypeError::New(env, "Database object expected");
 	}
 
 	database_ref = Napi::ObjectWrap<Database>::Unwrap(info[0].As<Napi::Object>());
@@ -277,8 +276,7 @@ struct RegisterUdfTask : public Task {
 Napi::Value Connection::RegisterUdf(const Napi::CallbackInfo &info) {
 	auto env = info.Env();
 	if (info.Length() < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsFunction()) {
-		Napi::TypeError::New(env, "Holding it wrong").ThrowAsJavaScriptException();
-		return env.Null();
+		throw Napi::TypeError::New(env, "Holding it wrong");
 	}
 
 	std::string name = info[0].As<Napi::String>();
@@ -290,8 +288,7 @@ Napi::Value Connection::RegisterUdf(const Napi::CallbackInfo &info) {
 	}
 
 	if (udfs.find(name) != udfs.end()) {
-		Napi::TypeError::New(env, "UDF with this name already exists").ThrowAsJavaScriptException();
-		return env.Null();
+		throw Napi::TypeError::New(env, "UDF with this name already exists");
 	}
 
 	auto udf = duckdb_node_udf_function_t::New(env, udf_callback, "duckdb_node_udf" + name, 0, 1, nullptr,
@@ -338,8 +335,7 @@ struct UnregisterUdfTask : public Task {
 Napi::Value Connection::UnregisterUdf(const Napi::CallbackInfo &info) {
 	auto env = info.Env();
 	if (info.Length() < 1 || !info[0].IsString()) {
-		Napi::TypeError::New(env, "Holding it wrong").ThrowAsJavaScriptException();
-		return env.Null();
+		throw Napi::TypeError::New(env, "Holding it wrong");
 	}
 	std::string name = info[0].As<Napi::String>();
 
@@ -441,8 +437,7 @@ Napi::Value Connection::Exec(const Napi::CallbackInfo &info) {
 	auto env = info.Env();
 
 	if (info.Length() < 1 || !info[0].IsString()) {
-		Napi::TypeError::New(env, "SQL query expected").ThrowAsJavaScriptException();
-		return env.Null();
+		throw Napi::TypeError::New(env, "SQL query expected");
 	}
 
 	std::string sql = info[0].As<Napi::String>();
@@ -461,8 +456,7 @@ Napi::Value Connection::RegisterBuffer(const Napi::CallbackInfo &info) {
 	auto env = info.Env();
 
 	if (info.Length() < 2 || !info[0].IsString() || !info[1].IsObject()) {
-		Napi::TypeError::New(env, "Incorrect params").ThrowAsJavaScriptException();
-		return env.Null();
+		throw Napi::TypeError::New(env, "Incorrect params");
 	}
 
 	std::string name = info[0].As<Napi::String>();
@@ -471,17 +465,13 @@ Napi::Value Connection::RegisterBuffer(const Napi::CallbackInfo &info) {
 
 	if (info.Length() > 2) {
 		if (!info[2].IsBoolean()) {
-			Napi::TypeError::New(env, "Parameter 3 is of unexpected type. Expected boolean")
-			    .ThrowAsJavaScriptException();
-			return env.Null();
+			throw Napi::TypeError::New(env, "Parameter 3 is of unexpected type. Expected boolean");
 		}
 		force_register = info[2].As<Napi::Boolean>().Value();
 	}
 
 	if (!force_register && array_references.find(name) != array_references.end()) {
-		Napi::TypeError::New(env, "Buffer with this name already exists and force_register is not enabled")
-		    .ThrowAsJavaScriptException();
-		return env.Null();
+		throw Napi::TypeError::New(env, "Buffer with this name already exists and force_register is not enabled");
 	}
 
 	array_references[name] = Napi::Persistent(array);
@@ -491,9 +481,7 @@ Napi::Value Connection::RegisterBuffer(const Napi::CallbackInfo &info) {
 	for (uint64_t ipc_idx = 0; ipc_idx < array.Length(); ipc_idx++) {
 		Napi::Value v = array[ipc_idx];
 		if (!v.IsObject()) {
-			Napi::TypeError::New(env, "Parameter 2 contains unexpected type at index " + std::to_string(ipc_idx))
-			    .ThrowAsJavaScriptException();
-			return env.Null();
+			throw Napi::TypeError::New(env, "Parameter 2 contains unexpected type at index " + std::to_string(ipc_idx));
 		}
 		Napi::Uint8Array arr = v.As<Napi::Uint8Array>();
 		auto raw_ptr = reinterpret_cast<uint64_t>(arr.ArrayBuffer().Data());
@@ -519,8 +507,7 @@ Napi::Value Connection::UnRegisterBuffer(const Napi::CallbackInfo &info) {
 	auto env = info.Env();
 
 	if (info.Length() < 1 || !info[0].IsString()) {
-		Napi::TypeError::New(env, "Incorrect params").ThrowAsJavaScriptException();
-		return env.Null();
+		throw Napi::TypeError::New(env, "Incorrect params");
 	}
 	std::string name = info[0].As<Napi::String>();
 

package/src/data_chunk.cpp

@@ -184,9 +184,7 @@ Napi::Array EncodeDataChunk(Napi::Env env, duckdb::DataChunk &chunk, bool with_t
 				break;
 			}
 			default:
-				Napi::TypeError::New(env, "Unsupported UDF argument type " + vec->GetType().ToString())
-				    .ThrowAsJavaScriptException();
-				break;
+				throw Napi::TypeError::New(env, "Unsupported UDF argument type " + vec->GetType().ToString());
 			}
 		}
 		col_descs.Set(col_idx, col_desc);

package/src/database.cpp

@@ -43,9 +43,7 @@ struct OpenTask : public Task {
 				try {
 					duckdb_config.SetOptionByName(key, duckdb::Value(val));
 				} catch (std::exception &e) {
-					Napi::TypeError::New(env, "Failed to set configuration option " + key + ": " + e.what())
-					    .ThrowAsJavaScriptException();
-					return;
+					throw Napi::TypeError::New(env, "Failed to set configuration option " + key + ": " + e.what());
 				}
 			}
 		}
@@ -90,8 +88,7 @@ Database::Database(const Napi::CallbackInfo &info)
 	auto env = info.Env();
 
 	if (info.Length() < 1 || !info[0].IsString()) {
-		Napi::TypeError::New(env, "Database location expected").ThrowAsJavaScriptException();
-		return;
+		throw Napi::TypeError::New(env, "Database location expected");
 	}
 	std::string filename = info[0].As<Napi::String>();
 	unsigned int pos = 1;
@@ -193,8 +190,7 @@ Napi::Value Database::Serialize(const Napi::CallbackInfo &info) {
 		return info.This();
 	}
 	if (info.Length() < 1 || !info[0].IsFunction()) {
-		Napi::TypeError::New(env, "Callback expected").ThrowAsJavaScriptException();
-		return env.Null();
+		throw Napi::TypeError::New(env, "Callback expected");
 	}
 	Napi::HandleScope scope(env);
 	info[0].As<Napi::Function>().MakeCallback(info.This(), {});
@@ -355,8 +351,7 @@ Napi::Value Database::RegisterReplacementScan(const Napi::CallbackInfo &info) {
 	auto env = info.Env();
 	auto deferred = Napi::Promise::Deferred::New(info.Env());
 	if (info.Length() < 1) {
-		Napi::TypeError::New(env, "Replacement scan callback expected").ThrowAsJavaScriptException();
-		return env.Null();
+		throw Napi::TypeError::New(env, "Replacement scan callback expected");
 	}
 	Napi::Function rs_callback = info[0].As<Napi::Function>();
 	auto rs =

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

@@ -108,10 +108,11 @@ struct ICUDatePart : public ICUDateFunc {
 		return ExtractMillisecond(calendar, micros) * Interval::MICROS_PER_MSEC + micros;
 	}
 
-	static int64_t ExtractEpoch(icu::Calendar *calendar, const uint64_t micros) {
+	static double ExtractEpoch(icu::Calendar *calendar, const uint64_t micros) {
 		UErrorCode status = U_ZERO_ERROR;
-		//	Truncate
-		return calendar->getTime(status) / Interval::MSECS_PER_SEC;
+		auto result = calendar->getTime(status) / Interval::MSECS_PER_SEC;
+		result += micros / double(Interval::MICROS_PER_SEC);
+		return result;
 	}
 
 	static int64_t ExtractTimezone(icu::Calendar *calendar, const uint64_t micros) {
@@ -187,8 +188,6 @@ struct ICUDatePart : public ICUDateFunc {
 			return ExtractQuarter;
 		case DatePartSpecifier::YEARWEEK:
 			return ExtractYearWeek;
-		case DatePartSpecifier::EPOCH:
-			return ExtractEpoch;
 		case DatePartSpecifier::ERA:
 			return ExtractEra;
 		case DatePartSpecifier::TIMEZONE:
@@ -204,6 +203,8 @@ struct ICUDatePart : public ICUDateFunc {
 
 	static part_double_t PartCodeDoubleFactory(DatePartSpecifier part) {
 		switch (part) {
+		case DatePartSpecifier::EPOCH:
+			return ExtractEpoch;
 		case DatePartSpecifier::JULIAN_DAY:
 			return ExtractJulianDay;
 		default:
@@ -262,7 +263,7 @@ struct ICUDatePart : public ICUDateFunc {
 		adapters_t adapters;
 
 		bool Equals(const FunctionData &other_p) const override {
-			const auto &other = (BindAdapterData &)other_p;
+			const auto &other = other_p.Cast<BindAdapterData>();
 			return BindData::Equals(other_p) && adapters == other.adapters;
 		}
 
@@ -278,7 +279,7 @@ struct ICUDatePart : public ICUDateFunc {
 		auto &date_arg = args.data[0];
 
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = (BIND_TYPE &)*func_expr.bind_info;
+		auto &info = func_expr.bind_info->Cast<BIND_TYPE>();
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
 
@@ -655,6 +656,8 @@ struct ICUDatePart : public ICUDateFunc {
 
 void RegisterICUDatePartFunctions(ClientContext &context) {
 	// register the individual operators
+
+	//	BIGINTs
 	ICUDatePart::AddUnaryPartCodeFunctions("era", context);
 	ICUDatePart::AddUnaryPartCodeFunctions("year", context);
 	ICUDatePart::AddUnaryPartCodeFunctions("month", context);
@@ -672,12 +675,13 @@ void RegisterICUDatePartFunctions(ClientContext &context) {
 	ICUDatePart::AddUnaryPartCodeFunctions("week", context); //  Note that WeekOperator is ISO-8601, not US
 	ICUDatePart::AddUnaryPartCodeFunctions("dayofyear", context);
 	ICUDatePart::AddUnaryPartCodeFunctions("quarter", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("epoch", context);
 	ICUDatePart::AddUnaryPartCodeFunctions("isoyear", context);
 	ICUDatePart::AddUnaryPartCodeFunctions("timezone", context);
 	ICUDatePart::AddUnaryPartCodeFunctions("timezone_hour", context);
 	ICUDatePart::AddUnaryPartCodeFunctions("timezone_minute", context);
 
+	//	DOUBLEs
+	ICUDatePart::AddUnaryPartCodeFunctions<double>("epoch", context, LogicalType::DOUBLE);
 	ICUDatePart::AddUnaryPartCodeFunctions<double>("julian", context, LogicalType::DOUBLE);
 
 	//  register combinations

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

@@ -1,6 +1,8 @@
 #include "json_transform.hpp"
 
 #include "duckdb/common/enum_util.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
@@ -8,8 +10,6 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "json_functions.hpp"
 #include "json_scan.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -72,12 +72,13 @@ static unique_ptr<FunctionData> JSONTransformBind(ClientContext &context, Scalar
 	if (arguments[1]->HasParameter()) {
 		throw ParameterNotResolvedException();
 	}
-	if (arguments[1]->return_type == LogicalTypeId::SQLNULL) {
-		bound_function.return_type = LogicalTypeId::SQLNULL;
-	} else if (!arguments[1]->IsFoldable()) {
+	if (!arguments[1]->IsFoldable()) {
 		throw BinderException("JSON structure must be a constant!");
+	}
+	auto structure_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
+	if (structure_val.IsNull() || arguments[1]->return_type == LogicalTypeId::SQLNULL) {
+		bound_function.return_type = LogicalTypeId::SQLNULL;
 	} else {
-		auto structure_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
 		if (!structure_val.DefaultTryCastAs(JSONCommon::JSONType())) {
 			throw BinderException("Cannot cast JSON structure to string");
 		}
@@ -741,6 +742,7 @@ bool JSONTransform::Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &resul
 
 	switch (result_type.id()) {
 	case LogicalTypeId::SQLNULL:
+		FlatVector::Validity(result).SetAllInvalid(count);
 		return true;
 	case LogicalTypeId::BOOLEAN:
 		return TransformNumerical<bool>(vals, result, count, options);

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

@@ -15,9 +15,6 @@ namespace duckdb {
 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");
-	}
 	const auto path_str_val = path_val.DefaultCastAs(LogicalType::VARCHAR);
 	auto path_str = path_str_val.GetValueUnsafe<string_t>();
 	len = path_str.GetSize();
@@ -49,7 +46,7 @@ unique_ptr<FunctionData> JSONReadFunctionData::Copy() const {
 }
 
 bool JSONReadFunctionData::Equals(const FunctionData &other_p) const {
-	auto &other = (const JSONReadFunctionData &)other_p;
+	auto &other = other_p.Cast<JSONReadFunctionData>();
 	return constant == other.constant && path == other.path && len == other.len && path_type == other.path_type;
 }
 
@@ -60,7 +57,7 @@ unique_ptr<FunctionData> JSONReadFunctionData::Bind(ClientContext &context, Scal
 	string path = "";
 	size_t len = 0;
 	JSONPathType path_type = JSONPathType::REGULAR;
-	if (arguments[1]->return_type.id() != LogicalTypeId::SQLNULL && arguments[1]->IsFoldable()) {
+	if (arguments[1]->IsFoldable()) {
 		constant = true;
 		const auto path_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
 		path_type = CheckPath(path_val, path, len);
@@ -83,7 +80,7 @@ unique_ptr<FunctionData> JSONReadManyFunctionData::Copy() const {
 }
 
 bool JSONReadManyFunctionData::Equals(const FunctionData &other_p) const {
-	auto &other = (const JSONReadManyFunctionData &)other_p;
+	auto &other = other_p.Cast<JSONReadManyFunctionData>();
 	return paths == other.paths && lens == other.lens;
 }
 
@@ -100,6 +97,7 @@ unique_ptr<FunctionData> JSONReadManyFunctionData::Bind(ClientContext &context,
 	vector<string> paths;
 	vector<size_t> lens;
 	auto paths_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
+
 	for (auto &path_val : ListValue::GetChildren(paths_val)) {
 		paths.emplace_back("");
 		lens.push_back(0);

package/src/duckdb/src/common/enum_util.cpp

@@ -1197,8 +1197,6 @@ const char* EnumUtil::ToChars<DatePartSpecifier>(DatePartSpecifier value) {
 		return "MINUTE";
 	case DatePartSpecifier::HOUR:
 		return "HOUR";
-	case DatePartSpecifier::EPOCH:
-		return "EPOCH";
 	case DatePartSpecifier::DOW:
 		return "DOW";
 	case DatePartSpecifier::ISODOW:
@@ -1221,8 +1219,12 @@ const char* EnumUtil::ToChars<DatePartSpecifier>(DatePartSpecifier value) {
 		return "TIMEZONE_HOUR";
 	case DatePartSpecifier::TIMEZONE_MINUTE:
 		return "TIMEZONE_MINUTE";
+	case DatePartSpecifier::EPOCH:
+		return "EPOCH";
 	case DatePartSpecifier::JULIAN_DAY:
 		return "JULIAN_DAY";
+	case DatePartSpecifier::INVALID:
+		return "INVALID";
 	default:
 		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
 	}
@@ -1263,9 +1265,6 @@ DatePartSpecifier EnumUtil::FromString<DatePartSpecifier>(const char *value) {
 	if (StringUtil::Equals(value, "HOUR")) {
 		return DatePartSpecifier::HOUR;
 	}
-	if (StringUtil::Equals(value, "EPOCH")) {
-		return DatePartSpecifier::EPOCH;
-	}
 	if (StringUtil::Equals(value, "DOW")) {
 		return DatePartSpecifier::DOW;
 	}
@@ -1299,9 +1298,15 @@ DatePartSpecifier EnumUtil::FromString<DatePartSpecifier>(const char *value) {
 	if (StringUtil::Equals(value, "TIMEZONE_MINUTE")) {
 		return DatePartSpecifier::TIMEZONE_MINUTE;
 	}
+	if (StringUtil::Equals(value, "EPOCH")) {
+		return DatePartSpecifier::EPOCH;
+	}
 	if (StringUtil::Equals(value, "JULIAN_DAY")) {
 		return DatePartSpecifier::JULIAN_DAY;
 	}
+	if (StringUtil::Equals(value, "INVALID")) {
+		return DatePartSpecifier::INVALID;
+	}
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 

package/src/duckdb/src/common/radix_partitioning.cpp

@@ -188,7 +188,7 @@ void RadixPartitionedTupleData::InitializeAppendStateInternal(PartitionedTupleDa
 	for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
 		column_ids.emplace_back(col_idx);
 	}
-	partitions[0]->InitializeAppend(state.chunk_state, std::move(column_ids));
+	partitions[0]->InitializeChunkState(state.chunk_state, std::move(column_ids));
 
 	// Initialize fixed-size map
 	state.fixed_partition_entries.resize(RadixPartitioning::NumberOfPartitions(radix_bits));