duckdb 0.3.5-dev346.0 → 0.3.5-dev349.0

package/package.json

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

package/src/duckdb.cpp

@@ -83676,7 +83676,7 @@ struct HistogramFun {
 
 namespace duckdb {
 
-struct HistogramUpdateFunctor {
+struct HistogramFunctor {
 	template <class T, class MAP_TYPE = map<T, idx_t>>
 	static void HistogramUpdate(VectorData &sdata, VectorData &input_data, idx_t count) {
 
@@ -83692,9 +83692,14 @@ struct HistogramUpdateFunctor {
 			}
 		}
 	}
+
+	template <class T>
+	static Value HistogramFinalize(T first) {
+		return Value::CreateValue(first);
+	}
 };
 
-struct HistogramStringUpdateFunctor {
+struct HistogramStringFunctor {
 	template <class T, class MAP_TYPE = map<T, idx_t>>
 	static void HistogramUpdate(VectorData &sdata, VectorData &input_data, idx_t count) {
 
@@ -83710,6 +83715,12 @@ struct HistogramStringUpdateFunctor {
 			}
 		}
 	}
+
+	template <class T>
+	static Value HistogramFinalize(T first) {
+		string_t value = first;
+		return Value::CreateValue(value);
+	}
 };
 
 struct HistogramFunction {
@@ -83770,8 +83781,8 @@ static void HistogramCombineFunction(Vector &state, Vector &combined, FunctionDa
 	}
 }
 
-template <class T, class MAP_TYPE>
-static void HistogramFinalize(Vector &state_vector, FunctionData *, Vector &result, idx_t count, idx_t offset) {
+template <class OP, class T, class MAP_TYPE>
+static void HistogramFinalizeFunction(Vector &state_vector, FunctionData *, Vector &result, idx_t count, idx_t offset) {
 
 	VectorData sdata;
 	state_vector.Orrify(count, sdata);
@@ -83787,7 +83798,9 @@ static void HistogramFinalize(Vector &state_vector, FunctionData *, Vector &resu
 
 	auto &bucket_validity = FlatVector::Validity(*bucket_list);
 	auto &count_validity = FlatVector::Validity(*count_list);
+
 	for (idx_t i = 0; i < count; i++) {
+
 		const auto rid = i + offset;
 		auto state = states[sdata.sel->get_index(i)];
 		if (!state->hist) {
@@ -83796,12 +83809,14 @@ static void HistogramFinalize(Vector &state_vector, FunctionData *, Vector &resu
 			count_validity.SetInvalid(rid);
 			continue;
 		}
+
 		for (auto &entry : *state->hist) {
-			auto bucket_value = Value::CreateValue(entry.first);
+			Value bucket_value = OP::template HistogramFinalize<T>(entry.first);
 			ListVector::PushBack(*bucket_list, bucket_value);
 			auto count_value = Value::CreateValue(entry.second);
 			ListVector::PushBack(*count_list, count_value);
 		}
+
 		auto list_struct_data = FlatVector::GetData<list_entry_t>(*bucket_list);
 		list_struct_data[rid].length = ListVector::GetListSize(*bucket_list) - old_len;
 		list_struct_data[rid].offset = old_len;
@@ -83834,7 +83849,7 @@ static AggregateFunction GetHistogramFunction(const LogicalType &type) {
 	return AggregateFunction("histogram", {type}, LogicalTypeId::MAP, AggregateFunction::StateSize<STATE_TYPE>,
 	                         AggregateFunction::StateInitialize<STATE_TYPE, HistogramFunction>,
 	                         HistogramUpdateFunction<OP, T, MAP_TYPE>, HistogramCombineFunction<T, MAP_TYPE>,
-	                         HistogramFinalize<T, MAP_TYPE>, nullptr, HistogramBindFunction,
+	                         HistogramFinalizeFunction<OP, T, MAP_TYPE>, nullptr, HistogramBindFunction,
 	                         AggregateFunction::StateDestroy<STATE_TYPE, HistogramFunction>);
 }
 
@@ -83852,45 +83867,45 @@ AggregateFunction GetHistogramFunction(const LogicalType &type) {
 
 	switch (type.id()) {
 	case LogicalType::BOOLEAN:
-		return GetMapType<HistogramUpdateFunctor, bool, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, bool, IS_ORDERED>(type);
 	case LogicalType::UTINYINT:
-		return GetMapType<HistogramUpdateFunctor, uint8_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, uint8_t, IS_ORDERED>(type);
 	case LogicalType::USMALLINT:
-		return GetMapType<HistogramUpdateFunctor, uint16_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, uint16_t, IS_ORDERED>(type);
 	case LogicalType::UINTEGER:
-		return GetMapType<HistogramUpdateFunctor, uint32_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, uint32_t, IS_ORDERED>(type);
 	case LogicalType::UBIGINT:
-		return GetMapType<HistogramUpdateFunctor, uint64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, uint64_t, IS_ORDERED>(type);
 	case LogicalType::TINYINT:
-		return GetMapType<HistogramUpdateFunctor, int8_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, int8_t, IS_ORDERED>(type);
 	case LogicalType::SMALLINT:
-		return GetMapType<HistogramUpdateFunctor, int16_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, int16_t, IS_ORDERED>(type);
 	case LogicalType::INTEGER:
-		return GetMapType<HistogramUpdateFunctor, int32_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, int32_t, IS_ORDERED>(type);
 	case LogicalType::BIGINT:
-		return GetMapType<HistogramUpdateFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
 	case LogicalType::FLOAT:
-		return GetMapType<HistogramUpdateFunctor, float, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, float, IS_ORDERED>(type);
 	case LogicalType::DOUBLE:
-		return GetMapType<HistogramUpdateFunctor, double, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, double, IS_ORDERED>(type);
 	case LogicalType::VARCHAR:
-		return GetMapType<HistogramStringUpdateFunctor, string, IS_ORDERED>(type);
+		return GetMapType<HistogramStringFunctor, string, IS_ORDERED>(type);
 	case LogicalType::TIMESTAMP:
-		return GetMapType<HistogramUpdateFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
 	case LogicalType::TIMESTAMP_TZ:
-		return GetMapType<HistogramUpdateFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
 	case LogicalType::TIMESTAMP_S:
-		return GetMapType<HistogramUpdateFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
 	case LogicalType::TIMESTAMP_MS:
-		return GetMapType<HistogramUpdateFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
 	case LogicalType::TIMESTAMP_NS:
-		return GetMapType<HistogramUpdateFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
 	case LogicalType::TIME:
-		return GetMapType<HistogramUpdateFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
 	case LogicalType::TIME_TZ:
-		return GetMapType<HistogramUpdateFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
 	case LogicalType::DATE:
-		return GetMapType<HistogramUpdateFunctor, int32_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, int32_t, IS_ORDERED>(type);
 	default:
 		throw InternalException("Unimplemented histogram aggregate");
 	}
@@ -92358,14 +92373,29 @@ struct StateVector {
 	Vector state_vector;
 };
 
+struct FinalizeValueFunctor {
+	template <class T>
+	static Value FinalizeValue(T first) {
+		return Value::CreateValue(first);
+	}
+};
+
+struct FinalizeStringValueFunctor {
+	template <class T>
+	static Value FinalizeValue(T first) {
+		string_t value = first;
+		return Value::CreateValue(value);
+	}
+};
+
 struct AggregateFunctor {
-	template <class T, class MAP_TYPE = unordered_map<T, idx_t>>
+	template <class OP, class T, class MAP_TYPE = unordered_map<T, idx_t>>
 	static void ListExecuteFunction(Vector &result, Vector &state_vector, idx_t count) {
 	}
 };
 
 struct DistinctFunctor {
-	template <class T, class MAP_TYPE = unordered_map<T, idx_t>>
+	template <class OP, class T, class MAP_TYPE = unordered_map<T, idx_t>>
 	static void ListExecuteFunction(Vector &result, Vector &state_vector, idx_t count) {
 
 		VectorData sdata;
@@ -92389,7 +92419,7 @@ struct DistinctFunctor {
 			offset += state->hist->size();
 
 			for (auto &entry : *state->hist) {
-				auto bucket_value = Value::CreateValue(entry.first);
+				Value bucket_value = OP::template FinalizeValue<T>(entry.first);
 				ListVector::PushBack(result, bucket_value);
 			}
 		}
@@ -92398,7 +92428,7 @@ struct DistinctFunctor {
 };
 
 struct UniqueFunctor {
-	template <class T, class MAP_TYPE = unordered_map<T, idx_t>>
+	template <class OP, class T, class MAP_TYPE = unordered_map<T, idx_t>>
 	static void ListExecuteFunction(Vector &result, Vector &state_vector, idx_t count) {
 
 		VectorData sdata;
@@ -92422,7 +92452,7 @@ struct UniqueFunctor {
 	}
 };
 
-template <class OP, bool IS_AGGR = false>
+template <class FUNCTION_FUNCTOR, bool IS_AGGR = false>
 static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 
 	auto count = args.size();
@@ -92528,61 +92558,80 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 
 		switch (key_type.InternalType()) {
 		case PhysicalType::BOOL:
-			OP::template ListExecuteFunction<bool>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, bool>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::UINT8:
-			OP::template ListExecuteFunction<uint8_t>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, uint8_t>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::UINT16:
-			OP::template ListExecuteFunction<uint16_t>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, uint16_t>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::UINT32:
-			OP::template ListExecuteFunction<uint32_t>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, uint32_t>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::UINT64:
-			OP::template ListExecuteFunction<uint64_t>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, uint64_t>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::INT8:
-			OP::template ListExecuteFunction<int8_t>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int8_t>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::INT16:
-			OP::template ListExecuteFunction<int16_t>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int16_t>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::INT32:
-			OP::template ListExecuteFunction<int32_t>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int32_t>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::INT64:
-			OP::template ListExecuteFunction<int64_t>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int64_t>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::FLOAT:
-			OP::template ListExecuteFunction<float>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, float>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::DOUBLE:
-			OP::template ListExecuteFunction<double>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, double>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::DATE32:
-			OP::template ListExecuteFunction<int32_t>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int32_t>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::DATE64:
-			OP::template ListExecuteFunction<int64_t>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int64_t>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::TIMESTAMP:
-			OP::template ListExecuteFunction<int64_t>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int64_t>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::TIME32:
-			OP::template ListExecuteFunction<int32_t>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int32_t>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::TIME64:
-			OP::template ListExecuteFunction<int64_t>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int64_t>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::STRING:
-			OP::template ListExecuteFunction<string>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeStringValueFunctor, string>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::LARGE_STRING:
-			OP::template ListExecuteFunction<string>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeStringValueFunctor, string>(
+			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::VARCHAR:
-			OP::template ListExecuteFunction<string>(result, state_vector.state_vector, count);
+			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeStringValueFunctor, string>(
+			    result, state_vector.state_vector, count);
 			break;
 		default:
 			throw InternalException("Unimplemented histogram aggregate");

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 "0a96249d0"
-#define DUCKDB_VERSION "v0.3.5-dev346"
+#define DUCKDB_SOURCE_ID "d8a2743d8"
+#define DUCKDB_VERSION "v0.3.5-dev349"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //