duckdb 0.3.1-dev289.0 → 0.3.1-dev291.0

package/package.json

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

package/src/duckdb.cpp

@@ -130128,16 +130128,23 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			throw ParserException("Cannot use multiple ORDER BY clauses with WITHIN GROUP");
 		}
 		if (lowercase_name == "percentile_cont") {
+			if (children.size() != 1) {
+				throw ParserException("Wrong number of arguments for PERCENTILE_CONT");
+			}
 			lowercase_name = "quantile_cont";
 		} else if (lowercase_name == "percentile_disc") {
+			if (children.size() != 1) {
+				throw ParserException("Wrong number of arguments for PERCENTILE_DISC");
+			}
 			lowercase_name = "quantile_disc";
 		} else if (lowercase_name == "mode") {
+			if (!children.empty()) {
+				throw ParserException("Wrong number of arguments for MODE");
+			}
 			lowercase_name = "mode";
 		} else {
 			throw ParserException("Unknown ordered aggregate \"%s\".", function_name);
 		}
-		children.insert(children.begin(), move(order_bys->orders[0].expression));
-		order_bys->orders.clear();
 	}
 
 	// star gets eaten in the parser
@@ -134249,6 +134256,7 @@ void BindContext::AddContext(BindContext other) {
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -134466,8 +134474,30 @@ public:
 
 
 
+
 namespace duckdb {
 
+static void InvertPercentileFractions(unique_ptr<ParsedExpression> &fractions) {
+	D_ASSERT(fractions.get());
+	D_ASSERT(fractions->expression_class == ExpressionClass::BOUND_EXPRESSION);
+	auto &bound = (BoundExpression &)*fractions;
+
+	if (!bound.expr->IsFoldable()) {
+		return;
+	}
+
+	Value value = ExpressionExecutor::EvaluateScalar(*bound.expr);
+	if (value.type().id() == LogicalTypeId::LIST) {
+		vector<Value> values;
+		for (const auto &element_val : value.list_value) {
+			values.emplace_back(Value(1) - element_val);
+		}
+		bound.expr = make_unique<BoundConstantExpression>(Value::LIST(values));
+	} else {
+		bound.expr = make_unique<BoundConstantExpression>(Value(1) - value);
+	}
+}
+
 BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry *func, idx_t depth) {
 	// first bind the child of the aggregate expression (if any)
 	this->bound_aggregate = true;
@@ -134480,8 +134510,28 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 		aggregate_binder.BindChild(aggr.filter, 0, error);
 	}
 
+	// Handle ordered-set aggregates by moving the single ORDER BY expression to the front of the children.
+	//	https://www.postgresql.org/docs/current/functions-aggregate.html#FUNCTIONS-ORDEREDSET-TABLE
+	bool ordered_set_agg = false;
+	bool invert_fractions = false;
+	if (aggr.order_bys && aggr.order_bys->orders.size() == 1) {
+		const auto &func_name = aggr.function_name;
+		ordered_set_agg = (func_name == "quantile_cont" || func_name == "quantile_disc" || func_name == "mode");
+
+		if (ordered_set_agg) {
+			auto &config = DBConfig::GetConfig(context);
+			const auto &order = aggr.order_bys->orders[0];
+			const auto sense = (order.type == OrderType::ORDER_DEFAULT) ? config.default_order_type : order.type;
+			invert_fractions = (sense == OrderType::DESCENDING);
+		}
+	}
+
 	for (auto &child : aggr.children) {
 		aggregate_binder.BindChild(child, 0, error);
+		// We have to invert the fractions for PERCENTILE_XXXX DESC
+		if (invert_fractions) {
+			InvertPercentileFractions(child);
+		}
 	}
 
 	// Bind the ORDER BYs, if any
@@ -134543,6 +134593,17 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 	vector<LogicalType> types;
 	vector<LogicalType> arguments;
 	vector<unique_ptr<Expression>> children;
+
+	if (ordered_set_agg) {
+		for (auto &order : aggr.order_bys->orders) {
+			auto &child = (BoundExpression &)*order.expression;
+			types.push_back(child.expr->return_type);
+			arguments.push_back(child.expr->return_type);
+			children.push_back(move(child.expr));
+		}
+		aggr.order_bys->orders.clear();
+	}
+
 	for (idx_t i = 0; i < aggr.children.size(); i++) {
 		auto &child = (BoundExpression &)*aggr.children[i];
 		types.push_back(child.expr->return_type);

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "00333848e"
-#define DUCKDB_VERSION "0.3.1-dev289"
+#define DUCKDB_SOURCE_ID "041bb3216"
+#define DUCKDB_VERSION "0.3.1-dev291"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //