duckdb 0.2.10-dev437.0 → 0.2.10-dev451.0

package/package.json

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

package/src/duckdb.cpp

@@ -47804,12 +47804,15 @@ namespace duckdb {
 
 unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundFunctionExpression &expr,
                                                                 ExpressionExecutorState &root) {
-	auto result = make_unique<ExpressionState>(expr, root);
+	auto result = make_unique<ExecuteFunctionState>(expr, root);
 	for (auto &child : expr.children) {
 		result->AddChild(child.get());
 	}
 	result->Finalize();
-	return result;
+	if (expr.function.init_local_state) {
+		result->local_state = expr.function.init_local_state(expr, expr.bind_info.get());
+	}
+	return move(result);
 }
 
 void ExpressionExecutor::Execute(const BoundFunctionExpression &expr, ExpressionState *state,
@@ -80389,20 +80392,20 @@ template <class OP>
 static void RegisterLeastGreatest(BuiltinFunctions &set, const string &fun_name) {
 	ScalarFunctionSet fun_set(fun_name);
 	fun_set.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::DATE, LeastGreatestFunction<date_t, OP>, false,
-	                                   nullptr, nullptr, nullptr, LogicalType::DATE));
+	                                   nullptr, nullptr, nullptr, nullptr, LogicalType::DATE));
 	fun_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP,
 	                                   LeastGreatestFunction<timestamp_t, OP>, false, nullptr, nullptr, nullptr,
-	                                   LogicalType::TIMESTAMP));
+	                                   nullptr, LogicalType::TIMESTAMP));
 	fun_set.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::BIGINT, LeastGreatestFunction<int64_t, OP>,
-	                                   false, nullptr, nullptr, nullptr, LogicalType::BIGINT));
+	                                   false, nullptr, nullptr, nullptr, nullptr, LogicalType::BIGINT));
 	fun_set.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::HUGEINT,
-	                                   LeastGreatestFunction<hugeint_t, OP>, false, nullptr, nullptr, nullptr,
+	                                   LeastGreatestFunction<hugeint_t, OP>, false, nullptr, nullptr, nullptr, nullptr,
 	                                   LogicalType::HUGEINT));
 	fun_set.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, LeastGreatestFunction<double, OP>,
-	                                   false, nullptr, nullptr, nullptr, LogicalType::DOUBLE));
+	                                   false, nullptr, nullptr, nullptr, nullptr, LogicalType::DOUBLE));
 	fun_set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                                   LeastGreatestFunction<string_t, OP, true>, false, nullptr, nullptr, nullptr,
-	                                   LogicalType::VARCHAR));
+	                                   nullptr, LogicalType::VARCHAR));
 	set.AddFunction(fun_set);
 }
 
@@ -87959,7 +87962,7 @@ struct RegexpMatchesBindData : public FunctionData {
 
 	duckdb_re2::RE2::Options options;
 	string constant_string;
-	std::unique_ptr<duckdb_re2::RE2> constant_pattern;
+	bool constant_pattern;
 	string range_min;
 	string range_max;
 	bool range_success;
@@ -87981,13 +87984,14 @@ namespace duckdb {
 
 RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string_p)
     : options(options), constant_string(move(constant_string_p)) {
-	if (!constant_string.empty()) {
-		constant_pattern = make_unique<RE2>(constant_string, options);
-		if (!constant_pattern->ok()) {
-			throw Exception(constant_pattern->error());
+	constant_pattern = !constant_string.empty();
+	if (constant_pattern) {
+		auto pattern = make_unique<RE2>(constant_string, options);
+		if (!pattern->ok()) {
+			throw Exception(pattern->error());
 		}
 
-		range_success = constant_pattern->PossibleMatchRange(&range_min, &range_max, 1000);
+		range_success = pattern->PossibleMatchRange(&range_min, &range_max, 1000);
 	} else {
 		range_success = false;
 	}
@@ -88056,6 +88060,24 @@ struct RegexFullMatch {
 	}
 };
 
+struct RegexLocalState : public FunctionData {
+	explicit RegexLocalState(RegexpMatchesBindData &info)
+	    : constant_pattern(duckdb_re2::StringPiece(info.constant_string.c_str(), info.constant_string.size()),
+	                       info.options) {
+		D_ASSERT(info.constant_pattern);
+	}
+
+	RE2 constant_pattern;
+};
+
+static unique_ptr<FunctionData> RegexInitLocalState(const BoundFunctionExpression &expr, FunctionData *bind_data) {
+	auto &info = (RegexpMatchesBindData &)*bind_data;
+	if (info.constant_pattern) {
+		return make_unique<RegexLocalState>(info);
+	}
+	return nullptr;
+}
+
 template <class OP>
 static void RegexpMatchesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &strings = args.data[0];
@@ -88065,8 +88087,9 @@ static void RegexpMatchesFunction(DataChunk &args, ExpressionState &state, Vecto
 	auto &info = (RegexpMatchesBindData &)*func_expr.bind_info;
 
 	if (info.constant_pattern) {
+		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
 		UnaryExecutor::Execute<string_t, bool>(strings, result, args.size(), [&](string_t input) {
-			return OP::Operation(CreateStringPiece(input), *info.constant_pattern);
+			return OP::Operation(CreateStringPiece(input), lstate.constant_pattern);
 		});
 	} else {
 		BinaryExecutor::Execute<string_t, string_t, bool>(strings, patterns, result, args.size(),
@@ -88153,18 +88176,19 @@ static unique_ptr<FunctionData> RegexReplaceBind(ClientContext &context, ScalarF
 void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet regexp_full_match("regexp_full_match");
 	regexp_full_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                                             RegexpMatchesFunction<RegexFullMatch>, false, RegexpMatchesBind));
+	                                             RegexpMatchesFunction<RegexFullMatch>, false, RegexpMatchesBind,
+	                                             nullptr, nullptr, RegexInitLocalState));
 	regexp_full_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
 	                                             LogicalType::BOOLEAN, RegexpMatchesFunction<RegexFullMatch>, false,
-	                                             RegexpMatchesBind));
+	                                             RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState));
 
 	ScalarFunctionSet regexp_partial_match("regexp_matches");
 	regexp_partial_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                                                RegexpMatchesFunction<RegexPartialMatch>, false,
-	                                                RegexpMatchesBind));
+	                                                RegexpMatchesFunction<RegexPartialMatch>, false, RegexpMatchesBind,
+	                                                nullptr, nullptr, RegexInitLocalState));
 	regexp_partial_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
 	                                                LogicalType::BOOLEAN, RegexpMatchesFunction<RegexPartialMatch>,
-	                                                false, RegexpMatchesBind));
+	                                                false, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState));
 
 	ScalarFunctionSet regexp_replace("regexp_replace");
 	regexp_replace.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
@@ -126729,6 +126753,27 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 	auto order_bys = make_unique<OrderModifier>();
 	TransformOrderBy(root->agg_order, order_bys->orders);
 
+	// Ordered aggregates can be either WITHIN GROUP or after the function arguments
+	if (root->agg_within_group) {
+		//	https://www.postgresql.org/docs/current/functions-aggregate.html#FUNCTIONS-ORDEREDSET-TABLE
+		//  Since we implement "ordered aggregates" without sorting,
+		//  we map all the ones we support to the corresponding aggregate function.
+		if (order_bys->orders.size() != 1) {
+			throw ParserException("Cannot use multiple ORDER BY clauses with WITHIN GROUP");
+		}
+		if (lowercase_name == "percentile_cont") {
+			lowercase_name = "quantile_cont";
+		} else if (lowercase_name == "percentile_disc") {
+			lowercase_name = "quantile_disc";
+		} else if (lowercase_name == "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
 	if (lowercase_name == "count" && children.empty()) {
 		lowercase_name = "count_star";
@@ -135014,6 +135059,16 @@ static unique_ptr<ParsedExpression> SummarizeCreateAggregate(const string &aggre
 	return move(cast_function);
 }
 
+static unique_ptr<ParsedExpression> SummarizeCreateAggregate(const string &aggregate, string column_name,
+                                                             const Value &modifier) {
+	vector<unique_ptr<ParsedExpression>> children;
+	children.push_back(make_unique<ColumnRefExpression>(move(column_name)));
+	children.push_back(make_unique<ConstantExpression>(modifier));
+	auto aggregate_function = make_unique<FunctionExpression>(aggregate, move(children));
+	auto cast_function = make_unique<CastExpression>(LogicalType::VARCHAR, move(aggregate_function));
+	return move(cast_function);
+}
+
 static unique_ptr<ParsedExpression> SummarizeCreateCountStar() {
 	vector<unique_ptr<ParsedExpression>> children;
 	auto aggregate_function = make_unique<FunctionExpression>("count_star", move(children));
@@ -135057,6 +135112,10 @@ BoundStatement Binder::BindSummarize(ShowStatement &stmt) {
 	vector<unique_ptr<ParsedExpression>> max_children;
 	vector<unique_ptr<ParsedExpression>> unique_children;
 	vector<unique_ptr<ParsedExpression>> avg_children;
+	vector<unique_ptr<ParsedExpression>> std_children;
+	vector<unique_ptr<ParsedExpression>> q25_children;
+	vector<unique_ptr<ParsedExpression>> q50_children;
+	vector<unique_ptr<ParsedExpression>> q75_children;
 	vector<unique_ptr<ParsedExpression>> count_children;
 	vector<unique_ptr<ParsedExpression>> null_percentage_children;
 	auto select = make_unique<SelectStatement>();
@@ -135067,8 +135126,19 @@ BoundStatement Binder::BindSummarize(ShowStatement &stmt) {
 		min_children.push_back(SummarizeCreateAggregate("min", plan.names[i]));
 		max_children.push_back(SummarizeCreateAggregate("max", plan.names[i]));
 		unique_children.push_back(SummarizeCreateAggregate("approx_count_distinct", plan.names[i]));
-		avg_children.push_back(plan.types[i].IsNumeric() ? SummarizeCreateAggregate("avg", plan.names[i])
-		                                                 : make_unique<ConstantExpression>(Value()));
+		if (plan.types[i].IsNumeric()) {
+			avg_children.push_back(SummarizeCreateAggregate("avg", plan.names[i]));
+			std_children.push_back(SummarizeCreateAggregate("stddev", plan.names[i]));
+			q25_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.25)));
+			q50_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.50)));
+			q75_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.75)));
+		} else {
+			avg_children.push_back(make_unique<ConstantExpression>(Value()));
+			std_children.push_back(make_unique<ConstantExpression>(Value()));
+			q25_children.push_back(make_unique<ConstantExpression>(Value()));
+			q50_children.push_back(make_unique<ConstantExpression>(Value()));
+			q75_children.push_back(make_unique<ConstantExpression>(Value()));
+		}
 		count_children.push_back(SummarizeCreateCountStar());
 		null_percentage_children.push_back(SummarizeCreateNullPercentage(plan.names[i]));
 	}
@@ -135082,6 +135152,10 @@ BoundStatement Binder::BindSummarize(ShowStatement &stmt) {
 	select_node->select_list.push_back(SummarizeWrapUnnest(max_children, "max"));
 	select_node->select_list.push_back(SummarizeWrapUnnest(unique_children, "approx_unique"));
 	select_node->select_list.push_back(SummarizeWrapUnnest(avg_children, "avg"));
+	select_node->select_list.push_back(SummarizeWrapUnnest(std_children, "std"));
+	select_node->select_list.push_back(SummarizeWrapUnnest(q25_children, "q25"));
+	select_node->select_list.push_back(SummarizeWrapUnnest(q50_children, "q50"));
+	select_node->select_list.push_back(SummarizeWrapUnnest(q75_children, "q75"));
 	select_node->select_list.push_back(SummarizeWrapUnnest(count_children, "count"));
 	select_node->select_list.push_back(SummarizeWrapUnnest(null_percentage_children, "null_percentage"));
 	select_node->from_table = move(subquery_ref);

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 "ca1fe636e"
-#define DUCKDB_VERSION "0.2.10-dev437"
+#define DUCKDB_SOURCE_ID "0edad5d3d"
+#define DUCKDB_VERSION "0.2.10-dev451"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -5014,40 +5014,6 @@ private:
 } // namespace duckdb
 
 
-
-namespace duckdb {
-class Expression;
-class ExpressionExecutor;
-struct ExpressionExecutorState;
-
-struct ExpressionState {
-	ExpressionState(const Expression &expr, ExpressionExecutorState &root);
-	virtual ~ExpressionState() {
-	}
-
-	const Expression &expr;
-	ExpressionExecutorState &root;
-	vector<unique_ptr<ExpressionState>> child_states;
-	vector<LogicalType> types;
-	DataChunk intermediate_chunk;
-	string name;
-	CycleCounter profiler;
-
-public:
-	void AddChild(Expression *expr);
-	void Finalize();
-};
-
-struct ExpressionExecutorState {
-	explicit ExpressionExecutorState(const string &name);
-	unique_ptr<ExpressionState> root_state;
-	ExpressionExecutor *executor;
-	CycleCounter profiler;
-	string name;
-};
-
-} // namespace duckdb
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -5711,6 +5677,53 @@ private:
 
 } // namespace duckdb
 
+
+namespace duckdb {
+class Expression;
+class ExpressionExecutor;
+struct ExpressionExecutorState;
+
+struct ExpressionState {
+	ExpressionState(const Expression &expr, ExpressionExecutorState &root);
+	virtual ~ExpressionState() {
+	}
+
+	const Expression &expr;
+	ExpressionExecutorState &root;
+	vector<unique_ptr<ExpressionState>> child_states;
+	vector<LogicalType> types;
+	DataChunk intermediate_chunk;
+	string name;
+	CycleCounter profiler;
+
+public:
+	void AddChild(Expression *expr);
+	void Finalize();
+};
+
+struct ExecuteFunctionState : public ExpressionState {
+	ExecuteFunctionState(const Expression &expr, ExpressionExecutorState &root) : ExpressionState(expr, root) {
+	}
+
+	unique_ptr<FunctionData> local_state;
+
+public:
+	static FunctionData *GetFunctionState(ExpressionState &state) {
+		return ((ExecuteFunctionState &)state).local_state.get();
+	}
+};
+
+struct ExpressionExecutorState {
+	explicit ExpressionExecutorState(const string &name);
+	unique_ptr<ExpressionState> root_state;
+	ExpressionExecutor *executor;
+	CycleCounter profiler;
+	string name;
+};
+
+} // namespace duckdb
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -6296,6 +6309,7 @@ typedef std::function<void(DataChunk &, ExpressionState &, Vector &)> scalar_fun
 //! Binds the scalar function and creates the function data
 typedef unique_ptr<FunctionData> (*bind_scalar_function_t)(ClientContext &context, ScalarFunction &bound_function,
                                                            vector<unique_ptr<Expression>> &arguments);
+typedef unique_ptr<FunctionData> (*init_local_state_t)(const BoundFunctionExpression &expr, FunctionData *bind_data);
 typedef unique_ptr<BaseStatistics> (*function_statistics_t)(ClientContext &context, BoundFunctionExpression &expr,
                                                             FunctionData *bind_data,
                                                             vector<unique_ptr<BaseStatistics>> &child_stats);
@@ -6307,23 +6321,27 @@ public:
 	ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
 	               bool has_side_effects = false, bind_scalar_function_t bind = nullptr,
 	               dependency_function_t dependency = nullptr, function_statistics_t statistics = nullptr,
+	               init_local_state_t init_local_state = nullptr,
 	               LogicalType varargs = LogicalType(LogicalTypeId::INVALID))
 	    : BaseScalarFunction(name, arguments, return_type, has_side_effects, varargs), function(function), bind(bind),
-	      dependency(dependency), statistics(statistics) {
+	      init_local_state(init_local_state), dependency(dependency), statistics(statistics) {
 	}
 
 	ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
 	               bool has_side_effects = false, bind_scalar_function_t bind = nullptr,
 	               dependency_function_t dependency = nullptr, function_statistics_t statistics = nullptr,
+	               init_local_state_t init_local_state = nullptr,
 	               LogicalType varargs = LogicalType(LogicalTypeId::INVALID))
 	    : ScalarFunction(string(), arguments, return_type, function, has_side_effects, bind, dependency, statistics,
-	                     varargs) {
+	                     init_local_state, varargs) {
 	}
 
 	//! The main scalar function to execute
 	scalar_function_t function;
 	//! The bind function (if any)
 	bind_scalar_function_t bind;
+	//! Init thread local state for the function (if any)
+	init_local_state_t init_local_state;
 	// The dependency function (if any)
 	dependency_function_t dependency;
 	//! The statistics propagation function (if any)