duckdb 0.4.1-dev452.0 → 0.4.1-dev464.0

package/package.json

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

package/src/duckdb.cpp

@@ -7600,8 +7600,8 @@ string PhysicalOperatorToString(PhysicalOperatorType type) {
 		return "STREAMING_WINDOW";
 	case PhysicalOperatorType::UNNEST:
 		return "UNNEST";
-	case PhysicalOperatorType::SIMPLE_AGGREGATE:
-		return "SIMPLE_AGGREGATE";
+	case PhysicalOperatorType::UNGROUPED_AGGREGATE:
+		return "UNGROUPED_AGGREGATE";
 	case PhysicalOperatorType::HASH_GROUP_BY:
 		return "HASH_GROUP_BY";
 	case PhysicalOperatorType::PERFECT_HASH_GROUP_BY:
@@ -58596,7 +58596,7 @@ string PhysicalPerfectHashAggregate::ParamsToString() const {
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/execution/operator/aggregate/physical_simple_aggregate.hpp
+// duckdb/execution/operator/aggregate/physical_window.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -58608,12 +58608,202 @@ string PhysicalPerfectHashAggregate::ParamsToString() const {
 
 namespace duckdb {
 
-//! PhysicalSimpleAggregate is an aggregate operator that can only perform aggregates (1) without any groups, (2)
+//! PhysicalStreamingWindow implements streaming window functions (i.e. with an empty OVER clause)
+class PhysicalStreamingWindow : public PhysicalOperator {
+public:
+	PhysicalStreamingWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
+	                        idx_t estimated_cardinality,
+	                        PhysicalOperatorType type = PhysicalOperatorType::STREAMING_WINDOW);
+
+	//! The projection list of the WINDOW statement
+	vector<unique_ptr<Expression>> select_list;
+
+public:
+	unique_ptr<GlobalOperatorState> GetGlobalOperatorState(ClientContext &context) const override;
+	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
+
+	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
+	                           GlobalOperatorState &gstate, OperatorState &state) const override;
+
+	string ParamsToString() const override;
+};
+
+} // namespace duckdb
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parallel/thread_context.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+class ClientContext;
+
+//! The ThreadContext holds thread-local info for parallel usage
+class ThreadContext {
+public:
+	explicit ThreadContext(ClientContext &context);
+
+	//! The operator profiler for the individual thread context
+	OperatorProfiler profiler;
+};
+
+} // namespace duckdb
+
+
+
+
+namespace duckdb {
+
+PhysicalStreamingWindow::PhysicalStreamingWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
+                                                 idx_t estimated_cardinality, PhysicalOperatorType type)
+    : PhysicalOperator(type, move(types), estimated_cardinality), select_list(move(select_list)) {
+}
+
+class StreamingWindowGlobalState : public GlobalOperatorState {
+public:
+	StreamingWindowGlobalState() : row_number(1) {
+	}
+
+	//! The next row number.
+	std::atomic<int64_t> row_number;
+};
+
+class StreamingWindowState : public OperatorState {
+public:
+	StreamingWindowState() : initialized(false) {
+	}
+
+	void Initialize(Allocator &allocator, DataChunk &input, const vector<unique_ptr<Expression>> &expressions) {
+		for (idx_t expr_idx = 0; expr_idx < expressions.size(); expr_idx++) {
+			auto &expr = *expressions[expr_idx];
+			switch (expr.GetExpressionType()) {
+			case ExpressionType::WINDOW_FIRST_VALUE: {
+				auto &wexpr = (BoundWindowExpression &)expr;
+
+				// Just execute the expression once
+				ExpressionExecutor executor(allocator);
+				executor.AddExpression(*wexpr.children[0]);
+				DataChunk result;
+				result.Initialize(allocator, {wexpr.children[0]->return_type});
+				executor.Execute(input, result);
+
+				const_vectors.push_back(make_unique<Vector>(result.GetValue(0, 0)));
+				break;
+			}
+			case ExpressionType::WINDOW_PERCENT_RANK: {
+				const_vectors.push_back(make_unique<Vector>(Value((double)0)));
+				break;
+			}
+			case ExpressionType::WINDOW_RANK:
+			case ExpressionType::WINDOW_RANK_DENSE: {
+				const_vectors.push_back(make_unique<Vector>(Value((int64_t)1)));
+				break;
+			}
+			default:
+				const_vectors.push_back(nullptr);
+			}
+		}
+		initialized = true;
+	}
+
+public:
+	bool initialized;
+	vector<unique_ptr<Vector>> const_vectors;
+};
+
+unique_ptr<GlobalOperatorState> PhysicalStreamingWindow::GetGlobalOperatorState(ClientContext &context) const {
+	return make_unique<StreamingWindowGlobalState>();
+}
+
+unique_ptr<OperatorState> PhysicalStreamingWindow::GetOperatorState(ExecutionContext &context) const {
+	return make_unique<StreamingWindowState>();
+}
+
+OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
+                                                    GlobalOperatorState &gstate_p, OperatorState &state_p) const {
+	auto &gstate = (StreamingWindowGlobalState &)gstate_p;
+	auto &state = (StreamingWindowState &)state_p;
+	if (!state.initialized) {
+		auto &allocator = Allocator::Get(context.client);
+		state.Initialize(allocator, input, select_list);
+	}
+	// Put payload columns in place
+	for (idx_t col_idx = 0; col_idx < input.data.size(); col_idx++) {
+		chunk.data[col_idx].Reference(input.data[col_idx]);
+	}
+	// Compute window function
+	const idx_t count = input.size();
+	for (idx_t expr_idx = 0; expr_idx < select_list.size(); expr_idx++) {
+		idx_t col_idx = input.data.size() + expr_idx;
+		auto &expr = *select_list[expr_idx];
+		switch (expr.GetExpressionType()) {
+		case ExpressionType::WINDOW_FIRST_VALUE:
+		case ExpressionType::WINDOW_PERCENT_RANK:
+		case ExpressionType::WINDOW_RANK:
+		case ExpressionType::WINDOW_RANK_DENSE: {
+			// Reference constant vector
+			chunk.data[col_idx].Reference(*state.const_vectors[expr_idx]);
+			break;
+		}
+		case ExpressionType::WINDOW_ROW_NUMBER: {
+			// Set row numbers
+			auto rdata = FlatVector::GetData<int64_t>(chunk.data[col_idx]);
+			for (idx_t i = 0; i < count; i++) {
+				rdata[i] = gstate.row_number + i;
+			}
+			break;
+		}
+		default:
+			throw NotImplementedException("%s for StreamingWindow", ExpressionTypeToString(expr.GetExpressionType()));
+		}
+	}
+	gstate.row_number += count;
+	chunk.SetCardinality(count);
+	return OperatorResultType::NEED_MORE_INPUT;
+}
+
+string PhysicalStreamingWindow::ParamsToString() const {
+	string result;
+	for (idx_t i = 0; i < select_list.size(); i++) {
+		if (i > 0) {
+			result += "\n";
+		}
+		result += select_list[i]->GetName();
+	}
+	return result;
+}
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/aggregate/physical_ungrouped_aggregate.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+//! PhysicalUngroupedAggregate is an aggregate operator that can only perform aggregates (1) without any groups, (2)
 //! without any DISTINCT aggregates, and (3) when all aggregates are combineable
-class PhysicalSimpleAggregate : public PhysicalOperator {
+class PhysicalUngroupedAggregate : public PhysicalOperator {
 public:
-	PhysicalSimpleAggregate(vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
-	                        idx_t estimated_cardinality);
+	PhysicalUngroupedAggregate(vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
+	                           idx_t estimated_cardinality);
 
 	//! The aggregates that have to be computed
 	vector<unique_ptr<Expression>> aggregates;
@@ -58654,39 +58844,15 @@ public:
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/thread_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-
-//! The ThreadContext holds thread-local info for parallel usage
-class ThreadContext {
-public:
-	explicit ThreadContext(ClientContext &context);
-
-	//! The operator profiler for the individual thread context
-	OperatorProfiler profiler;
-};
-
-} // namespace duckdb
 
 
 
 namespace duckdb {
 
-PhysicalSimpleAggregate::PhysicalSimpleAggregate(vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
-                                                 idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::SIMPLE_AGGREGATE, move(types), estimated_cardinality),
+PhysicalUngroupedAggregate::PhysicalUngroupedAggregate(vector<LogicalType> types,
+                                                       vector<unique_ptr<Expression>> expressions,
+                                                       idx_t estimated_cardinality)
+    : PhysicalOperator(PhysicalOperatorType::UNGROUPED_AGGREGATE, move(types), estimated_cardinality),
       aggregates(move(expressions)) {
 }
 
@@ -58785,16 +58951,16 @@ public:
 	AggregateFilterDataSet filter_set;
 };
 
-unique_ptr<GlobalSinkState> PhysicalSimpleAggregate::GetGlobalSinkState(ClientContext &context) const {
+unique_ptr<GlobalSinkState> PhysicalUngroupedAggregate::GetGlobalSinkState(ClientContext &context) const {
 	return make_unique<SimpleAggregateGlobalState>(aggregates);
 }
 
-unique_ptr<LocalSinkState> PhysicalSimpleAggregate::GetLocalSinkState(ExecutionContext &context) const {
+unique_ptr<LocalSinkState> PhysicalUngroupedAggregate::GetLocalSinkState(ExecutionContext &context) const {
 	return make_unique<SimpleAggregateLocalState>(Allocator::Get(context.client), aggregates, children[0]->GetTypes());
 }
 
-SinkResultType PhysicalSimpleAggregate::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                             DataChunk &input) const {
+SinkResultType PhysicalUngroupedAggregate::Sink(ExecutionContext &context, GlobalSinkState &state,
+                                                LocalSinkState &lstate, DataChunk &input) const {
 	auto &sink = (SimpleAggregateLocalState &)lstate;
 	// perform the aggregation inside the local state
 	idx_t payload_idx = 0, payload_expr_idx = 0;
@@ -58840,7 +59006,8 @@ SinkResultType PhysicalSimpleAggregate::Sink(ExecutionContext &context, GlobalSi
 //===--------------------------------------------------------------------===//
 // Finalize
 //===--------------------------------------------------------------------===//
-void PhysicalSimpleAggregate::Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const {
+void PhysicalUngroupedAggregate::Combine(ExecutionContext &context, GlobalSinkState &state,
+                                         LocalSinkState &lstate) const {
 	auto &gstate = (SimpleAggregateGlobalState &)state;
 	auto &source = (SimpleAggregateLocalState &)lstate;
 	D_ASSERT(!gstate.finished);
@@ -58866,8 +59033,8 @@ void PhysicalSimpleAggregate::Combine(ExecutionContext &context, GlobalSinkState
 	client_profiler.Flush(context.thread.profiler);
 }
 
-SinkFinalizeType PhysicalSimpleAggregate::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                   GlobalSinkState &gstate_p) const {
+SinkFinalizeType PhysicalUngroupedAggregate::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
+                                                      GlobalSinkState &gstate_p) const {
 	auto &gstate = (SimpleAggregateGlobalState &)gstate_p;
 
 	D_ASSERT(!gstate.finished);
@@ -58886,7 +59053,7 @@ public:
 	bool finished;
 };
 
-unique_ptr<GlobalSourceState> PhysicalSimpleAggregate::GetGlobalSourceState(ClientContext &context) const {
+unique_ptr<GlobalSourceState> PhysicalUngroupedAggregate::GetGlobalSourceState(ClientContext &context) const {
 	return make_unique<SimpleAggregateState>();
 }
 
@@ -58904,8 +59071,8 @@ void VerifyNullHandling(DataChunk &chunk, AggregateState &state, const vector<un
 #endif
 }
 
-void PhysicalSimpleAggregate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                                      LocalSourceState &lstate) const {
+void PhysicalUngroupedAggregate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
+                                         LocalSourceState &lstate) const {
 	auto &gstate = (SimpleAggregateGlobalState &)*sink_state;
 	auto &state = (SimpleAggregateState &)gstate_p;
 	D_ASSERT(gstate.finished);
@@ -58926,7 +59093,7 @@ void PhysicalSimpleAggregate::GetData(ExecutionContext &context, DataChunk &chun
 	state.finished = true;
 }
 
-string PhysicalSimpleAggregate::ParamsToString() const {
+string PhysicalUngroupedAggregate::ParamsToString() const {
 	string result;
 	for (idx_t i = 0; i < aggregates.size(); i++) {
 		auto &aggregate = (BoundAggregateExpression &)*aggregates[i];
@@ -58955,171 +59122,6 @@ string PhysicalSimpleAggregate::ParamsToString() const {
 
 
 
-namespace duckdb {
-
-//! PhysicalStreamingWindow implements streaming window functions (i.e. with an empty OVER clause)
-class PhysicalStreamingWindow : public PhysicalOperator {
-public:
-	PhysicalStreamingWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-	                        idx_t estimated_cardinality,
-	                        PhysicalOperatorType type = PhysicalOperatorType::STREAMING_WINDOW);
-
-	//! The projection list of the WINDOW statement
-	vector<unique_ptr<Expression>> select_list;
-
-public:
-	unique_ptr<GlobalOperatorState> GetGlobalOperatorState(ClientContext &context) const override;
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	string ParamsToString() const override;
-};
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalStreamingWindow::PhysicalStreamingWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-                                                 idx_t estimated_cardinality, PhysicalOperatorType type)
-    : PhysicalOperator(type, move(types), estimated_cardinality), select_list(move(select_list)) {
-}
-
-class StreamingWindowGlobalState : public GlobalOperatorState {
-public:
-	StreamingWindowGlobalState() : row_number(1) {
-	}
-
-	//! The next row number.
-	std::atomic<int64_t> row_number;
-};
-
-class StreamingWindowState : public OperatorState {
-public:
-	StreamingWindowState() : initialized(false) {
-	}
-
-	void Initialize(Allocator &allocator, DataChunk &input, const vector<unique_ptr<Expression>> &expressions) {
-		for (idx_t expr_idx = 0; expr_idx < expressions.size(); expr_idx++) {
-			auto &expr = *expressions[expr_idx];
-			switch (expr.GetExpressionType()) {
-			case ExpressionType::WINDOW_FIRST_VALUE: {
-				auto &wexpr = (BoundWindowExpression &)expr;
-
-				// Just execute the expression once
-				ExpressionExecutor executor(allocator);
-				executor.AddExpression(*wexpr.children[0]);
-				DataChunk result;
-				result.Initialize(allocator, {wexpr.children[0]->return_type});
-				executor.Execute(input, result);
-
-				const_vectors.push_back(make_unique<Vector>(result.GetValue(0, 0)));
-				break;
-			}
-			case ExpressionType::WINDOW_PERCENT_RANK: {
-				const_vectors.push_back(make_unique<Vector>(Value((double)0)));
-				break;
-			}
-			case ExpressionType::WINDOW_RANK:
-			case ExpressionType::WINDOW_RANK_DENSE: {
-				const_vectors.push_back(make_unique<Vector>(Value((int64_t)1)));
-				break;
-			}
-			default:
-				const_vectors.push_back(nullptr);
-			}
-		}
-		initialized = true;
-	}
-
-public:
-	bool initialized;
-	vector<unique_ptr<Vector>> const_vectors;
-};
-
-unique_ptr<GlobalOperatorState> PhysicalStreamingWindow::GetGlobalOperatorState(ClientContext &context) const {
-	return make_unique<StreamingWindowGlobalState>();
-}
-
-unique_ptr<OperatorState> PhysicalStreamingWindow::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<StreamingWindowState>();
-}
-
-OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                    GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &gstate = (StreamingWindowGlobalState &)gstate_p;
-	auto &state = (StreamingWindowState &)state_p;
-	if (!state.initialized) {
-		auto &allocator = Allocator::Get(context.client);
-		state.Initialize(allocator, input, select_list);
-	}
-	// Put payload columns in place
-	for (idx_t col_idx = 0; col_idx < input.data.size(); col_idx++) {
-		chunk.data[col_idx].Reference(input.data[col_idx]);
-	}
-	// Compute window function
-	const idx_t count = input.size();
-	for (idx_t expr_idx = 0; expr_idx < select_list.size(); expr_idx++) {
-		idx_t col_idx = input.data.size() + expr_idx;
-		auto &expr = *select_list[expr_idx];
-		switch (expr.GetExpressionType()) {
-		case ExpressionType::WINDOW_FIRST_VALUE:
-		case ExpressionType::WINDOW_PERCENT_RANK:
-		case ExpressionType::WINDOW_RANK:
-		case ExpressionType::WINDOW_RANK_DENSE: {
-			// Reference constant vector
-			chunk.data[col_idx].Reference(*state.const_vectors[expr_idx]);
-			break;
-		}
-		case ExpressionType::WINDOW_ROW_NUMBER: {
-			// Set row numbers
-			auto rdata = FlatVector::GetData<int64_t>(chunk.data[col_idx]);
-			for (idx_t i = 0; i < count; i++) {
-				rdata[i] = gstate.row_number + i;
-			}
-			break;
-		}
-		default:
-			throw NotImplementedException("%s for StreamingWindow", ExpressionTypeToString(expr.GetExpressionType()));
-		}
-	}
-	gstate.row_number += count;
-	chunk.SetCardinality(count);
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-string PhysicalStreamingWindow::ParamsToString() const {
-	string result;
-	for (idx_t i = 0; i < select_list.size(); i++) {
-		if (i > 0) {
-			result += "\n";
-		}
-		result += select_list[i]->GetName();
-	}
-	return result;
-}
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/physical_window.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
 
 namespace duckdb {
 
@@ -60301,34 +60303,41 @@ static void ComputeWindowExpression(BoundWindowExpression *wexpr, ChunkCollectio
 		}
 		case ExpressionType::WINDOW_NTILE: {
 			D_ASSERT(payload_collection.ColumnCount() == 1);
-			auto n_param = GetCell<int64_t>(payload_collection, 0, row_idx);
-			// With thanks from SQLite's ntileValueFunc()
-			int64_t n_total = bounds.partition_end - bounds.partition_start;
-			if (n_param > n_total) {
-				// more groups allowed than we have values
-				// map every entry to a unique group
-				n_param = n_total;
-			}
-			int64_t n_size = (n_total / n_param);
-			// find the row idx within the group
-			D_ASSERT(row_idx >= bounds.partition_start);
-			int64_t adjusted_row_idx = row_idx - bounds.partition_start;
-			// now compute the ntile
-			int64_t n_large = n_total - n_param * n_size;
-			int64_t i_small = n_large * (n_size + 1);
-			int64_t result_ntile;
-
-			D_ASSERT((n_large * (n_size + 1) + (n_param - n_large) * n_size) == n_total);
-
-			if (adjusted_row_idx < i_small) {
-				result_ntile = 1 + adjusted_row_idx / (n_size + 1);
+			if (CellIsNull(payload_collection, 0, row_idx)) {
+				FlatVector::SetNull(result, output_offset, true);
 			} else {
-				result_ntile = 1 + n_large + (adjusted_row_idx - i_small) / n_size;
+				auto n_param = GetCell<int64_t>(payload_collection, 0, row_idx);
+				if (n_param < 1) {
+					throw InvalidInputException("Argument for ntile must be greater than zero");
+				}
+				// With thanks from SQLite's ntileValueFunc()
+				int64_t n_total = bounds.partition_end - bounds.partition_start;
+				if (n_param > n_total) {
+					// more groups allowed than we have values
+					// map every entry to a unique group
+					n_param = n_total;
+				}
+				int64_t n_size = (n_total / n_param);
+				// find the row idx within the group
+				D_ASSERT(row_idx >= bounds.partition_start);
+				int64_t adjusted_row_idx = row_idx - bounds.partition_start;
+				// now compute the ntile
+				int64_t n_large = n_total - n_param * n_size;
+				int64_t i_small = n_large * (n_size + 1);
+				int64_t result_ntile;
+
+				D_ASSERT((n_large * (n_size + 1) + (n_param - n_large) * n_size) == n_total);
+
+				if (adjusted_row_idx < i_small) {
+					result_ntile = 1 + adjusted_row_idx / (n_size + 1);
+				} else {
+					result_ntile = 1 + n_large + (adjusted_row_idx - i_small) / n_size;
+				}
+				// result has to be between [1, NTILE]
+				D_ASSERT(result_ntile >= 1 && result_ntile <= n_param);
+				auto rdata = FlatVector::GetData<int64_t>(result);
+				rdata[output_offset] = result_ntile;
 			}
-			// result has to be between [1, NTILE]
-			D_ASSERT(result_ntile >= 1 && result_ntile <= n_param);
-			auto rdata = FlatVector::GetData<int64_t>(result);
-			rdata[output_offset] = result_ntile;
 			break;
 		}
 		case ExpressionType::WINDOW_LEAD:
@@ -74763,8 +74772,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAggregate
 			}
 		}
 		if (use_simple_aggregation) {
-			groupby = make_unique_base<PhysicalOperator, PhysicalSimpleAggregate>(op.types, move(op.expressions),
-			                                                                      op.estimated_cardinality);
+			groupby = make_unique_base<PhysicalOperator, PhysicalUngroupedAggregate>(op.types, move(op.expressions),
+			                                                                         op.estimated_cardinality);
 		} else {
 			groupby = make_unique_base<PhysicalOperator, PhysicalHashAggregate>(context, op.types, move(op.expressions),
 			                                                                    op.estimated_cardinality);
@@ -127308,7 +127317,7 @@ bool QueryProfiler::OperatorRequiresProfiling(PhysicalOperatorType op_type) {
 	case PhysicalOperatorType::TOP_N:
 	case PhysicalOperatorType::WINDOW:
 	case PhysicalOperatorType::UNNEST:
-	case PhysicalOperatorType::SIMPLE_AGGREGATE:
+	case PhysicalOperatorType::UNGROUPED_AGGREGATE:
 	case PhysicalOperatorType::HASH_GROUP_BY:
 	case PhysicalOperatorType::FILTER:
 	case PhysicalOperatorType::PROJECTION:

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 "57b41d277"
-#define DUCKDB_VERSION "v0.4.1-dev452"
+#define DUCKDB_SOURCE_ID "f5be5d58a"
+#define DUCKDB_VERSION "v0.4.1-dev464"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -10544,7 +10544,7 @@ enum class PhysicalOperatorType : uint8_t {
 	TOP_N,
 	WINDOW,
 	UNNEST,
-	SIMPLE_AGGREGATE,
+	UNGROUPED_AGGREGATE,
 	HASH_GROUP_BY,
 	PERFECT_HASH_GROUP_BY,
 	FILTER,