duckdb 0.3.3-dev432.0 → 0.3.3-dev452.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.3-dev432.0",
+  "version": "0.3.3-dev452.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -44384,6 +44384,9 @@ static bool BlobCastSwitch(Vector &source, Vector &result, idx_t count, string *
 		// blob to varchar
 		VectorStringCast<string_t, duckdb::CastFromBlob>(source, result, count);
 		break;
+	case LogicalTypeId::AGGREGATE_STATE:
+		result.Reinterpret(source);
+		break;
 	default:
 		return TryVectorNullCast(source, result, count, error_message);
 	}
@@ -44572,6 +44575,15 @@ static bool EnumCastSwitch(Vector &source, Vector &result, idx_t count, string *
 	return true;
 }
 
+static bool AggregateStateToBlobCast(Vector &source, Vector &result, idx_t count, string *error_message, bool strict) {
+	if (result.GetType().id() != LogicalTypeId::BLOB) {
+		throw TypeMismatchException(source.GetType(), result.GetType(),
+		                            "Cannot cast AGGREGATE_STATE to anything but BLOB");
+	}
+	result.Reinterpret(source);
+	return true;
+}
+
 static bool StructCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
 	switch (result.GetType().id()) {
 	case LogicalTypeId::STRUCT:
@@ -44687,6 +44699,8 @@ bool VectorOperations::TryCast(Vector &source, Vector &result, idx_t count, stri
 		return ListCastSwitch(source, result, count, error_message);
 	case LogicalTypeId::ENUM:
 		return EnumCastSwitch(source, result, count, error_message, strict);
+	case LogicalTypeId::AGGREGATE_STATE:
+		return AggregateStateToBlobCast(source, result, count, error_message, strict);
 	default:
 		return TryVectorNullCast(source, result, count, error_message);
 	}
@@ -69315,6 +69329,10 @@ struct VarianceFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct StandardErrorOfTheMeanFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
@@ -69909,6 +69927,20 @@ struct STDDevPopOperation : public STDDevBaseOperation {
 		}
 	}
 };
+
+struct StandardErrorOfTheMeanOperation : public STDDevBaseOperation {
+	template <class T, class STATE>
+	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+		if (state->count == 0) {
+			mask.SetInvalid(idx);
+		} else {
+			target[idx] = sqrt(state->dsquared / state->count) / sqrt((state->count));
+			if (!Value::DoubleIsValid(target[idx])) {
+				throw OutOfRangeException("SEM is out of range!");
+			}
+		}
+	}
+};
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
@@ -70070,6 +70102,13 @@ void VarianceFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(var_samp);
 }
 
+void StandardErrorOfTheMeanFun::RegisterFunction(BuiltinFunctions &set) {
+	AggregateFunctionSet sem("sem");
+	sem.AddFunction(AggregateFunction::UnaryAggregate<StddevState, double, double, StandardErrorOfTheMeanOperation>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE));
+	set.AddFunction(sem);
+}
+
 } // namespace duckdb
 
 
@@ -70087,7 +70126,7 @@ void BuiltinFunctions::RegisterAlgebraicAggregates() {
 	Register<VarPopFun>();
 	Register<VarSampFun>();
 	Register<VarianceFun>();
-
+	Register<StandardErrorOfTheMeanFun>();
 	Register<Corr>();
 }
 
@@ -71244,7 +71283,7 @@ struct FirstFunctionString : public FirstFunctionBase {
 		if (!state->is_set || state->is_null) {
 			mask.SetInvalid(idx);
 		} else {
-			target[idx] = StringVector::AddString(result, state->value);
+			target[idx] = StringVector::AddStringOrBlob(result, state->value);
 		}
 	}
 
@@ -92902,9 +92941,13 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 
 	D_ASSERT(input.data.size() == 2);
 	D_ASSERT(input.data[0].GetType().id() == LogicalTypeId::AGGREGATE_STATE);
-	D_ASSERT(input.data[0].GetType() == input.data[1].GetType());
 	D_ASSERT(input.data[0].GetType() == result.GetType());
 
+	if (input.data[0].GetType().InternalType() != input.data[1].GetType().InternalType()) {
+		throw IOException("Aggregate state combine type mismatch, expect %s, got %s",
+		                  input.data[0].GetType().ToString(), input.data[1].GetType().ToString());
+	}
+
 	VectorData state0_data, state1_data;
 	input.data[0].Orrify(input.size(), state0_data);
 	input.data[1].Orrify(input.size(), state1_data);
@@ -92935,8 +92978,10 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 		}
 
 		// we actually have to combine
-		D_ASSERT(state0.GetSize() == bind_data.state_size);
-		D_ASSERT(state1.GetSize() == bind_data.state_size);
+		if (state0.GetSize() != bind_data.state_size || state1.GetSize() != bind_data.state_size) {
+			throw IOException("Aggregate state size mismatch, expect %llu, got %llu and %llu", bind_data.state_size,
+			                  state0.GetSize(), state1.GetSize());
+		}
 
 		memcpy(local_state.state_buffer0.get(), state0.GetDataUnsafe(), bind_data.state_size);
 		memcpy(local_state.state_buffer1.get(), state1.GetDataUnsafe(), bind_data.state_size);
@@ -92963,7 +93008,8 @@ static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, Scala
 		throw BinderException("Can only FINALIZE aggregate state, not %s", arg_return_type.ToString());
 	}
 	// combine
-	if (arguments.size() == 2 && arguments[0]->return_type != arguments[1]->return_type) {
+	if (arguments.size() == 2 && arguments[0]->return_type != arguments[1]->return_type &&
+	    arguments[1]->return_type.id() != LogicalTypeId::BLOB) {
 		throw BinderException("Cannot COMBINE aggregate states from different functions, %s <> %s",
 		                      arguments[0]->return_type.ToString(), arguments[1]->return_type.ToString());
 	}
@@ -93069,7 +93115,7 @@ ScalarFunction ExportAggregateFunction::GetFinalize() {
 }
 
 ScalarFunction ExportAggregateFunction::GetCombine() {
-	return ScalarFunction("combine", {LogicalTypeId::AGGREGATE_STATE, LogicalTypeId::AGGREGATE_STATE},
+	return ScalarFunction("combine", {LogicalTypeId::AGGREGATE_STATE, LogicalTypeId::ANY},
 	                      LogicalTypeId::AGGREGATE_STATE, AggregateStateCombine, false, BindAggregateState, nullptr,
 	                      nullptr, InitCombineState);
 }
@@ -100336,6 +100382,7 @@ void BaseAppender::Close() {
 
 
 
+
 #include <cstring>
 #include <cassert>
 
@@ -100370,6 +100417,10 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &type);
 idx_t GetCTypeSize(duckdb_type type);
 duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_result *out);
 
+struct DuckDBColumnData {
+	LogicalType type;
+};
+
 } // namespace duckdb
 
 
@@ -100915,6 +100966,8 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
 		return DUCKDB_TYPE_BLOB;
 	case LogicalTypeId::INTERVAL:
 		return DUCKDB_TYPE_INTERVAL;
+	case LogicalTypeId::DECIMAL:
+		return DUCKDB_TYPE_DECIMAL;
 	default: // LCOV_EXCL_START
 		D_ASSERT(0);
 		return DUCKDB_TYPE_INVALID;
@@ -100958,6 +101011,8 @@ idx_t GetCTypeSize(duckdb_type type) {
 		return sizeof(duckdb_blob);
 	case DUCKDB_TYPE_INTERVAL:
 		return sizeof(duckdb_interval);
+	case DUCKDB_TYPE_DECIMAL:
+		return sizeof(duckdb_hugeint);
 	default: // LCOV_EXCL_START
 		// unsupported type
 		D_ASSERT(0);
@@ -100977,6 +101032,8 @@ void duckdb_free(void *ptr) {
 
 
 
+
+
 using duckdb::Hugeint;
 using duckdb::hugeint_t;
 using duckdb::Value;
@@ -101001,6 +101058,15 @@ duckdb_hugeint duckdb_double_to_hugeint(double val) {
 	return result;
 }
 
+double duckdb_decimal_to_double(duckdb_decimal val) {
+	double result;
+	hugeint_t value;
+	value.lower = val.value.lower;
+	value.upper = val.value.upper;
+	duckdb::TryCastFromDecimal::Operation<hugeint_t, double>(value, result, nullptr, val.width, val.scale);
+	return result;
+}
+
 
 
 
@@ -101238,6 +101304,9 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 	// zero initialize the columns (so we can cleanly delete it in case a malloc fails)
 	memset(out->__deprecated_columns, 0, sizeof(duckdb_column) * out->__deprecated_column_count);
 	for (idx_t i = 0; i < out->__deprecated_column_count; i++) {
+		auto column_data = new DuckDBColumnData();
+		column_data->type = result->types[i];
+		out->__deprecated_columns[i].internal_data = column_data;
 		out->__deprecated_columns[i].__deprecated_type = ConvertCPPTypeToC(result->types[i]);
 		out->__deprecated_columns[i].__deprecated_name = strdup(result->names[i].c_str());
 		out->__deprecated_columns[i].__deprecated_nullmask =
@@ -101400,9 +101469,72 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 			}
 			break;
 		}
+		case LogicalTypeId::DECIMAL: {
+			// get data
+			idx_t row = 0;
+			auto target = (hugeint_t *)out->__deprecated_columns[col].__deprecated_data;
+			switch (result->types[col].InternalType()) {
+			case PhysicalType::INT16: {
+				for (auto &chunk : result->collection.Chunks()) {
+					auto source = FlatVector::GetData<int16_t>(chunk->data[col]);
+					for (idx_t k = 0; k < chunk->size(); k++) {
+						if (!FlatVector::IsNull(chunk->data[col], k)) {
+							target[row].lower = source[k];
+							target[row].upper = 0;
+						}
+						row++;
+					}
+				}
+				break;
+			}
+			case PhysicalType::INT32: {
+				for (auto &chunk : result->collection.Chunks()) {
+					auto source = FlatVector::GetData<int32_t>(chunk->data[col]);
+					for (idx_t k = 0; k < chunk->size(); k++) {
+						if (!FlatVector::IsNull(chunk->data[col], k)) {
+							target[row].lower = source[k];
+							target[row].upper = 0;
+						}
+						row++;
+					}
+				}
+				break;
+			}
+			case PhysicalType::INT64: {
+				for (auto &chunk : result->collection.Chunks()) {
+					auto source = FlatVector::GetData<int64_t>(chunk->data[col]);
+					for (idx_t k = 0; k < chunk->size(); k++) {
+						if (!FlatVector::IsNull(chunk->data[col], k)) {
+							target[row].lower = source[k];
+							target[row].upper = 0;
+						}
+						row++;
+					}
+				}
+				break;
+			}
+			case PhysicalType::INT128: {
+				for (auto &chunk : result->collection.Chunks()) {
+					auto source = FlatVector::GetData<hugeint_t>(chunk->data[col]);
+					for (idx_t k = 0; k < chunk->size(); k++) {
+						if (!FlatVector::IsNull(chunk->data[col], k)) {
+							target[row].lower = source[k].lower;
+							target[row].upper = source[k].upper;
+						}
+						row++;
+					}
+				}
+				break;
+			}
+			default:
+				throw std::runtime_error("Unsupported physical type for Decimal" +
+				                         TypeIdToString(result->types[col].InternalType()));
+			}
+			break;
+		}
 		default: // LCOV_EXCL_START
-			// unsupported type for C API
-			D_ASSERT(0);
+			std::string err_msg = "Unsupported type for C API: " + result->types[col].ToString();
+			out->__deprecated_error_message = strdup(err_msg.c_str());
 			return DuckDBError;
 		} // LCOV_EXCL_STOP
 	}
@@ -101438,6 +101570,10 @@ static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
 	if (column.__deprecated_name) {
 		duckdb_free(column.__deprecated_name);
 	}
+	if (column.internal_data) {
+		auto column_data = (duckdb::DuckDBColumnData *)column.internal_data;
+		delete column_data;
+	}
 }
 
 void duckdb_destroy_result(duckdb_result *result) {
@@ -101652,7 +101788,12 @@ using duckdb::UnsafeFetch;
 template <class SOURCE_TYPE, class RESULT_TYPE, class OP>
 RESULT_TYPE TryCastCInternal(duckdb_result *result, idx_t col, idx_t row) {
 	RESULT_TYPE result_value;
-	if (!OP::template Operation<SOURCE_TYPE, RESULT_TYPE>(UnsafeFetch<SOURCE_TYPE>(result, col, row), result_value)) {
+	try {
+		if (!OP::template Operation<SOURCE_TYPE, RESULT_TYPE>(UnsafeFetch<SOURCE_TYPE>(result, col, row),
+		                                                      result_value)) {
+			return FetchDefaultValue::Operation<RESULT_TYPE>();
+		}
+	} catch (...) {
 		return FetchDefaultValue::Operation<RESULT_TYPE>();
 	}
 	return result_value;
@@ -101704,6 +101845,8 @@ static RESULT_TYPE GetInternalCValue(duckdb_result *result, idx_t col, idx_t row
 		return TryCastCInternal<timestamp_t, RESULT_TYPE, OP>(result, col, row);
 	case DUCKDB_TYPE_HUGEINT:
 		return TryCastCInternal<hugeint_t, RESULT_TYPE, OP>(result, col, row);
+	case DUCKDB_TYPE_DECIMAL:
+		return TryCastCInternal<hugeint_t, RESULT_TYPE, OP>(result, col, row);
 	case DUCKDB_TYPE_INTERVAL:
 		return TryCastCInternal<interval_t, RESULT_TYPE, OP>(result, col, row);
 	case DUCKDB_TYPE_VARCHAR:
@@ -101740,6 +101883,18 @@ int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t row) {
 	return GetInternalCValue<int64_t>(result, col, row);
 }
 
+duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row) {
+	duckdb_decimal result_value;
+
+	auto column_data = (duckdb::DuckDBColumnData *)result->__deprecated_columns[col].internal_data;
+	column_data->type.GetDecimalProperties(result_value.width, result_value.scale);
+
+	auto internal_value = GetInternalCValue<hugeint_t>(result, col, row);
+	result_value.value.lower = internal_value.lower;
+	result_value.value.upper = internal_value.upper;
+	return result_value;
+}
+
 duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row) {
 	duckdb_hugeint result_value;
 	auto internal_value = GetInternalCValue<hugeint_t>(result, col, row);
@@ -101833,6 +101988,7 @@ bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row) {
 	return result->__deprecated_columns[col].__deprecated_nullmask[row];
 }
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "851e8cfd3"
-#define DUCKDB_VERSION "v0.3.3-dev432"
+#define DUCKDB_SOURCE_ID "079877f47"
+#define DUCKDB_VERSION "v0.3.3-dev452"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -12070,7 +12070,9 @@ typedef enum DUCKDB_TYPE {
 	// const char*
 	DUCKDB_TYPE_VARCHAR,
 	// duckdb_blob
-	DUCKDB_TYPE_BLOB
+	DUCKDB_TYPE_BLOB,
+	// decimal
+	DUCKDB_TYPE_DECIMAL
 } duckdb_type;
 
 //! Days are stored as days since 1970-01-01
@@ -12123,6 +12125,13 @@ typedef struct {
 	int64_t upper;
 } duckdb_hugeint;
 
+typedef struct {
+	uint8_t width;
+	uint8_t scale;
+
+	duckdb_hugeint value;
+} duckdb_decimal;
+
 typedef struct {
 	void *data;
 	idx_t size;
@@ -12457,6 +12466,11 @@ DUCKDB_API int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t ro
  */
 DUCKDB_API duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row);
 
+/*!
+ * returns: The duckdb_decimal value at the specified location, or 0 if the value cannot be converted.
+ */
+DUCKDB_API duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row);
+
 /*!
  * returns: The uint8_t value at the specified location, or 0 if the value cannot be converted.
  */
@@ -12623,6 +12637,17 @@ If the conversion fails because the double value is too big the result will be 0
 */
 DUCKDB_API duckdb_hugeint duckdb_double_to_hugeint(double val);
 
+//===--------------------------------------------------------------------===//
+// Decimal Helpers
+//===--------------------------------------------------------------------===//
+/*!
+Converts a duckdb_decimal object (as obtained from a `DUCKDB_TYPE_DECIMAL` column) into a double.
+
+* val: The decimal value.
+* returns: The converted `double` element.
+*/
+DUCKDB_API double duckdb_decimal_to_double(duckdb_decimal val);
+
 //===--------------------------------------------------------------------===//
 // Prepared Statements
 //===--------------------------------------------------------------------===//