duckdb 0.3.5-dev653.0 → 0.3.5-dev658.0

package/package.json

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

package/src/duckdb.cpp

@@ -59077,7 +59077,7 @@ public:
 	using FrameBounds = std::pair<idx_t, idx_t>;
 
 	WindowSegmentTree(AggregateFunction &aggregate, FunctionData *bind_info, const LogicalType &result_type,
-	                  ChunkCollection *input, WindowAggregationMode mode);
+	                  ChunkCollection *input, const ValidityMask &filter_mask, WindowAggregationMode mode);
 	~WindowSegmentTree();
 
 	//! First row contains the result.
@@ -59110,6 +59110,8 @@ private:
 	vector<data_t> state;
 	//! Input data chunk, used for intermediate window segment aggregation
 	DataChunk inputs;
+	//! The filtered rows in inputs.
+	SelectionVector filter_sel;
 	//! A vector of pointers to "state", used for intermediate window segment aggregation
 	Vector statep;
 	//! The frame boundaries, used for the window functions
@@ -59130,6 +59132,9 @@ private:
 	//! The (sorted) input chunk collection on which the tree is built
 	ChunkCollection *input_ref;
 
+	//! The filtered rows in input_ref.
+	const ValidityMask &filter_mask;
+
 	//! Use the window API, if available
 	WindowAggregationMode mode;
 
@@ -60032,6 +60037,25 @@ static void ComputeWindowExpression(BoundWindowExpression *wexpr, ChunkCollectio
 		}
 	}
 
+	// evaluate the FILTER clause and stuff it into a large mask for compactness and reuse
+	ValidityMask filter_mask;
+	vector<validity_t> filter_bits;
+	if (wexpr->filter_expr) {
+		// 	Start with all invalid and set the ones that pass
+		filter_bits.resize(ValidityMask::ValidityMaskSize(input.Count()), 0);
+		filter_mask.Initialize(filter_bits.data());
+		ExpressionExecutor filter_execution(*wexpr->filter_expr);
+		SelectionVector true_sel(STANDARD_VECTOR_SIZE);
+		idx_t base_idx = 0;
+		for (auto &chunk : input.Chunks()) {
+			const auto filtered = filter_execution.SelectExpression(*chunk, true_sel);
+			for (idx_t f = 0; f < filtered; ++f) {
+				filter_mask.SetValid(base_idx + true_sel[f]);
+			}
+			base_idx += chunk->size();
+		}
+	}
+
 	// evaluate boundaries if present. Parser has checked boundary types.
 	ChunkCollection boundary_start_collection;
 	if (wexpr->start_expr) {
@@ -60085,7 +60109,7 @@ static void ComputeWindowExpression(BoundWindowExpression *wexpr, ChunkCollectio
 
 	if (wexpr->aggregate) {
 		segment_tree = make_unique<WindowSegmentTree>(*(wexpr->aggregate), wexpr->bind_info.get(), wexpr->return_type,
-		                                              &payload_collection, mode);
+		                                              &payload_collection, filter_mask, mode);
 	}
 
 	WindowBoundariesState bounds(wexpr);
@@ -78692,10 +78716,11 @@ namespace duckdb {
 
 WindowSegmentTree::WindowSegmentTree(AggregateFunction &aggregate, FunctionData *bind_info,
                                      const LogicalType &result_type_p, ChunkCollection *input,
-                                     WindowAggregationMode mode_p)
+                                     const ValidityMask &filter_mask_p, WindowAggregationMode mode_p)
     : aggregate(aggregate), bind_info(bind_info), result_type(result_type_p), state(aggregate.state_size()),
       statep(Value::POINTER((idx_t)state.data())), frame(0, 0), active(0, 1),
-      statev(Value::POINTER((idx_t)state.data())), internal_nodes(0), input_ref(input), mode(mode_p) {
+      statev(Value::POINTER((idx_t)state.data())), internal_nodes(0), input_ref(input), filter_mask(filter_mask_p),
+      mode(mode_p) {
 #if STANDARD_VECTOR_SIZE < 512
 	throw NotImplementedException("Window functions are not supported for vector sizes < 512");
 #endif
@@ -78703,6 +78728,7 @@ WindowSegmentTree::WindowSegmentTree(AggregateFunction &aggregate, FunctionData
 	statev.SetVectorType(VectorType::FLAT_VECTOR); // Prevent conversion of results to constants
 
 	if (input_ref && input_ref->ColumnCount() > 0) {
+		filter_sel.Initialize(STANDARD_VECTOR_SIZE);
 		inputs.Initialize(input_ref->Types());
 		// if we have a frame-by-frame method, share the single state
 		if (aggregate.window && UseWindowAPI()) {
@@ -78783,6 +78809,19 @@ void WindowSegmentTree::ExtractFrame(idx_t begin, idx_t end) {
 			VectorOperations::Copy(chunk_b.data[i], v, chunk_b_count, 0, chunk_a_count);
 		}
 	}
+
+	// Slice to any filtered rows
+	if (!filter_mask.AllValid()) {
+		idx_t filtered = 0;
+		for (idx_t i = begin; i < end; ++i) {
+			if (filter_mask.RowIsValid(i)) {
+				filter_sel.set_index(filtered++, i - begin);
+			}
+		}
+		if (filtered != inputs.size()) {
+			inputs.Slice(filter_sel, filtered);
+		}
+	}
 }
 
 void WindowSegmentTree::WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end) {
@@ -78863,7 +78902,16 @@ void WindowSegmentTree::Compute(Vector &result, idx_t rid, idx_t begin, idx_t en
 	if (inputs.ColumnCount() == 0) {
 		D_ASSERT(GetTypeIdSize(result_type.InternalType()) == sizeof(idx_t));
 		auto data = FlatVector::GetData<idx_t>(result);
-		data[rid] = end - begin;
+		// Slice to any filtered rows
+		if (!filter_mask.AllValid()) {
+			idx_t filtered = 0;
+			for (idx_t i = begin; i < end; ++i) {
+				filtered += filter_mask.RowIsValid(i);
+			}
+			data[rid] = filtered;
+		} else {
+			data[rid] = end - begin;
+		}
 		return;
 	}
 
@@ -78904,8 +78952,8 @@ void WindowSegmentTree::Compute(Vector &result, idx_t rid, idx_t begin, idx_t en
 		active = FrameBounds(active_chunks.first * STANDARD_VECTOR_SIZE,
 		                     MinValue((active_chunks.second + 1) * STANDARD_VECTOR_SIZE, coll.Count()));
 
-		aggregate.window(inputs.data.data(), bind_info, inputs.ColumnCount(), state.data(), frame, prev, result, rid,
-		                 active.first);
+		aggregate.window(inputs.data.data(), filter_mask, bind_info, inputs.ColumnCount(), state.data(), frame, prev,
+		                 result, rid, active.first);
 		return;
 	}
 
@@ -83436,6 +83484,19 @@ struct ModeState {
 	}
 };
 
+struct ModeIncluded {
+	inline explicit ModeIncluded(const ValidityMask &fmask_p, const ValidityMask &dmask_p, idx_t bias_p)
+	    : fmask(fmask_p), dmask(dmask_p), bias(bias_p) {
+	}
+
+	inline bool operator()(const idx_t &idx) const {
+		return fmask.RowIsValid(idx) && dmask.RowIsValid(idx - bias);
+	}
+	const ValidityMask &fmask;
+	const ValidityMask &dmask;
+	const idx_t bias;
+};
+
 template <typename KEY_TYPE>
 struct ModeFunction {
 	template <class STATE>
@@ -83492,11 +83553,14 @@ struct ModeFunction {
 	}
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
-	static void Window(const INPUT_TYPE *data, const ValidityMask &dmask, FunctionData *bind_data_p, STATE *state,
-	                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid, idx_t bias) {
+	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
+	                   FunctionData *bind_data_p, STATE *state, const FrameBounds &frame, const FrameBounds &prev,
+	                   Vector &result, idx_t rid, idx_t bias) {
 		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
 		auto &rmask = FlatVector::Validity(result);
 
+		ModeIncluded included(fmask, dmask, bias);
+
 		if (!state->frequency_map) {
 			state->frequency_map = new unordered_map<KEY_TYPE, size_t>();
 		}
@@ -83505,31 +83569,31 @@ struct ModeFunction {
 			state->Reset();
 			// for f ∈ F do
 			for (auto f = frame.first; f < frame.second; ++f) {
-				if (dmask.RowIsValid(f - bias)) {
+				if (included(f)) {
 					state->ModeAdd(KEY_TYPE(data[f]));
 				}
 			}
 		} else {
 			// for f ∈ P \ F do
 			for (auto p = prev.first; p < frame.first; ++p) {
-				if (dmask.RowIsValid(p - bias)) {
+				if (included(p)) {
 					state->ModeRm(KEY_TYPE(data[p]));
 				}
 			}
 			for (auto p = frame.second; p < prev.second; ++p) {
-				if (dmask.RowIsValid(p - bias)) {
+				if (included(p)) {
 					state->ModeRm(KEY_TYPE(data[p]));
 				}
 			}
 
 			// for f ∈ F \ P do
 			for (auto f = frame.first; f < prev.first; ++f) {
-				if (dmask.RowIsValid(f - bias)) {
+				if (included(f)) {
 					state->ModeAdd(KEY_TYPE(data[f]));
 				}
 			}
 			for (auto f = prev.second; f < frame.second; ++f) {
-				if (dmask.RowIsValid(f - bias)) {
+				if (included(f)) {
 					state->ModeAdd(KEY_TYPE(data[f]));
 				}
 			}
@@ -83744,14 +83808,21 @@ struct QuantileState {
 	}
 };
 
-struct QuantileNotNull {
-	inline explicit QuantileNotNull(const ValidityMask &mask_p, idx_t bias_p) : mask(mask_p), bias(bias_p) {
+struct QuantileIncluded {
+	inline explicit QuantileIncluded(const ValidityMask &fmask_p, const ValidityMask &dmask_p, idx_t bias_p)
+	    : fmask(fmask_p), dmask(dmask_p), bias(bias_p) {
 	}
 
 	inline bool operator()(const idx_t &idx) const {
-		return mask.RowIsValid(idx - bias);
+		return fmask.RowIsValid(idx) && dmask.RowIsValid(idx - bias);
+	}
+
+	inline bool AllValid() const {
+		return fmask.AllValid() && dmask.AllValid();
 	}
-	const ValidityMask &mask;
+
+	const ValidityMask &fmask;
+	const ValidityMask &dmask;
 	const idx_t bias;
 };
 
@@ -83811,7 +83882,7 @@ static idx_t ReplaceIndex(idx_t *index, const FrameBounds &frame, const FrameBou
 
 template <class INPUT_TYPE>
 static inline int CanReplace(const idx_t *index, const INPUT_TYPE *fdata, const idx_t j, const idx_t k0, const idx_t k1,
-                             const QuantileNotNull &validity) {
+                             const QuantileIncluded &validity) {
 	D_ASSERT(index);
 
 	// NULLs sort to the end, so if we have inserted a NULL,
@@ -84142,12 +84213,13 @@ struct QuantileScalarOperation : public QuantileOperation {
 	}
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
-	static void Window(const INPUT_TYPE *data, const ValidityMask &dmask, FunctionData *bind_data_p, STATE *state,
-	                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t ridx, idx_t bias) {
+	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
+	                   FunctionData *bind_data_p, STATE *state, const FrameBounds &frame, const FrameBounds &prev,
+	                   Vector &result, idx_t ridx, idx_t bias) {
 		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
 		auto &rmask = FlatVector::Validity(result);
 
-		QuantileNotNull not_null(dmask, bias);
+		QuantileIncluded included(fmask, dmask, bias);
 
 		//  Lazily initialise frame state
 		auto prev_pos = state->pos;
@@ -84167,9 +84239,9 @@ struct QuantileScalarOperation : public QuantileOperation {
 			//  Fixed frame size
 			const auto j = ReplaceIndex(index, frame, prev);
 			//	We can only replace if the number of NULLs has not changed
-			if (dmask.AllValid() || not_null(prev.first) == not_null(prev.second)) {
+			if (included.AllValid() || included(prev.first) == included(prev.second)) {
 				Interpolator<DISCRETE> interp(q, prev_pos);
-				replace = CanReplace(index, data, j, interp.FRN, interp.CRN, not_null);
+				replace = CanReplace(index, data, j, interp.FRN, interp.CRN, included);
 				if (replace) {
 					state->pos = prev_pos;
 				}
@@ -84178,9 +84250,9 @@ struct QuantileScalarOperation : public QuantileOperation {
 			ReuseIndexes(index, frame, prev);
 		}
 
-		if (!replace && !dmask.AllValid()) {
+		if (!replace && !included.AllValid()) {
 			// Remove the NULLs
-			state->pos = std::partition(index, index + state->pos, not_null) - index;
+			state->pos = std::partition(index, index + state->pos, included) - index;
 		}
 		if (state->pos) {
 			Interpolator<DISCRETE> interp(q, state->pos);
@@ -84293,12 +84365,13 @@ struct QuantileListOperation : public QuantileOperation {
 	}
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
-	static void Window(const INPUT_TYPE *data, const ValidityMask &dmask, FunctionData *bind_data_p, STATE *state,
-	                   const FrameBounds &frame, const FrameBounds &prev, Vector &list, idx_t lidx, idx_t bias) {
+	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
+	                   FunctionData *bind_data_p, STATE *state, const FrameBounds &frame, const FrameBounds &prev,
+	                   Vector &list, idx_t lidx, idx_t bias) {
 		D_ASSERT(bind_data_p);
 		auto bind_data = (QuantileBindData *)bind_data_p;
 
-		QuantileNotNull not_null(dmask, bias);
+		QuantileIncluded included(fmask, dmask, bias);
 
 		// Result is a constant LIST<RESULT_TYPE> with a fixed length
 		auto ldata = FlatVector::GetData<RESULT_TYPE>(list);
@@ -84329,11 +84402,11 @@ struct QuantileListOperation : public QuantileOperation {
 			//  Fixed frame size
 			const auto j = ReplaceIndex(index, frame, prev);
 			//	We can only replace if the number of NULLs has not changed
-			if (dmask.AllValid() || not_null(prev.first) == not_null(prev.second)) {
+			if (included.AllValid() || included(prev.first) == included(prev.second)) {
 				for (const auto &q : bind_data->order) {
 					const auto &quantile = bind_data->quantiles[q];
 					Interpolator<DISCRETE> interp(quantile, prev_pos);
-					const auto replace = CanReplace(index, data, j, interp.FRN, interp.CRN, not_null);
+					const auto replace = CanReplace(index, data, j, interp.FRN, interp.CRN, included);
 					if (replace < 0) {
 						//	Replacement is before this quantile, so the rest will be replaceable too.
 						replaceable.first = MinValue(replaceable.first, interp.FRN);
@@ -84353,9 +84426,9 @@ struct QuantileListOperation : public QuantileOperation {
 			ReuseIndexes(index, frame, prev);
 		}
 
-		if (replaceable.first >= replaceable.second && !dmask.AllValid()) {
+		if (replaceable.first >= replaceable.second && !included.AllValid()) {
 			// Remove the NULLs
-			state->pos = std::partition(index, index + state->pos, not_null) - index;
+			state->pos = std::partition(index, index + state->pos, included) - index;
 		}
 
 		if (state->pos) {
@@ -84652,12 +84725,13 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 	}
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
-	static void Window(const INPUT_TYPE *data, const ValidityMask &dmask, FunctionData *bind_data_p, STATE *state,
-	                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t ridx, idx_t bias) {
+	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
+	                   FunctionData *bind_data_p, STATE *state, const FrameBounds &frame, const FrameBounds &prev,
+	                   Vector &result, idx_t ridx, idx_t bias) {
 		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
 		auto &rmask = FlatVector::Validity(result);
 
-		QuantileNotNull not_null(dmask, bias);
+		QuantileIncluded included(fmask, dmask, bias);
 
 		//  Lazily initialise frame state
 		auto prev_pos = state->pos;
@@ -84678,7 +84752,7 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 		// the median has changed, the previous order is not correct.
 		// It is probably close, however, and so reuse is helpful.
 		ReuseIndexes(index2, frame, prev);
-		std::partition(index2, index2 + state->pos, not_null);
+		std::partition(index2, index2 + state->pos, included);
 
 		// Find the two positions needed for the median
 		const float q = 0.5;
@@ -84687,10 +84761,10 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 		if (frame.first == prev.first + 1 && frame.second == prev.second + 1) {
 			//  Fixed frame size
 			const auto j = ReplaceIndex(index, frame, prev);
-			//	We can only replace if the number of NULls has not changed
-			if (dmask.AllValid() || not_null(prev.first) == not_null(prev.second)) {
+			//	We can only replace if the number of NULLs has not changed
+			if (included.AllValid() || included(prev.first) == included(prev.second)) {
 				Interpolator<false> interp(q, prev_pos);
-				replace = CanReplace(index, data, j, interp.FRN, interp.CRN, not_null);
+				replace = CanReplace(index, data, j, interp.FRN, interp.CRN, included);
 				if (replace) {
 					state->pos = prev_pos;
 				}
@@ -84699,9 +84773,9 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 			ReuseIndexes(index, frame, prev);
 		}
 
-		if (!replace && !dmask.AllValid()) {
+		if (!replace && !included.AllValid()) {
 			// Remove the NULLs
-			state->pos = std::partition(index, index + state->pos, not_null) - index;
+			state->pos = std::partition(index, index + state->pos, included) - index;
 		}
 
 		if (state->pos) {
@@ -145925,6 +145999,11 @@ bool WindowExpression::Equals(const WindowExpression *a, const WindowExpression
 			return false;
 		}
 	}
+	// check if the filter clauses are equivalent
+	if (!BaseExpression::Equals(a->filter_expr.get(), b->filter_expr.get())) {
+		return false;
+	}
+
 	return true;
 }
 
@@ -145944,6 +146023,8 @@ unique_ptr<ParsedExpression> WindowExpression::Copy() const {
 		new_window->orders.emplace_back(o.type, o.null_order, o.expression->Copy());
 	}
 
+	new_window->filter_expr = filter_expr ? filter_expr->Copy() : nullptr;
+
 	new_window->start = start;
 	new_window->end = end;
 	new_window->start_expr = start_expr ? start_expr->Copy() : nullptr;
@@ -145976,6 +146057,7 @@ void WindowExpression::Serialize(FieldWriter &writer) const {
 	writer.WriteOptional(offset_expr);
 	writer.WriteOptional(default_expr);
 	writer.WriteField<bool>(ignore_nulls);
+	writer.WriteOptional(filter_expr);
 }
 
 unique_ptr<ParsedExpression> WindowExpression::Deserialize(ExpressionType type, FieldReader &reader) {
@@ -145998,6 +146080,7 @@ unique_ptr<ParsedExpression> WindowExpression::Deserialize(ExpressionType type,
 	expr->offset_expr = reader.ReadOptional<ParsedExpression>(nullptr);
 	expr->default_expr = reader.ReadOptional<ParsedExpression>(nullptr);
 	expr->ignore_nulls = reader.ReadRequired<bool>();
+	expr->filter_expr = reader.ReadOptional<ParsedExpression>(nullptr);
 	return move(expr);
 }
 
@@ -146860,6 +146943,9 @@ void ParsedExpressionIterator::EnumerateChildren(
 		for (auto &child : window_expr.children) {
 			callback(child);
 		}
+		if (window_expr.filter_expr) {
+			callback(window_expr.filter_expr);
+		}
 		if (window_expr.start_expr) {
 			callback(window_expr.start_expr);
 		}
@@ -155446,6 +155532,11 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 	auto lowercase_name = StringUtil::Lower(function_name);
 
 	if (root->over) {
+		const auto win_fun_type = WindowToExpressionType(lowercase_name);
+		if (win_fun_type == ExpressionType::INVALID) {
+			throw InternalException("Unknown/unsupported window function");
+		}
+
 		if (root->agg_distinct) {
 			throw ParserException("DISTINCT is not implemented for window functions!");
 		}
@@ -155454,18 +155545,13 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			throw ParserException("ORDER BY is not implemented for window functions!");
 		}
 
-		if (root->agg_filter) {
-			throw ParserException("FILTER is not implemented for window functions!");
+		if (win_fun_type != ExpressionType::WINDOW_AGGREGATE && root->agg_filter) {
+			throw ParserException("FILTER is not implemented for non-aggregate window functions!");
 		}
 		if (root->export_state) {
 			throw ParserException("EXPORT_STATE is not supported for window functions!");
 		}
 
-		const auto win_fun_type = WindowToExpressionType(lowercase_name);
-		if (win_fun_type == ExpressionType::INVALID) {
-			throw InternalException("Unknown/unsupported window function");
-		}
-
 		if (win_fun_type == ExpressionType::WINDOW_AGGREGATE && root->agg_ignore_nulls) {
 			throw ParserException("IGNORE NULLS is not supported for windowed aggregates");
 		}
@@ -155473,6 +155559,11 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		auto expr = make_unique<WindowExpression>(win_fun_type, schema, lowercase_name);
 		expr->ignore_nulls = root->agg_ignore_nulls;
 
+		if (root->agg_filter) {
+			auto filter_expr = TransformExpression(root->agg_filter);
+			expr->filter_expr = move(filter_expr);
+		}
+
 		if (root->args) {
 			vector<unique_ptr<ParsedExpression>> function_list;
 			TransformExpressionList(*root->args, function_list);
@@ -161727,6 +161818,7 @@ BindResult SelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	for (auto &order : window.orders) {
 		BindChild(order.expression, depth, error);
 	}
+	BindChild(window.filter_expr, depth, error);
 	BindChild(window.start_expr, depth, error);
 	BindChild(window.end_expr, depth, error);
 	BindChild(window.offset_expr, depth, error);
@@ -161860,6 +161952,8 @@ BindResult SelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 		result->orders.emplace_back(type, null_order, move(expression));
 	}
 
+	result->filter_expr = CastWindowExpression(window.filter_expr, LogicalType::BOOLEAN);
+
 	result->start_expr = CastWindowExpression(window.start_expr, start_type);
 	result->end_expr = CastWindowExpression(window.end_expr, end_type);
 	result->offset_expr = CastWindowExpression(window.offset_expr, LogicalType::BIGINT);
@@ -168164,6 +168258,11 @@ bool BoundWindowExpression::Equals(const BaseExpression *other_p) const {
 			return false;
 		}
 	}
+	// check if the filter expressions are equivalent
+	if (!Expression::Equals(filter_expr.get(), other->filter_expr.get())) {
+		return false;
+	}
+
 	// check if the framing expressions are equivalent
 	if (!Expression::Equals(start_expr.get(), other->start_expr.get()) ||
 	    !Expression::Equals(end_expr.get(), other->end_expr.get()) ||
@@ -168228,6 +168327,8 @@ unique_ptr<Expression> BoundWindowExpression::Copy() {
 		new_window->orders.emplace_back(o.type, o.null_order, o.expression->Copy());
 	}
 
+	new_window->filter_expr = filter_expr ? filter_expr->Copy() : nullptr;
+
 	new_window->start = start;
 	new_window->end = end;
 	new_window->start_expr = start_expr ? start_expr->Copy() : nullptr;
@@ -169468,6 +169569,9 @@ void ExpressionIterator::EnumerateChildren(Expression &expr,
 		for (auto &child : window_expr.children) {
 			callback(child);
 		}
+		if (window_expr.filter_expr) {
+			callback(window_expr.filter_expr);
+		}
 		if (window_expr.start_expr) {
 			callback(window_expr.start_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 "ac159c167"
-#define DUCKDB_VERSION "v0.3.5-dev653"
+#define DUCKDB_SOURCE_ID "1d0e9975a"
+#define DUCKDB_VERSION "v0.3.5-dev658"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -7791,13 +7791,13 @@ public:
 	}
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void UnaryWindow(Vector &input, FunctionData *bind_data, data_ptr_t state, const FrameBounds &frame,
-	                        const FrameBounds &prev, Vector &result, idx_t rid, idx_t bias) {
+	static void UnaryWindow(Vector &input, const ValidityMask &ifilter, FunctionData *bind_data, data_ptr_t state,
+	                        const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid, idx_t bias) {
 
 		auto idata = FlatVector::GetData<const INPUT_TYPE>(input) - bias;
 		const auto &ivalid = FlatVector::Validity(input);
-		OP::template Window<STATE, INPUT_TYPE, RESULT_TYPE>(idata, ivalid, bind_data, (STATE *)state, frame, prev,
-		                                                    result, rid, bias);
+		OP::template Window<STATE, INPUT_TYPE, RESULT_TYPE>(idata, ifilter, ivalid, bind_data, (STATE *)state, frame,
+		                                                    prev, result, rid, bias);
 	}
 
 	template <class STATE_TYPE, class OP>
@@ -9022,9 +9022,9 @@ typedef void (*aggregate_simple_update_t)(Vector inputs[], FunctionData *bind_da
 
 //! The type used for updating complex windowed aggregate functions (optional)
 typedef std::pair<idx_t, idx_t> FrameBounds;
-typedef void (*aggregate_window_t)(Vector inputs[], FunctionData *bind_data, idx_t input_count, data_ptr_t state,
-                                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid,
-                                   idx_t bias);
+typedef void (*aggregate_window_t)(Vector inputs[], const ValidityMask &filter_mask, FunctionData *bind_data,
+                                   idx_t input_count, data_ptr_t state, const FrameBounds &frame,
+                                   const FrameBounds &prev, Vector &result, idx_t rid, idx_t bias);
 
 class AggregateFunction : public BaseScalarFunction {
 public:
@@ -9191,11 +9191,12 @@ public:
 	}
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void UnaryWindow(Vector inputs[], FunctionData *bind_data, idx_t input_count, data_ptr_t state,
-	                        const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid, idx_t bias) {
+	static void UnaryWindow(Vector inputs[], const ValidityMask &filter_mask, FunctionData *bind_data,
+	                        idx_t input_count, data_ptr_t state, const FrameBounds &frame, const FrameBounds &prev,
+	                        Vector &result, idx_t rid, idx_t bias) {
 		D_ASSERT(input_count == 1);
-		AggregateExecutor::UnaryWindow<STATE, INPUT_TYPE, RESULT_TYPE, OP>(inputs[0], bind_data, state, frame, prev,
-		                                                                   result, rid, bias);
+		AggregateExecutor::UnaryWindow<STATE, INPUT_TYPE, RESULT_TYPE, OP>(inputs[0], filter_mask, bind_data, state,
+		                                                                   frame, prev, result, rid, bias);
 	}
 
 	template <class STATE, class A_TYPE, class B_TYPE, class OP>
@@ -14363,12 +14364,14 @@ public:
 	string schema;
 	//! Name of the aggregate function
 	string function_name;
-	//! The child expression of the main window aggregate
+	//! The child expression of the main window function
 	vector<unique_ptr<ParsedExpression>> children;
 	//! The set of expressions to partition by
 	vector<unique_ptr<ParsedExpression>> partitions;
 	//! The set of ordering clauses
 	vector<OrderByNode> orders;
+	//! Expression representing a filter, only used for aggregates
+	unique_ptr<ParsedExpression> filter_expr;
 	//! True to ignore NULL values
 	bool ignore_nulls;
 	//! The window boundaries
@@ -14417,8 +14420,13 @@ public:
 		if (entry.ignore_nulls) {
 			result += " IGNORE NULLS";
 		}
+		// FILTER
+		if (entry.filter_expr) {
+			result += ") FILTER (WHERE " + entry.filter_expr->ToString();
+		}
+
 		// Over clause
-		result += ") OVER(";
+		result += ") OVER (";
 		string sep;
 
 		// Partitions
@@ -14537,7 +14545,7 @@ public:
 	unique_ptr<AggregateFunction> aggregate;
 	//! The bound function info
 	unique_ptr<FunctionData> bind_info;
-	//! The child expressions of the main window aggregate
+	//! The child expressions of the main window function
 	vector<unique_ptr<Expression>> children;
 	//! The set of expressions to partition by
 	vector<unique_ptr<Expression>> partitions;
@@ -14545,6 +14553,8 @@ public:
 	vector<unique_ptr<BaseStatistics>> partitions_stats;
 	//! The set of ordering clauses
 	vector<BoundOrderByNode> orders;
+	//! Expression representing a filter, only used for aggregates
+	unique_ptr<Expression> filter_expr;
 	//! True to ignore NULL values
 	bool ignore_nulls;
 	//! The window boundaries