duckdb 0.3.5-dev324.0 → 0.3.5-dev346.0

package/package.json

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

package/src/duckdb.cpp

@@ -50336,13 +50336,9 @@ static bool TimestampTzCastSwitch(Vector &source, Vector &result, idx_t count, s
 		// timestamp with time zone to varchar
 		VectorStringCast<timestamp_t, duckdb::StringCastTZ>(source, result, count);
 		break;
-	case LogicalTypeId::DATE:
-		// timestamp with time zone to date
-		UnaryExecutor::Execute<timestamp_t, date_t, duckdb::Cast>(source, result, count);
-		break;
-	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIME_TZ:
-		// timestamp with time zone to time
+		// timestamp with time zone to time with time zone.
+		// TODO: set the offset to +00
 		UnaryExecutor::Execute<timestamp_t, dtime_t, duckdb::Cast>(source, result, count);
 		break;
 	case LogicalTypeId::TIMESTAMP:
@@ -77817,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));
@@ -129093,44 +129092,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;
+				// 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;
+
+				// 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 "fc2413a5e"
-#define DUCKDB_VERSION "v0.3.5-dev324"
+#define DUCKDB_SOURCE_ID "0a96249d0"
+#define DUCKDB_VERSION "v0.3.5-dev346"
 //===----------------------------------------------------------------------===//
 //                         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;