duckdb 0.3.2-dev668.0 → 0.3.2-dev679.0

package/package.json

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

package/src/duckdb.cpp

@@ -8540,6 +8540,8 @@ string PhysicalOperatorToString(PhysicalOperatorType type) {
 		return "TOP_N";
 	case PhysicalOperatorType::WINDOW:
 		return "WINDOW";
+	case PhysicalOperatorType::STREAMING_WINDOW:
+		return "STREAMING_WINDOW";
 	case PhysicalOperatorType::UNNEST:
 		return "UNNEST";
 	case PhysicalOperatorType::SIMPLE_AGGREGATE:
@@ -52691,6 +52693,149 @@ 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<OperatorState> GetOperatorState(ClientContext &context) const override;
+
+	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
+	                           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 StreamingWindowState : public OperatorState {
+public:
+	StreamingWindowState() : initialized(false), row_number(1) {
+	}
+
+	void Initialize(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;
+				auto &ref = (BoundReferenceExpression &)*wexpr.children[0];
+				const_vectors.push_back(make_unique<Vector>(input.data[ref.index].GetValue(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;
+	int64_t row_number;
+	vector<unique_ptr<Vector>> const_vectors;
+};
+
+unique_ptr<OperatorState> PhysicalStreamingWindow::GetOperatorState(ClientContext &context) const {
+	return make_unique<StreamingWindowState>();
+}
+
+OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
+                                                    OperatorState &state_p) const {
+	auto &state = (StreamingWindowState &)state_p;
+	if (!state.initialized) {
+		state.Initialize(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] = state.row_number + i;
+			}
+			break;
+		}
+		default:
+			throw NotImplementedException("%s for StreamingWindow", ExpressionTypeToString(expr.GetExpressionType()));
+		}
+	}
+	state.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 {
 
@@ -68409,6 +68554,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUpdate &op
 
 
 
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -68442,12 +68590,28 @@ protected:
 } // namespace duckdb
 
 
-
-
 #include <numeric>
 
 namespace duckdb {
 
+static bool IsStreamingWindow(unique_ptr<Expression> &expr) {
+	auto wexpr = reinterpret_cast<BoundWindowExpression *>(expr.get());
+	if (!wexpr->partitions.empty() || !wexpr->orders.empty() || wexpr->ignore_nulls) {
+		return false;
+	}
+	switch (wexpr->type) {
+	// TODO: add more expression types here?
+	case ExpressionType::WINDOW_FIRST_VALUE:
+	case ExpressionType::WINDOW_PERCENT_RANK:
+	case ExpressionType::WINDOW_RANK:
+	case ExpressionType::WINDOW_RANK_DENSE:
+	case ExpressionType::WINDOW_ROW_NUMBER:
+		return true;
+	default:
+		return false;
+	}
+}
+
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalWindow &op) {
 	D_ASSERT(op.children.size() == 1);
 
@@ -68463,11 +68627,23 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalWindow &op
 	const auto output_idx = types.size() - op.expressions.size();
 	types.resize(output_idx);
 
+	// Identify streaming windows
+	vector<idx_t> blocking_windows;
+	vector<idx_t> streaming_windows;
+	for (idx_t expr_idx = 0; expr_idx < op.expressions.size(); expr_idx++) {
+		if (IsStreamingWindow(op.expressions[expr_idx])) {
+			streaming_windows.push_back(expr_idx);
+		} else {
+			blocking_windows.push_back(expr_idx);
+		}
+	}
+
 	// Process the window functions by sharing the partition/order definitions
 	vector<idx_t> evaluation_order;
-	vector<idx_t> remaining(op.expressions.size());
-	std::iota(remaining.begin(), remaining.end(), 0);
-	while (!remaining.empty()) {
+	while (!blocking_windows.empty() || !streaming_windows.empty()) {
+		const bool process_streaming = blocking_windows.empty();
+		auto &remaining = process_streaming ? streaming_windows : blocking_windows;
+
 		// Find all functions that share the partitioning of the first remaining expression
 		const auto over_idx = remaining[0];
 		auto over_expr = reinterpret_cast<BoundWindowExpression *>(op.expressions[over_idx].get());
@@ -68493,7 +68669,12 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalWindow &op
 		}
 
 		// Chain the new window operator on top of the plan
-		auto window = make_unique<PhysicalWindow>(types, move(select_list), op.estimated_cardinality);
+		unique_ptr<PhysicalOperator> window;
+		if (process_streaming) {
+			window = make_unique<PhysicalStreamingWindow>(types, move(select_list), op.estimated_cardinality);
+		} else {
+			window = make_unique<PhysicalWindow>(types, move(select_list), op.estimated_cardinality);
+		}
 		window->children.push_back(move(plan));
 		plan = move(window);
 

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 "a5e6d9bd4"
-#define DUCKDB_VERSION "0.3.2-dev668"
+#define DUCKDB_SOURCE_ID "000fbffa3"
+#define DUCKDB_VERSION "0.3.2-dev679"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -5382,11 +5382,11 @@ public:
 	}
 
 	//! Returns the type of the expression
-	ExpressionType GetExpressionType() {
+	ExpressionType GetExpressionType() const {
 		return type;
 	}
 	//! Returns the class of the expression
-	ExpressionClass GetExpressionClass() {
+	ExpressionClass GetExpressionClass() const {
 		return expression_class;
 	}
 
@@ -9187,6 +9187,7 @@ enum class PhysicalOperatorType : uint8_t {
 	COPY_TO_FILE,
 	RESERVOIR_SAMPLE,
 	STREAMING_SAMPLE,
+	STREAMING_WINDOW,
 	// -----------------------------
 	// Scans
 	// -----------------------------