duckdb 0.3.5-dev653.0 → 0.3.5-dev666.0

package/package.json

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

package/src/duckdb.cpp

@@ -1261,7 +1261,7 @@ public:
 	}
 
 	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value, ARGS &&...args) {
+	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value, ARGS &&... args) {
 		if (field_count >= max_field_count) {
 			// field is not there, read the default value
 			return default_value;
@@ -1283,7 +1283,7 @@ public:
 	}
 
 	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadRequiredSerializable(ARGS &&...args) {
+	RETURN_TYPE ReadRequiredSerializable(ARGS &&... args) {
 		if (field_count >= max_field_count) {
 			// field is not there, read the default value
 			throw SerializationException("Attempting to read mandatory field, but field is missing");
@@ -52758,28 +52758,23 @@ idx_t GroupedAggregateHashTable::AddChunk(DataChunk &groups, Vector &group_hashe
 			// value have not been seen yet
 			idx_t new_group_count =
 			    distinct_hashes[aggr_idx]->FindOrCreateGroups(probe_chunk, dummy_addresses, new_groups);
-
-			// now fix up the payload and addresses accordingly by creating
-			// a selection vector
 			if (new_group_count > 0) {
+				// now fix up the payload and addresses accordingly by creating
+				// a selection vector
+				DataChunk distinct_payload;
+				distinct_payload.Initialize(payload.GetTypes());
+				distinct_payload.Slice(payload, new_groups, new_group_count);
+				distinct_payload.Verify();
+
+				Vector distinct_addresses(addresses, new_groups, new_group_count);
+				distinct_addresses.Verify(new_group_count);
+
 				if (aggr.filter) {
-					Vector distinct_addresses(addresses, new_groups, new_group_count);
-					DataChunk distinct_payload;
-					auto pay_types = payload.GetTypes();
-					distinct_payload.Initialize(pay_types);
-					distinct_payload.Slice(payload, new_groups, new_group_count);
-					distinct_addresses.Verify(new_group_count);
 					distinct_addresses.Normalify(new_group_count);
 					RowOperations::UpdateFilteredStates(aggr, distinct_addresses, distinct_payload, payload_idx);
 				} else {
-					Vector distinct_addresses(addresses, new_groups, new_group_count);
-					for (idx_t i = 0; i < aggr.child_count; i++) {
-						payload.data[payload_idx + i].Slice(new_groups, new_group_count);
-						payload.data[payload_idx + i].Verify(new_group_count);
-					}
-					distinct_addresses.Verify(new_group_count);
-
-					RowOperations::UpdateStates(aggr, distinct_addresses, payload, payload_idx, new_group_count);
+					RowOperations::UpdateStates(aggr, distinct_addresses, distinct_payload, payload_idx,
+					                            new_group_count);
 				}
 			}
 		} else if (aggr.filter) {
@@ -58033,6 +58028,7 @@ SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, GlobalSink
 		for (auto &child_expr : aggr.children) {
 			D_ASSERT(child_expr->type == ExpressionType::BOUND_REF);
 			auto &bound_ref_expr = (BoundReferenceExpression &)*child_expr;
+			D_ASSERT(bound_ref_expr.index < input.data.size());
 			aggregate_input_chunk.data[aggregate_input_idx++].Reference(input.data[bound_ref_expr.index]);
 		}
 	}
@@ -58041,6 +58037,7 @@ SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, GlobalSink
 		if (aggr.filter) {
 			auto it = filter_indexes.find(aggr.filter.get());
 			D_ASSERT(it != filter_indexes.end());
+			D_ASSERT(it->second < input.data.size());
 			aggregate_input_chunk.data[aggregate_input_idx++].Reference(input.data[it->second]);
 		}
 	}
@@ -59077,7 +59074,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 +59107,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 +59129,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 +60034,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 +60106,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 +78713,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 +78725,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 +78806,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 +78899,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 +78949,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 +83481,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 +83550,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 +83566,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 +83805,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);
 	}
-	const ValidityMask &mask;
+
+	inline bool AllValid() const {
+		return fmask.AllValid() && dmask.AllValid();
+	}
+
+	const ValidityMask &fmask;
+	const ValidityMask &dmask;
 	const idx_t bias;
 };
 
@@ -83811,7 +83879,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 +84210,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 +84236,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 +84247,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 +84362,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 +84399,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 +84423,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 +84722,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 +84749,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 +84758,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 +84770,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) {
@@ -104983,6 +105054,14 @@ void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanState &scan
 		auto &struct_validity_mask = FlatVector::Validity(vector);
 		for (idx_t type_idx = 0; type_idx < (idx_t)array.n_children; type_idx++) {
 			SetValidityMask(*child_entries[type_idx], *array.children[type_idx], scan_state, size, nested_offset);
+			if (!struct_validity_mask.AllValid()) {
+				auto &child_validity_mark = FlatVector::Validity(*child_entries[type_idx]);
+				for (idx_t i = 0; i < size; i++) {
+					if (!struct_validity_mask.RowIsValid(i)) {
+						child_validity_mark.SetInvalid(i);
+					}
+				}
+			}
 			ColumnArrowToDuckDB(*child_entries[type_idx], *array.children[type_idx], scan_state, size,
 			                    arrow_convert_data, col_idx, arrow_convert_idx, nested_offset, &struct_validity_mask);
 		}
@@ -145925,6 +146004,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 +146028,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 +146062,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 +146085,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 +146948,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 +155537,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 +155550,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 +155564,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 +161823,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 +161957,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 +168263,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 +168332,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 +169574,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);
 		}