duckdb 1.1.4-dev9.0 → 1.2.0

package/src/duckdb/src/function/table/system/duckdb_extensions.cpp

@@ -149,11 +149,15 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 			auto entry = installed_extensions.find(ext_name);
 			if (entry == installed_extensions.end() || !entry->second.installed) {
 				ExtensionInformation &info = installed_extensions[ext_name];
+
 				info.name = ext_name;
 				info.loaded = true;
 				info.extension_version = ext_install_info->version;
 				info.installed = ext_install_info->mode == ExtensionInstallMode::STATICALLY_LINKED;
 				info.install_mode = ext_install_info->mode;
+				if (ext_data.install_info->mode == ExtensionInstallMode::STATICALLY_LINKED && info.file_path.empty()) {
+					info.file_path = "(BUILT-IN)";
+				}
 			} else {
 				entry->second.loaded = true;
 				entry->second.extension_version = ext_install_info->version;

package/src/duckdb/src/function/table/system/duckdb_secret_types.cpp

@@ -0,0 +1,71 @@
+#include "duckdb/function/table/system_functions.hpp"
+#include "duckdb/main/config.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/common/enum_util.hpp"
+#include "duckdb/main/secret/secret_manager.hpp"
+#include "duckdb/main/secret/secret.hpp"
+
+namespace duckdb {
+
+struct DuckDBSecretTypesData : public GlobalTableFunctionState {
+	DuckDBSecretTypesData() : offset(0) {
+	}
+
+	vector<SecretType> types;
+	idx_t offset;
+};
+
+static unique_ptr<FunctionData> DuckDBSecretTypesBind(ClientContext &context, TableFunctionBindInput &input,
+                                                      vector<LogicalType> &return_types, vector<string> &names) {
+	names.emplace_back("type");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("default_provider");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("extension");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	return nullptr;
+}
+
+unique_ptr<GlobalTableFunctionState> DuckDBSecretTypesInit(ClientContext &context, TableFunctionInitInput &input) {
+	auto result = make_uniq<DuckDBSecretTypesData>();
+
+	auto &secret_manager = SecretManager::Get(context);
+	result->types = secret_manager.AllSecretTypes();
+
+	return std::move(result);
+}
+
+void DuckDBSecretTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = data_p.global_state->Cast<DuckDBSecretTypesData>();
+	if (data.offset >= data.types.size()) {
+		// finished returning values
+		return;
+	}
+	// start returning values
+	// either fill up the chunk or return all the remaining columns
+	idx_t count = 0;
+	while (data.offset < data.types.size() && count < STANDARD_VECTOR_SIZE) {
+		auto &entry = data.types[data.offset++];
+
+		// return values:
+		// type, LogicalType::VARCHAR
+		output.SetValue(0, count, Value(entry.name));
+		// default_provider, LogicalType::VARCHAR
+		output.SetValue(1, count, Value(entry.default_provider));
+		// extension, LogicalType::VARCHAR
+		output.SetValue(2, count, Value(entry.extension));
+
+		count++;
+	}
+	output.SetCardinality(count);
+}
+
+void DuckDBSecretTypesFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(TableFunction("duckdb_secret_types", {}, DuckDBSecretTypesFunction, DuckDBSecretTypesBind,
+	                              DuckDBSecretTypesInit));
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/table/system_functions.cpp

@@ -33,6 +33,7 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 	DuckDBOptimizersFun::RegisterFunction(*this);
 	DuckDBSecretsFun::RegisterFunction(*this);
 	DuckDBWhichSecretFun::RegisterFunction(*this);
+	DuckDBSecretTypesFun::RegisterFunction(*this);
 	DuckDBSequencesFun::RegisterFunction(*this);
 	DuckDBSettingsFun::RegisterFunction(*this);
 	DuckDBTablesFun::RegisterFunction(*this);

package/src/duckdb/src/function/table/table_scan.cpp

@@ -24,6 +24,7 @@
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
 #include "duckdb/planner/filter/conjunction_filter.hpp"
+#include "duckdb/common/types/value_map.hpp"
 
 namespace duckdb {
 
@@ -41,6 +42,8 @@ struct IndexScanLocalState : public LocalTableFunctionState {
 	//! The DataChunk containing all read columns.
 	//! This includes filter columns, which are immediately removed.
 	DataChunk all_columns;
+	//! Fetch state
+	ColumnFetchState fetch_state;
 };
 
 static StorageIndex TransformStorageIndex(const ColumnIndex &column_id) {
@@ -115,7 +118,6 @@ public:
 	//! Synchronize changes to the global index scan state.
 	mutex index_scan_lock;
 
-	ColumnFetchState fetch_state;
 	TableScanState table_scan_state;
 
 public:
@@ -159,10 +161,10 @@ public:
 
 			if (CanRemoveFilterColumns()) {
 				l_state.all_columns.Reset();
-				storage.Fetch(tx, l_state.all_columns, column_ids, local_vector, scan_count, fetch_state);
+				storage.Fetch(tx, l_state.all_columns, column_ids, local_vector, scan_count, l_state.fetch_state);
 				output.ReferenceColumns(l_state.all_columns, projection_ids);
 			} else {
-				storage.Fetch(tx, output, column_ids, local_vector, scan_count, fetch_state);
+				storage.Fetch(tx, output, column_ids, local_vector, scan_count, l_state.fetch_state);
 			}
 		}
 
@@ -361,56 +363,137 @@ unique_ptr<GlobalTableFunctionState> DuckIndexScanInitGlobal(ClientContext &cont
 	return std::move(g_state);
 }
 
-void ExtractInFilter(unique_ptr<TableFilter> &filter, BoundColumnRefExpression &bound_ref,
-                     unique_ptr<vector<unique_ptr<Expression>>> &filter_expressions) {
-	// Special-handling of IN filters.
-	// They are part of a CONJUNCTION_AND.
-	if (filter->filter_type != TableFilterType::CONJUNCTION_AND) {
-		return;
+void ExtractExpressionsFromValues(value_set_t &unique_values, BoundColumnRefExpression &bound_ref,
+                                  vector<unique_ptr<Expression>> &expressions) {
+	for (const auto &value : unique_values) {
+		auto bound_constant = make_uniq<BoundConstantExpression>(value);
+		auto filter_expr = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_EQUAL, bound_ref.Copy(),
+		                                                        std::move(bound_constant));
+		expressions.push_back(std::move(filter_expr));
 	}
+}
 
-	auto &and_filter = filter->Cast<ConjunctionAndFilter>();
-	auto &children = and_filter.child_filters;
-	if (children.empty()) {
-		return;
+void ExtractIn(InFilter &filter, BoundColumnRefExpression &bound_ref, vector<unique_ptr<Expression>> &expressions) {
+	// Eliminate any duplicates.
+	value_set_t unique_values;
+	for (const auto &value : filter.values) {
+		if (unique_values.find(value) == unique_values.end()) {
+			unique_values.insert(value);
+		}
 	}
-	if (children[0]->filter_type != TableFilterType::OPTIONAL_FILTER) {
+	ExtractExpressionsFromValues(unique_values, bound_ref, expressions);
+}
+
+void ExtractConjunctionAnd(ConjunctionAndFilter &filter, BoundColumnRefExpression &bound_ref,
+                           vector<unique_ptr<Expression>> &expressions) {
+	if (filter.child_filters.empty()) {
 		return;
 	}
 
-	auto &optional_filter = children[0]->Cast<OptionalFilter>();
-	auto &child = optional_filter.child_filter;
-	if (child->filter_type != TableFilterType::IN_FILTER) {
+	// Extract the CONSTANT_COMPARISON and IN_FILTER children.
+	vector<reference<ConstantFilter>> comparisons;
+	vector<reference<InFilter>> in_filters;
+
+	for (idx_t i = 0; i < filter.child_filters.size(); i++) {
+		if (filter.child_filters[i]->filter_type == TableFilterType::CONSTANT_COMPARISON) {
+			auto &comparison = filter.child_filters[i]->Cast<ConstantFilter>();
+			comparisons.push_back(comparison);
+			continue;
+		}
+
+		if (filter.child_filters[i]->filter_type == TableFilterType::OPTIONAL_FILTER) {
+			auto &optional_filter = filter.child_filters[i]->Cast<OptionalFilter>();
+			if (!optional_filter.child_filter) {
+				return;
+			}
+			if (optional_filter.child_filter->filter_type != TableFilterType::IN_FILTER) {
+				// No support for other optional filter types yet.
+				return;
+			}
+			auto &in_filter = optional_filter.child_filter->Cast<InFilter>();
+			in_filters.push_back(in_filter);
+			continue;
+		}
+
+		// No support for other filter types than CONSTANT_COMPARISON and IN_FILTER in CONJUNCTION_AND yet.
 		return;
 	}
 
-	auto &in_filter = child->Cast<InFilter>();
-	if (!in_filter.origin_is_hash_join) {
+	// No support for other CONJUNCTION_AND cases yet.
+	if (in_filters.empty()) {
 		return;
 	}
 
-	// They are all on the same column, so we can split them.
-	for (const auto &value : in_filter.values) {
-		auto bound_constant = make_uniq<BoundConstantExpression>(value);
-		auto filter_expr = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_EQUAL, bound_ref.Copy(),
-		                                                        std::move(bound_constant));
-		filter_expressions->push_back(std::move(filter_expr));
+	// Get the combined unique values of the IN filters.
+	value_set_t unique_values;
+	for (idx_t filter_idx = 0; filter_idx < in_filters.size(); filter_idx++) {
+		auto &in_filter = in_filters[filter_idx].get();
+		for (idx_t value_idx = 0; value_idx < in_filter.values.size(); value_idx++) {
+			auto &value = in_filter.values[value_idx];
+			if (unique_values.find(value) != unique_values.end()) {
+				continue;
+			}
+			unique_values.insert(value);
+		}
+	}
+
+	// Extract all qualifying values.
+	for (auto value_it = unique_values.begin(); value_it != unique_values.end();) {
+		bool qualifies = true;
+		for (idx_t comp_idx = 0; comp_idx < comparisons.size(); comp_idx++) {
+			if (!comparisons[comp_idx].get().Compare(*value_it)) {
+				qualifies = false;
+				value_it = unique_values.erase(value_it);
+				break;
+			}
+		}
+		if (qualifies) {
+			value_it++;
+		}
+	}
+
+	ExtractExpressionsFromValues(unique_values, bound_ref, expressions);
+}
+
+void ExtractFilter(TableFilter &filter, BoundColumnRefExpression &bound_ref,
+                   vector<unique_ptr<Expression>> &expressions) {
+	switch (filter.filter_type) {
+	case TableFilterType::OPTIONAL_FILTER: {
+		auto &optional_filter = filter.Cast<OptionalFilter>();
+		if (!optional_filter.child_filter) {
+			return;
+		}
+		return ExtractFilter(*optional_filter.child_filter, bound_ref, expressions);
+	}
+	case TableFilterType::IN_FILTER: {
+		auto &in_filter = filter.Cast<InFilter>();
+		ExtractIn(in_filter, bound_ref, expressions);
+		return;
+	}
+	case TableFilterType::CONJUNCTION_AND: {
+		auto &conjunction_and = filter.Cast<ConjunctionAndFilter>();
+		ExtractConjunctionAnd(conjunction_and, bound_ref, expressions);
+		return;
+	}
+	default:
+		return;
 	}
 }
 
-unique_ptr<vector<unique_ptr<Expression>>> ExtractFilters(const ColumnDefinition &col, unique_ptr<TableFilter> &filter,
-                                                          idx_t storage_idx) {
+vector<unique_ptr<Expression>> ExtractFilterExpressions(const ColumnDefinition &col, unique_ptr<TableFilter> &filter,
+                                                        idx_t storage_idx) {
 	ColumnBinding binding(0, storage_idx);
 	auto bound_ref = make_uniq<BoundColumnRefExpression>(col.Name(), col.Type(), binding);
 
-	auto filter_expressions = make_uniq<vector<unique_ptr<Expression>>>();
-	ExtractInFilter(filter, *bound_ref, filter_expressions);
+	vector<unique_ptr<Expression>> expressions;
+	ExtractFilter(*filter, *bound_ref, expressions);
 
-	if (filter_expressions->empty()) {
+	// Attempt matching the top-level filter to the index expression.
+	if (expressions.empty()) {
 		auto filter_expr = filter->ToExpression(*bound_ref);
-		filter_expressions->push_back(std::move(filter_expr));
+		expressions.push_back(std::move(filter_expr));
 	}
-	return filter_expressions;
+	return expressions;
 }
 
 bool TryScanIndex(ART &art, const ColumnList &column_list, TableFunctionInitInput &input, TableFilterSet &filter_set,
@@ -453,8 +536,8 @@ bool TryScanIndex(ART &art, const ColumnList &column_list, TableFunctionInitInpu
 		return false;
 	}
 
-	auto filter_expressions = ExtractFilters(col, filter->second, storage_index.GetIndex());
-	for (const auto &filter_expr : *filter_expressions) {
+	auto expressions = ExtractFilterExpressions(col, filter->second, storage_index.GetIndex());
+	for (const auto &filter_expr : expressions) {
 		auto scan_state = art.TryInitializeScan(*index_expr, *filter_expr);
 		if (!scan_state) {
 			return false;
@@ -493,7 +576,8 @@ unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context,
 	}
 
 	// The checkpoint lock ensures that we do not checkpoint while scanning this table.
-	auto checkpoint_lock = storage.GetSharedCheckpointLock();
+	auto &transaction = DuckTransaction::Get(context, storage.db);
+	auto checkpoint_lock = transaction.SharedLockTable(*storage.GetDataTableInfo());
 	auto &info = storage.GetDataTableInfo();
 	auto &indexes = info->GetIndexes();
 	if (indexes.Empty()) {
@@ -588,7 +672,7 @@ InsertionOrderPreservingMap<string> TableScanToString(TableFunctionToStringInput
 	InsertionOrderPreservingMap<string> result;
 	auto &bind_data = input.bind_data->Cast<TableScanBindData>();
 	result["Table"] = bind_data.table.name;
-	result["Type"] = bind_data.is_index_scan ? "Index Scan" : "Sequence Scan";
+	result["Type"] = bind_data.is_index_scan ? "Index Scan" : "Sequential Scan";
 	return result;
 }
 

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,17 +1,17 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "4-dev4615"
+#define DUCKDB_PATCH_VERSION "0"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
-#define DUCKDB_MINOR_VERSION 1
+#define DUCKDB_MINOR_VERSION 2
 #endif
 #ifndef DUCKDB_MAJOR_VERSION
 #define DUCKDB_MAJOR_VERSION 1
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v1.1.4-dev4615"
+#define DUCKDB_VERSION "v1.2.0"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "ff6dde1453"
+#define DUCKDB_SOURCE_ID "5f5512b827"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/function/window/window_aggregate_function.cpp

@@ -194,7 +194,12 @@ static void ApplyWindowStats(const WindowBoundary &boundary, FrameDelta &delta,
 	case WindowBoundary::EXPR_PRECEDING_RANGE:
 	case WindowBoundary::EXPR_FOLLOWING_RANGE:
 		return;
-	default:
+	case WindowBoundary::CURRENT_ROW_GROUPS:
+	case WindowBoundary::EXPR_PRECEDING_GROUPS:
+	case WindowBoundary::EXPR_FOLLOWING_GROUPS:
+		return;
+	case WindowBoundary::INVALID:
+		throw InternalException(is_start ? "Unknown window start boundary" : "Unknown window end boundary");
 		break;
 	}
 

package/src/duckdb/src/function/window/window_boundaries_state.cpp

@@ -374,7 +374,7 @@ WindowBoundsSet WindowBoundariesState::GetWindowBounds(const BoundWindowExpressi
 		result.insert(FRAME_END);
 		break;
 	default:
-		throw InternalException("Window aggregate type %s", ExpressionTypeToString(wexpr.GetExpressionType()));
+		throw InternalException("Window expression type %s", ExpressionTypeToString(wexpr.GetExpressionType()));
 	}
 
 	//	Internal dependencies
@@ -388,11 +388,12 @@ WindowBoundsSet WindowBoundariesState::GetWindowBounds(const BoundWindowExpressi
 			result.insert(PEER_END);
 		}
 
-		// If the frames are RANGE, then we need peer boundaries
-		// If they are preceding or following, we also need to know
+		// If the frames are RANGE or GROUPS, then we need peer boundaries
+		// If they are preceding or following, RANGE also needs to know
 		// where the valid values begin or end.
 		switch (wexpr.start) {
 		case WindowBoundary::CURRENT_ROW_RANGE:
+		case WindowBoundary::CURRENT_ROW_GROUPS:
 			result.insert(PEER_BEGIN);
 			break;
 		case WindowBoundary::EXPR_PRECEDING_RANGE:
@@ -404,12 +405,24 @@ WindowBoundsSet WindowBoundariesState::GetWindowBounds(const BoundWindowExpressi
 			result.insert(PEER_BEGIN);
 			result.insert(VALID_END);
 			break;
-		default:
+		case WindowBoundary::EXPR_PRECEDING_GROUPS:
+			result.insert(PEER_BEGIN);
+			break;
+		case WindowBoundary::EXPR_FOLLOWING_GROUPS:
+			result.insert(PEER_BEGIN);
+			break;
+		case WindowBoundary::UNBOUNDED_PRECEDING:
+		case WindowBoundary::UNBOUNDED_FOLLOWING:
+		case WindowBoundary::CURRENT_ROW_ROWS:
+		case WindowBoundary::EXPR_PRECEDING_ROWS:
+		case WindowBoundary::EXPR_FOLLOWING_ROWS:
+		case WindowBoundary::INVALID:
 			break;
 		}
 
 		switch (wexpr.end) {
 		case WindowBoundary::CURRENT_ROW_RANGE:
+		case WindowBoundary::CURRENT_ROW_GROUPS:
 			result.insert(PEER_END);
 			break;
 		case WindowBoundary::EXPR_PRECEDING_RANGE:
@@ -421,7 +434,18 @@ WindowBoundsSet WindowBoundariesState::GetWindowBounds(const BoundWindowExpressi
 			result.insert(VALID_BEGIN);
 			result.insert(VALID_END);
 			break;
-		default:
+		case WindowBoundary::EXPR_PRECEDING_GROUPS:
+			result.insert(PEER_END);
+			break;
+		case WindowBoundary::EXPR_FOLLOWING_GROUPS:
+			result.insert(PEER_END);
+			break;
+		case WindowBoundary::UNBOUNDED_PRECEDING:
+		case WindowBoundary::UNBOUNDED_FOLLOWING:
+		case WindowBoundary::CURRENT_ROW_ROWS:
+		case WindowBoundary::EXPR_PRECEDING_ROWS:
+		case WindowBoundary::EXPR_FOLLOWING_ROWS:
+		case WindowBoundary::INVALID:
 			break;
 		}
 	}
@@ -483,10 +507,10 @@ void WindowBoundariesState::Bounds(DataChunk &bounds, idx_t row_idx, optional_pt
 		ValidEnd(bounds, row_idx, count, is_jump, partition_mask, order_mask, range);
 	}
 	if (required.count(FRAME_BEGIN)) {
-		FrameBegin(bounds, row_idx, count, boundary_start, range);
+		FrameBegin(bounds, row_idx, count, boundary_start, order_mask, range);
 	}
 	if (required.count(FRAME_END)) {
-		FrameEnd(bounds, row_idx, count, boundary_end, range);
+		FrameEnd(bounds, row_idx, count, boundary_end, order_mask, range);
 	}
 	next_pos += count;
 
@@ -683,7 +707,8 @@ void WindowBoundariesState::ValidEnd(DataChunk &bounds, idx_t row_idx, const idx
 }
 
 void WindowBoundariesState::FrameBegin(DataChunk &bounds, idx_t row_idx, const idx_t count,
-                                       WindowInputExpression &boundary_begin, optional_ptr<WindowCursor> range) {
+                                       WindowInputExpression &boundary_begin, const ValidityMask &order_mask,
+                                       optional_ptr<WindowCursor> range) {
 	auto partition_begin_data = FlatVector::GetData<idx_t>(bounds.data[PARTITION_BEGIN]);
 	auto partition_end_data = FlatVector::GetData<const idx_t>(bounds.data[PARTITION_END]);
 	auto peer_begin_data = FlatVector::GetData<idx_t>(bounds.data[PEER_BEGIN]);
@@ -704,6 +729,9 @@ void WindowBoundariesState::FrameBegin(DataChunk &bounds, idx_t row_idx, const i
 		}
 		break;
 	case WindowBoundary::CURRENT_ROW_RANGE:
+	case WindowBoundary::CURRENT_ROW_GROUPS:
+		// in RANGE or GROUPS mode it means that the frame starts or ends with the current row's
+		// first or last peer in the ORDER BY ordering
 		bounds.data[FRAME_BEGIN].Reference(bounds.data[PEER_BEGIN]);
 		frame_begin_data = peer_begin_data;
 		break;
@@ -759,7 +787,53 @@ void WindowBoundariesState::FrameBegin(DataChunk &bounds, idx_t row_idx, const i
 			frame_begin_data[chunk_idx] = window_start;
 		}
 		break;
-	default:
+	case WindowBoundary::EXPR_PRECEDING_GROUPS:
+		// In GROUPS mode, the offset is an integer indicating that the frame starts or ends that many peer groups
+		// before or after the current row's peer group, where a peer group is a group of rows that are equivalent
+		// according to the window's ORDER BY clause.
+		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
+			if (boundary_begin.CellIsNull(chunk_idx)) {
+				window_start = peer_begin_data[chunk_idx];
+			} else {
+				//	Count peer groups backwards.
+				const auto peer_begin = peer_begin_data[chunk_idx];
+				const auto partition_begin = partition_begin_data[chunk_idx];
+				const auto boundary = boundary_begin.GetCell<int64_t>(chunk_idx);
+				if (boundary < 0) {
+					throw OutOfRangeException("Invalid GROUPS PRECEDING value");
+				} else if (!boundary) {
+					window_start = peer_begin;
+				} else {
+					auto n = UnsafeNumericCast<idx_t>(boundary);
+					window_start = FindPrevStart(order_mask, partition_begin, peer_begin, n);
+				}
+			}
+			frame_begin_data[chunk_idx] = window_start;
+		}
+		break;
+	case WindowBoundary::EXPR_FOLLOWING_GROUPS:
+		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
+			if (boundary_begin.CellIsNull(chunk_idx)) {
+				window_start = peer_begin_data[chunk_idx];
+			} else {
+				//	Count peer groups forward.
+				const auto peer_begin = peer_begin_data[chunk_idx];
+				const auto partition_end = partition_end_data[chunk_idx];
+				const auto boundary = boundary_begin.GetCell<int64_t>(chunk_idx);
+				if (boundary < 0) {
+					throw OutOfRangeException("Invalid GROUPS FOLLOWING value");
+				} else if (!boundary) {
+					window_start = peer_begin;
+				} else {
+					auto n = UnsafeNumericCast<idx_t>(boundary);
+					window_start = FindNextStart(order_mask, peer_begin + 1, partition_end, n);
+				}
+			}
+			frame_begin_data[chunk_idx] = window_start;
+		}
+		break;
+	case WindowBoundary::UNBOUNDED_FOLLOWING:
+	case WindowBoundary::INVALID:
 		throw InternalException("Unsupported window start boundary");
 	}
 
@@ -767,7 +841,8 @@ void WindowBoundariesState::FrameBegin(DataChunk &bounds, idx_t row_idx, const i
 }
 
 void WindowBoundariesState::FrameEnd(DataChunk &bounds, idx_t row_idx, const idx_t count,
-                                     WindowInputExpression &boundary_end, optional_ptr<WindowCursor> range) {
+                                     WindowInputExpression &boundary_end, const ValidityMask &order_mask,
+                                     optional_ptr<WindowCursor> range) {
 	auto partition_begin_data = FlatVector::GetData<const idx_t>(bounds.data[PARTITION_BEGIN]);
 	auto partition_end_data = FlatVector::GetData<idx_t>(bounds.data[PARTITION_END]);
 	auto peer_end_data = FlatVector::GetData<idx_t>(bounds.data[PEER_END]);
@@ -784,6 +859,9 @@ void WindowBoundariesState::FrameEnd(DataChunk &bounds, idx_t row_idx, const idx
 		}
 		break;
 	case WindowBoundary::CURRENT_ROW_RANGE:
+	case WindowBoundary::CURRENT_ROW_GROUPS:
+		// in RANGE or GROUPS mode it means that the frame starts or ends with the current row's
+		// first or last peer in the ORDER BY ordering
 		bounds.data[FRAME_END].Reference(bounds.data[PEER_END]);
 		frame_end_data = peer_end_data;
 		break;
@@ -844,7 +922,53 @@ void WindowBoundariesState::FrameEnd(DataChunk &bounds, idx_t row_idx, const idx
 			frame_end_data[chunk_idx] = window_end;
 		}
 		break;
-	default:
+	case WindowBoundary::EXPR_PRECEDING_GROUPS:
+		// In GROUPS mode, the offset is an integer indicating that the frame starts or ends that many peer groups
+		// before or after the current row's peer group, where a peer group is a group of rows that are equivalent
+		// according to the window's ORDER BY clause.
+		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
+			if (boundary_end.CellIsNull(chunk_idx)) {
+				window_end = peer_end_data[chunk_idx];
+			} else {
+				//	Count peer groups backwards.
+				const auto peer_end = peer_end_data[chunk_idx];
+				const auto partition_begin = partition_begin_data[chunk_idx];
+				const auto boundary = boundary_end.GetCell<int64_t>(chunk_idx);
+				if (boundary < 0) {
+					throw OutOfRangeException("Invalid GROUPS PRECEDING value");
+				} else if (!boundary) {
+					window_end = peer_end;
+				} else {
+					auto n = UnsafeNumericCast<idx_t>(boundary);
+					window_end = FindPrevStart(order_mask, partition_begin, peer_end, n);
+				}
+			}
+			frame_end_data[chunk_idx] = window_end;
+		}
+		break;
+	case WindowBoundary::EXPR_FOLLOWING_GROUPS:
+		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
+			if (boundary_end.CellIsNull(chunk_idx)) {
+				window_end = peer_end_data[chunk_idx];
+			} else {
+				//	Count peer groups forward.
+				const auto peer_end = peer_end_data[chunk_idx];
+				const auto partition_end = partition_end_data[chunk_idx];
+				const auto boundary = boundary_end.GetCell<int64_t>(chunk_idx);
+				if (boundary < 0) {
+					throw OutOfRangeException("Invalid GROUPS FOLLOWING value");
+				} else if (!boundary) {
+					window_end = peer_end;
+				} else {
+					auto n = UnsafeNumericCast<idx_t>(boundary);
+					window_end = FindNextStart(order_mask, peer_end + 1, partition_end, n);
+				}
+			}
+			frame_end_data[chunk_idx] = window_end;
+		}
+		break;
+	case WindowBoundary::UNBOUNDED_PRECEDING:
+	case WindowBoundary::INVALID:
 		throw InternalException("Unsupported window end boundary");
 	}