duckdb 0.3.5-dev329.0 → 0.3.5-dev349.0

package/package.json

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

package/src/duckdb.cpp

@@ -77813,6 +77813,9 @@ void AvgFun::RegisterFunction(BuiltinFunctions &set) {
 	    LogicalType::DOUBLE, LogicalType::DOUBLE, true));
 	set.AddFunction(avg);
 
+	avg.name = "mean";
+	set.AddFunction(avg);
+
 	AggregateFunctionSet favg("favg");
 	favg.AddFunction(AggregateFunction::UnaryAggregate<KahanAvgState, double, double, KahanAverageOperation>(
 	    LogicalType::DOUBLE, LogicalType::DOUBLE, true));
@@ -83673,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) {
 
@@ -83689,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) {
 
@@ -83707,6 +83715,12 @@ struct HistogramStringUpdateFunctor {
 			}
 		}
 	}
+
+	template <class T>
+	static Value HistogramFinalize(T first) {
+		string_t value = first;
+		return Value::CreateValue(value);
+	}
 };
 
 struct HistogramFunction {
@@ -83767,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);
@@ -83784,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) {
@@ -83793,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;
@@ -83831,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>);
 }
 
@@ -83849,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");
 	}
@@ -92355,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;
@@ -92386,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);
 			}
 		}
@@ -92395,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;
@@ -92419,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();
@@ -92525,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");
@@ -129089,44 +129141,75 @@ FilterResult FilterCombiner::AddFilter(Expression *expr) {
 	if (expr->GetExpressionClass() == ExpressionClass::BOUND_BETWEEN) {
 		auto &comparison = (BoundBetweenExpression &)*expr;
 		//! check if one of the sides is a scalar value
-		bool left_is_scalar = comparison.lower->IsFoldable();
-		bool right_is_scalar = comparison.upper->IsFoldable();
-		if (left_is_scalar || right_is_scalar) {
-			//! comparison with scalar
+		bool lower_is_scalar = comparison.lower->IsFoldable();
+		bool upper_is_scalar = comparison.upper->IsFoldable();
+		if (lower_is_scalar || upper_is_scalar) {
+			//! comparison with scalar - break apart
 			auto node = GetNode(comparison.input.get());
 			idx_t equivalence_set = GetEquivalenceSet(node);
-			auto scalar = comparison.lower.get();
-			auto constant_value = ExpressionExecutor::EvaluateScalar(*scalar);
+			auto result = FilterResult::UNSATISFIABLE;
+
+			if (lower_is_scalar) {
+				auto scalar = comparison.lower.get();
+				auto constant_value = ExpressionExecutor::EvaluateScalar(*scalar);
+
+				// create the ExpressionValueInformation
+				ExpressionValueInformation info;
+				if (comparison.lower_inclusive) {
+					info.comparison_type = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
+				} else {
+					info.comparison_type = ExpressionType::COMPARE_GREATERTHAN;
+				}
+				info.constant = constant_value;
 
-			// create the ExpressionValueInformation
-			ExpressionValueInformation info;
-			if (comparison.lower_inclusive) {
-				info.comparison_type = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
+				// get the current bucket of constant values
+				D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
+				auto &info_list = constant_values.find(equivalence_set)->second;
+				// check the existing constant comparisons to see if we can do any pruning
+				result = AddConstantComparison(info_list, info);
 			} else {
-				info.comparison_type = ExpressionType::COMPARE_GREATERTHAN;
+				D_ASSERT(upper_is_scalar);
+				const auto type = comparison.upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO
+				                                             : ExpressionType::COMPARE_LESSTHAN;
+				auto left = comparison.lower->Copy();
+				auto right = comparison.input->Copy();
+				auto lower_comp = make_unique<BoundComparisonExpression>(type, move(left), move(right));
+				result = AddBoundComparisonFilter(lower_comp.get());
+			}
+
+			//	 Stop if we failed
+			if (result != FilterResult::SUCCESS) {
+				return result;
 			}
-			info.constant = constant_value;
 
-			// get the current bucket of constant values
-			D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
-			auto &info_list = constant_values.find(equivalence_set)->second;
-			// check the existing constant comparisons to see if we can do any pruning
-			AddConstantComparison(info_list, info);
-			scalar = comparison.upper.get();
-			constant_value = ExpressionExecutor::EvaluateScalar(*scalar);
+			if (upper_is_scalar) {
+				auto scalar = comparison.upper.get();
+				auto constant_value = ExpressionExecutor::EvaluateScalar(*scalar);
 
-			// create the ExpressionValueInformation
-			if (comparison.upper_inclusive) {
-				info.comparison_type = ExpressionType::COMPARE_LESSTHANOREQUALTO;
+				// create the ExpressionValueInformation
+				ExpressionValueInformation info;
+				if (comparison.upper_inclusive) {
+					info.comparison_type = ExpressionType::COMPARE_LESSTHANOREQUALTO;
+				} else {
+					info.comparison_type = ExpressionType::COMPARE_LESSTHAN;
+				}
+				info.constant = constant_value;
+
+				// get the current bucket of constant values
+				D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
+				// check the existing constant comparisons to see if we can do any pruning
+				result = AddConstantComparison(constant_values.find(equivalence_set)->second, info);
 			} else {
-				info.comparison_type = ExpressionType::COMPARE_LESSTHAN;
+				D_ASSERT(lower_is_scalar);
+				const auto type = comparison.upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO
+				                                             : ExpressionType::COMPARE_LESSTHAN;
+				auto left = comparison.input->Copy();
+				auto right = comparison.upper->Copy();
+				auto upper_comp = make_unique<BoundComparisonExpression>(type, move(left), move(right));
+				result = AddBoundComparisonFilter(upper_comp.get());
 			}
-			info.constant = constant_value;
 
-			// get the current bucket of constant values
-			D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
-			// check the existing constant comparisons to see if we can do any pruning
-			return AddConstantComparison(constant_values.find(equivalence_set)->second, info);
+			return result;
 		}
 	} else if (expr->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
 		return AddBoundComparisonFilter(expr);

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 "9462bc223"
-#define DUCKDB_VERSION "v0.3.5-dev329"
+#define DUCKDB_SOURCE_ID "d8a2743d8"
+#define DUCKDB_VERSION "v0.3.5-dev349"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -22808,8 +22808,8 @@ namespace duckdb {
 
 class BetweenExpression : public ParsedExpression {
 public:
-	BetweenExpression(unique_ptr<ParsedExpression> input, unique_ptr<ParsedExpression> lower,
-	                  unique_ptr<ParsedExpression> upper);
+	DUCKDB_API BetweenExpression(unique_ptr<ParsedExpression> input, unique_ptr<ParsedExpression> lower,
+	                             unique_ptr<ParsedExpression> upper);
 
 	unique_ptr<ParsedExpression> input;
 	unique_ptr<ParsedExpression> lower;