pg.ddx.io pgdogdev/pgdog GitHub issues and pull requests
help / color / mirror / Atom feed[pgdogdev/pgdog] PR #2050: feat: cross-shard GROUP BY on SELECT aliases, and alias/expression keys with HAVING
8+ messages / 4 participants
[nested] [flat]
* [pgdogdev/pgdog] PR #2050: feat: cross-shard GROUP BY on SELECT aliases, and alias/expression keys with HAVING
@ 2026-11-17 16:58 "murex971 (@murex971)" <noreply+murex971@github.com>
0 siblings, 0 replies; 8+ messages in thread
From: murex971 (@murex971) @ 2026-11-17 16:58 UTC (permalink / raw)
To: pgdogdev/pgdog <noreply+pgdogdev-pgdog@github.com>
### Summary
Cross-shard `GROUP BY` now accepts a SELECT alias, and queries with `HAVING` accept
alias and expression group keys. All three were rejected before.
### How
In `GROUP BY name`, Postgres prefers a table column called `name` over a SELECT alias.
PgDog uses its loaded schema to decide which one it is:
- No table in `FROM` has that column: it's the alias, and groups merge on that SELECT
list position.
- A table has that column: the column wins and is sent to shards as a hidden key.
- PgDog can't tell (subquery, function or CTE in `FROM`, table not in the schema,
`AS t(a, b)` renames, system columns): still rejected, with a clearer error.
For `HAVING`, the rewrite now returns the position of every group key, and keys that
aren't in the SELECT list are projected as hidden columns.
### Limits
- Alias grouping needs the schema loaded; without it the query is rejected as before.
- Unqualified tables are matched by name across all schemas, since the search path
isn't available here. This only errs towards the hidden-column path.
- `HAVING` that references a column inside an expression key
(`GROUP BY lower(label) HAVING label = 'x'`) is not handled.
inline patch 1: integration/sql/cases/957_group_by_alias_expression_case.sql, integration/sql/cases/957_group_by_alias_expression_setup.sql, integration/sql/cases/957_group_by_alias_expression_teardown.sql and 5 more (+355/-77 lines) download inline-1.patch
diff --git a/integration/sql/cases/957_group_by_alias_expression_case.sql b/integration/sql/cases/957_group_by_alias_expression_case.sql
new file mode 100644
index 000000000..b35b95ac1
--- /dev/null
+++ b/integration/sql/cases/957_group_by_alias_expression_case.sql
@@ -0,0 +1,24 @@
+-- description: GROUP BY on a SELECT alias or an expression merges across shards
+-- tags: standard sharded
+-- transactional: true
+
+SELECT value % 2 AS parity, COUNT(*) FROM sql_regression_samples GROUP BY parity ORDER BY parity;
+
+SELECT COUNT(*), lower(label) AS l, value % 2 AS parity FROM sql_regression_samples
+GROUP BY parity, l ORDER BY parity, l;
+
+-- The table column wins over the alias, so 'a' and 'A' stay separate groups.
+SELECT lower(label) AS label, COUNT(*), SUM(value) FROM sql_regression_samples
+GROUP BY label ORDER BY 1, 3;
+
+SELECT value % 2 AS parity, COUNT(*) FROM sql_regression_samples
+GROUP BY parity HAVING COUNT(*) > 3 ORDER BY parity;
+
+SELECT lower(label), COUNT(*) FROM sql_regression_samples
+GROUP BY lower(label) HAVING COUNT(*) > 1 ORDER BY 1;
+
+SELECT COUNT(*), SUM(value) FROM sql_regression_samples
+GROUP BY value % 3 HAVING SUM(value) > 4 ORDER BY 2;
+
+SELECT lower(label) AS label, COUNT(*) FROM sql_regression_samples
+GROUP BY label HAVING COUNT(*) >= 1 ORDER BY 1, 2;
diff --git a/integration/sql/cases/957_group_by_alias_expression_setup.sql b/integration/sql/cases/957_group_by_alias_expression_setup.sql
new file mode 100644
index 000000000..9ccde7b03
--- /dev/null
+++ b/integration/sql/cases/957_group_by_alias_expression_setup.sql
@@ -0,0 +1,10 @@
+DROP TABLE IF EXISTS sql_regression_samples;
+CREATE TABLE sql_regression_samples (id BIGINT PRIMARY KEY, value INTEGER, label TEXT);
+INSERT INTO sql_regression_samples VALUES (1, 1, 'a');
+INSERT INTO sql_regression_samples VALUES (101, 1, 'A');
+INSERT INTO sql_regression_samples VALUES (2, 2, 'b');
+INSERT INTO sql_regression_samples VALUES (102, 3, 'B');
+INSERT INTO sql_regression_samples VALUES (3, 4, 'c');
+INSERT INTO sql_regression_samples VALUES (103, 5, 'a');
+INSERT INTO sql_regression_samples VALUES (4, 6, NULL);
+INSERT INTO sql_regression_samples VALUES (104, NULL, NULL);
diff --git a/integration/sql/cases/957_group_by_alias_expression_teardown.sql b/integration/sql/cases/957_group_by_alias_expression_teardown.sql
new file mode 100644
index 000000000..f14a9af47
--- /dev/null
+++ b/integration/sql/cases/957_group_by_alias_expression_teardown.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS sql_regression_samples;
diff --git a/pgdog/src/frontend/router/parser/aggregate.rs b/pgdog/src/frontend/router/parser/aggregate.rs
index 22eb3716d..5f831b2b3 100644
--- a/pgdog/src/frontend/router/parser/aggregate.rs
+++ b/pgdog/src/frontend/router/parser/aggregate.rs
@@ -1,6 +1,8 @@
use pg_raw_parse::{Node, nodes};
use std::fmt;
+use pgdog_stats::Relation as StatsRelation;
+
use super::Function;
use crate::backend::schema::Schema;
@@ -93,6 +95,108 @@ fn index_of_column(stmt: &nodes::SelectStmt, qualified_column_name: &[&str]) ->
})
}
+/// Columns every table has without listing them in its definition.
+const SYSTEM_COLUMNS: [&str; 6] = ["tableoid", "xmin", "cmin", "xmax", "cmax", "ctid"];
+
+/// What a bare `GROUP BY` name that matches a `SELECT` alias refers to.
+///
+/// Postgres looks for a column of the `FROM` tables first and falls back to
+/// the `SELECT` alias, so the schema decides which one it is:
+///
+/// ```sql
+/// SELECT lower(name) AS name, count(*) FROM users GROUP BY name -- users.name
+/// SELECT lower(name) AS n, count(*) FROM users GROUP BY n -- lower(name)
+/// ```
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub(crate) enum GroupByAlias {
+ /// A table in `FROM` has a column with this name.
+ InputColumn,
+ /// No table has one. The name is the `SELECT` list item at this position.
+ Output(usize),
+ /// `FROM` has something other than tables found in the schema.
+ Unknown,
+}
+
+impl GroupByAlias {
+ /// Returns `None` if the column isn't a bare name matching a `SELECT` alias.
+ pub(crate) fn resolve(
+ stmt: &nodes::SelectStmt,
+ column: &nodes::ColumnRef,
+ schema: &Schema,
+ ) -> Option<Self> {
+ let mut fields = column.fields().into_iter();
+ let (Some(name), None) = (fields.next().and_then(Node::as_str), fields.next()) else {
+ return None;
+ };
+ let index = stmt
+ .target_list()
+ .iter()
+ .position(|target| target.name() == Some(name))?;
+
+ if SYSTEM_COLUMNS.contains(&name) {
+ return Some(Self::Unknown);
+ }
+
+ let ctes: Vec<&str> = stmt
+ .with_clause()
+ .map(|with| with.ctes().iter().filter_map(|cte| cte.ctename()).collect())
+ .unwrap_or_default();
+ let mut is_input_column = false;
+ for from in stmt.from_clause().iter() {
+ match from_has_column(from, name, schema, &ctes) {
+ Some(has_column) => is_input_column |= has_column,
+ None => return Some(Self::Unknown),
+ }
+ }
+
+ Some(if is_input_column {
+ Self::InputColumn
+ } else {
+ Self::Output(index)
+ })
+ }
+}
+
+/// Whether a `FROM` item has a column with this name. `None` if it isn't made
+/// of tables found in the schema, e.g., a subquery, a function or a CTE.
+fn from_has_column(from: Node<'_>, name: &str, schema: &Schema, ctes: &[&str]) -> Option<bool> {
+ // `AS t(a, b)` renames the columns.
+ let renames_columns =
+ |alias: Option<&nodes::Alias>| alias.is_some_and(|alias| !alias.colnames().is_empty());
+
+ match from {
+ Node::RangeVar(table) => {
+ let relname = table.relname()?;
+ if renames_columns(table.alias()) {
+ return None;
+ }
+ let has_column = |relation: &StatsRelation| relation.columns.contains_key(name);
+ match table.schemaname() {
+ Some(schemaname) => schema.get(schemaname, relname).map(has_column),
+ None if ctes.contains(&relname) => None,
+ // The search path isn't known here. A column in any table
+ // with this name counts, which only ever picks the hidden
+ // column the shards check themselves.
+ None => schema
+ .relations
+ .values()
+ .filter_map(|relations| relations.get(relname))
+ .map(has_column)
+ .reduce(|a, b| a || b),
+ }
+ }
+ Node::JoinExpr(join) => {
+ if renames_columns(join.alias()) {
+ return None;
+ }
+ let left = from_has_column(join.larg(), name, schema, ctes)?;
+ let right = from_has_column(join.rarg(), name, schema, ctes)?;
+ Some(left || right)
+ }
+ _ => None,
+ }
+}
+
fn columns_match(group_by_names: &[&str], select_names: &[&str]) -> bool {
if group_by_names == select_names {
return true;
@@ -127,7 +231,7 @@ impl Aggregate {
let group_by = stmt
.group_clause()
.iter()
- .filter_map(|node| Self::group_by_column(stmt, node))
+ .filter_map(|node| Self::group_by_column(stmt, node, schema))
.collect();
let targets = stmt
@@ -156,9 +260,13 @@ impl Aggregate {
Self { group_by, targets }
}
- /// Position of a GROUP BY item in the SELECT list, if it's an ordinal
- /// or a selected column.
- pub(crate) fn group_by_column(stmt: &nodes::SelectStmt, node: Node<'_>) -> Option<usize> {
+ /// Position of a GROUP BY item in the SELECT list, if it's an ordinal,
+ /// a selected column or a SELECT alias.
+ pub(crate) fn group_by_column(
+ stmt: &nodes::SelectStmt,
+ node: Node<'_>,
+ schema: &Schema,
+ ) -> Option<usize> {
match node {
// We use 0-indexed arrays, Postgres uses 1-indexed.
Node::A_Const(c) => c
@@ -171,7 +279,11 @@ impl Aggregate {
.iter()
.filter_map(Node::as_str)
.collect::<Vec<_>>(),
- ),
+ )
+ .or_else(|| match GroupByAlias::resolve(stmt, c, schema) {
+ Some(GroupByAlias::Output(index)) => Some(index),
+ _ => None,
+ }),
_ => None,
}
}
diff --git a/pgdog/src/frontend/router/parser/mod.rs b/pgdog/src/frontend/router/parser/mod.rs
index b6dbbd6db..672a88cfd 100644
--- a/pgdog/src/frontend/router/parser/mod.rs
+++ b/pgdog/src/frontend/router/parser/mod.rs
@@ -33,7 +33,7 @@ mod table;
pub(crate) mod value;
mod where_clause;
-pub(crate) use aggregate::{Aggregate, AggregateFunction, AggregateTarget};
+pub(crate) use aggregate::{Aggregate, AggregateFunction, AggregateTarget, GroupByAlias};
pub(crate) use binary::BinaryStream;
pub(crate) use cache::{Ast, AstContext, Cache};
pub(crate) use column::Column;
diff --git a/pgdog/src/frontend/router/parser/rewrite/statement/group_by.rs b/pgdog/src/frontend/router/parser/rewrite/statement/group_by.rs
index 1247971ff..62d4189ce 100644
--- a/pgdog/src/frontend/router/parser/rewrite/statement/group_by.rs
+++ b/pgdog/src/frontend/router/parser/rewrite/statement/group_by.rs
@@ -4,12 +4,18 @@ use pg_raw_parse::{Node, make, nodes};
use super::{
Error,
- projection::{HiddenAliases, column_name, expands_star},
+ projection::{HiddenAliases, expands_star},
+};
+use crate::{
+ backend::schema::Schema,
+ frontend::router::parser::{Aggregate, GroupByAlias},
};
-use crate::frontend::router::parser::Aggregate;
const ALIAS_PREFIX: &str = "__pgdog_group_";
+pub(super) const UNRESOLVED_ALIAS: &str = "GROUP BY on a SELECT alias is only supported when FROM has just tables \
+ PgDog has loaded the schema for";
+
/// GROUP BY keys added to the shard query as hidden columns.
#[derive(Debug, PartialEq)]
pub(crate) struct GroupByRewrite {
@@ -50,6 +56,7 @@ pub(super) fn rewrite_select<'a>(
select: &mut make::Unique<'a, &'a nodes::SelectStmt>,
mem: make::MemoryToken<'a>,
aggregate: &Aggregate,
+ schema: &Schema,
) -> Result<Option<GroupByRewrite>, Error> {
if aggregate.group_by().len() == select.group_clause().len() {
return Ok(None);
@@ -67,7 +74,7 @@ pub(super) fn rewrite_select<'a>(
let mut group_by = vec![];
for node in select.group_clause().iter() {
- if let Some(column) = Aggregate::group_by_column(select, node) {
+ if let Some(column) = Aggregate::group_by_column(select, node, schema) {
group_by.push(column);
continue;
}
@@ -78,11 +85,12 @@ pub(super) fn rewrite_select<'a>(
"GROUPING SETS, ROLLUP and CUBE are unsupported",
));
}
- // Shards can't resolve a SELECT alias inside the hidden column.
- Node::ColumnRef(column) if groups_by_output_alias(select, column) => {
- return Err(Error::UnsupportedGroupBy(
- "GROUP BY on a SELECT alias is unsupported",
- ));
+ // Shards can't resolve a SELECT alias inside the hidden column,
+ // so the name has to be a known column of the FROM tables.
+ Node::ColumnRef(column)
+ if GroupByAlias::resolve(select, column, schema) == Some(GroupByAlias::Unknown) =>
+ {
+ return Err(Error::UnsupportedGroupBy(UNRESOLVED_ALIAS));
}
_ => {}
}
@@ -102,12 +110,3 @@ pub(super) fn rewrite_select<'a>(
aggregate.clone().with_group_by(group_by),
)))
}
-
-fn groups_by_output_alias(select: &nodes::SelectStmt, column: &nodes::ColumnRef) -> bool {
- column.fields().len() == 1
- && select.target_list().iter().any(|target| {
- target
- .name()
- .is_some_and(|name| Some(name) == column_name(column))
- })
-}
diff --git a/pgdog/src/frontend/router/parser/rewrite/statement/having.rs b/pgdog/src/frontend/router/parser/rewrite/statement/having.rs
index f053056db..46735a884 100644
--- a/pgdog/src/frontend/router/parser/rewrite/statement/having.rs
+++ b/pgdog/src/frontend/router/parser/rewrite/statement/having.rs
@@ -7,11 +7,13 @@ use pg_raw_parse::{
};
use crate::backend::schema::Schema;
-use crate::frontend::router::parser::{AggregateFunction, HavingRewritePlan};
+use crate::frontend::router::parser::{
+ Aggregate, AggregateFunction, GroupByAlias, HavingRewritePlan,
+};
use super::{
- Error, offset,
- projection::{HiddenAliases, column_name, is_star},
+ Error, group_by, offset,
+ projection::{HiddenAliases, is_star},
};
const ALIAS_PREFIX: &str = "__pgdog_having_";
@@ -49,11 +51,14 @@ const TABLE_ALIAS: &str = "__pgdog_having";
///
/// which returns the positions of the groups to keep. LIMIT and OFFSET are
/// removed from the shard query, since they apply to the groups that pass.
+///
+/// Returns the plan and the position of every GROUP BY key in the rewritten
+/// SELECT list.
pub(super) fn rewrite_select<'a>(
select: &mut nodes::SelectStmtMut<'a, '_>,
mem: make::MemoryToken<'a>,
schema: &Schema,
-) -> Result<HavingRewritePlan, Error> {
+) -> Result<(HavingRewritePlan, Vec<usize>), Error> {
debug_assert!(
!matches!(select.having_clause(), Node::None),
"HAVING rewrite requires a HAVING clause"
@@ -123,25 +128,39 @@ pub(super) fn rewrite_select<'a>(
.iter()
.map(|group| mem.make_unique(group))
.collect::<Vec<_>>();
+ let selected = select.target_list().len();
+ let mut group_by = Vec::with_capacity(group_sources.len());
for group_source in group_sources {
- match group_source.as_ref() {
- // Shards can't resolve a SELECT alias inside the hidden projection.
- Node::ColumnRef(column) if groups_by_output_alias(select, column) => {
- return Err(Error::UnsupportedHaving(
- "GROUP BY on a SELECT alias is unsupported",
- ));
- }
- Node::ColumnRef(_) => {
- let alias = operands.aliases.next_alias();
- operands.projected.push((alias, group_source));
- }
- Node::A_Const(_) => {}
- _ => {
+ let selected_column = match group_source.as_ref() {
+ // A merged row can't tell which grouping set it came from.
+ Node::GroupingSet(_) => {
return Err(Error::UnsupportedHaving(
- "GROUP BY expressions other than columns and ordinals are unsupported",
+ "GROUPING SETS, ROLLUP and CUBE are unsupported",
));
}
- }
+ ordinal @ Node::A_Const(_) => Some(
+ Aggregate::group_by_column(select, ordinal, schema).ok_or_else(|| {
+ Error::UnsupportedHaving(
+ "GROUP BY constants other than ordinals are unsupported",
+ )
+ })?,
+ ),
+ Node::ColumnRef(column) => match GroupByAlias::resolve(select, column, schema) {
+ Some(GroupByAlias::Output(index)) => Some(index),
+ // Shards can't resolve a SELECT alias inside the hidden projection.
+ Some(GroupByAlias::Unknown) => {
+ return Err(Error::UnsupportedHaving(group_by::UNRESOLVED_ALIAS));
+ }
+ Some(GroupByAlias::InputColumn) | None => None,
+ },
+ _ => None,
+ };
+ // Keys that aren't a SELECT list position are projected as hidden columns.
+ group_by.push(selected_column.unwrap_or_else(|| {
+ let alias = operands.aliases.next_alias();
+ operands.projected.push((alias, group_source));
+ selected + operands.projected.len() - 1
+ }));
}
let hidden_aliases = operands
@@ -174,26 +193,12 @@ pub(super) fn rewrite_select<'a>(
// Shards return every group; PgDog applies LIMIT and OFFSET after the filter.
offset::remove_select(select, mem);
- Ok(HavingRewritePlan::new(
- filter_sql,
- operand_aliases,
- hidden_aliases,
- operands.params,
+ Ok((
+ HavingRewritePlan::new(filter_sql, operand_aliases, hidden_aliases, operands.params),
+ group_by,
))
}
-fn groups_by_output_alias(
- select: &nodes::SelectStmtMut<'_, '_>,
- column: &nodes::ColumnRef,
-) -> bool {
- column.fields().len() == 1
- && select.target_list().iter().any(|target| {
- target
- .name()
- .is_some_and(|name| Some(name) == column_name(column))
- })
-}
-
struct Operands<'a, 's> {
schema: &'s Schema,
aliases: HiddenAliases,
@@ -285,11 +290,7 @@ mod tests {
let mut plan = None;
let rewritten = make::try_owned(|mem| {
let mut select = mem.make_unique(select);
- plan = Some(rewrite_select(
- &mut select.as_mut(),
- mem,
- &Schema::default(),
- )?);
+ plan = Some(rewrite_select(&mut select.as_mut(), mem, &Schema::default())?.0);
Ok::<_, Error>(select)
})?;
Ok((
diff --git a/pgdog/src/frontend/router/parser/rewrite/statement/projection.rs b/pgdog/src/frontend/router/parser/rewrite/statement/projection.rs
index b2a75417e..47d669999 100644
--- a/pgdog/src/frontend/router/parser/rewrite/statement/projection.rs
+++ b/pgdog/src/frontend/router/parser/rewrite/statement/projection.rs
@@ -326,26 +326,23 @@ fn build(
let rewritten = make::try_owned(|mem| {
let mut select = mem.make_unique(select);
if has_having {
- let having = having::rewrite_select(&mut select.as_mut(), mem, schema)?;
- let rewritten_aggregate = Aggregate::parse(&select, schema);
+ let (having, group_by) = having::rewrite_select(&mut select.as_mut(), mem, schema)?;
+ // Aggregate::parse skips GROUP BY items it cannot resolve. The
+ // rewrite has a position for every one of them, so unrelated
+ // groups are never merged together.
+ let rewritten_aggregate = Aggregate::parse(&select, schema).with_group_by(group_by);
if rewritten_aggregate.targets().is_empty() {
return Err(Error::UnsupportedHaving(
"at least one aggregate function is required",
));
}
- // Aggregate::parse skips GROUP BY items it cannot resolve. Require
- // every item here so unrelated groups are never merged together.
- if rewritten_aggregate.group_by().len() != select.group_clause().len() {
- return Err(Error::UnsupportedHaving(
- "every GROUP BY expression must be a selected column or ordinal",
- ));
- }
plan.having = Some(Box::new(HavingRewriteResult::new(
having,
rewritten_aggregate,
)));
} else if let Some(aggregate) = &aggregate {
- plan.group_by = group_by::rewrite_select(&mut select, mem, aggregate)?.map(Box::new);
+ plan.group_by =
+ group_by::rewrite_select(&mut select, mem, aggregate, schema)?.map(Box::new);
}
let aggregate = plan
.aggregate()
@@ -448,7 +445,10 @@ impl HiddenAliases {
#[cfg(test)]
mod tests {
+ use std::collections::HashMap;
+
use super::*;
+ use crate::backend::schema::relation::Relation;
#[test]
fn rejects_count_sort_key() {
@@ -750,12 +750,143 @@ mod tests {
}
}
+ /// A schema with `items (id, category, region)`.
+ fn items_schema() -> Schema {
+ let columns = ["id", "category", "region"]
+ .into_iter()
+ .map(|name| {
+ let column = pgdog_stats::Column {
+ column_name: name.into(),
+ ..Default::default()
+ };
+ (name.to_owned(), column.into())
+ })
+ .collect();
+ let relation = Relation::test_table("public", "items", columns);
+ Schema::from_parts(
+ vec!["public".into()],
+ HashMap::from([(("public".into(), "items".into()), relation)]),
+ )
+ }
+
+ #[test]
+ fn group_by_select_alias_is_merged_by_position() {
+ let schema = items_schema();
+ // (query, shard query if rewritten, merged GROUP BY columns)
+ for (sql, shard_sql, group_by) in [
+ // No table has a column `c`, so it's the SELECT alias.
+ (
+ "SELECT lower(category) AS c, count(*) FROM items GROUP BY c",
+ None,
+ vec![0],
+ ),
+ (
+ "SELECT count(*), category AS c, region AS r FROM items i JOIN items j USING (id) GROUP BY r, c",
+ None,
+ vec![2, 1],
+ ),
+ // `items.category` wins over the alias, so the key is hidden.
+ (
+ "SELECT lower(category) AS category, count(*) FROM items GROUP BY category",
+ Some(
+ "SELECT lower(category) AS category, count(*), category AS __pgdog_group_0 \
+ FROM items GROUP BY category",
+ ),
+ vec![2],
+ ),
+ ] {
+ let ast = pg_raw_parse::parse(sql).unwrap();
+ let Some(Node::SelectStmt(select)) = ast.stmts().next() else {
+ panic!("expected SELECT")
+ };
+ let rewrite = build(&ast, &schema, false).unwrap();
+ assert_eq!(
+ rewrite.as_ref().map(|rewrite| rewrite.sql.as_ref()),
+ shard_sql,
+ "{sql}"
+ );
+ let aggregate = match rewrite.as_ref().and_then(|rewrite| rewrite.plan.as_ref()) {
+ Some(plan) => plan.aggregate().expect("GROUP BY plan").clone(),
+ None => Aggregate::parse(select, &schema),
+ };
+ assert_eq!(aggregate.group_by(), group_by, "{sql}");
+ }
+ }
+
+ #[test]
+ fn group_by_select_alias_is_rejected_when_from_is_not_known() {
+ let loaded = items_schema();
+ let not_loaded = Schema::default();
+ for (sql, schema) in [
+ (
+ "SELECT lower(category) AS c, count(*) FROM unknown GROUP BY c",
+ &loaded,
+ ),
+ (
+ "SELECT lower(category) AS c, count(*) FROM (SELECT * FROM items) i GROUP BY c",
+ &loaded,
+ ),
+ (
+ "WITH items AS (SELECT 1 AS c) SELECT c + 1 AS c, count(*) FROM items GROUP BY c",
+ &loaded,
+ ),
+ (
+ "SELECT lower(category) AS c, count(*) FROM items AS i (c, d, e) GROUP BY c",
+ &loaded,
+ ),
+ (
+ "SELECT lower(category) AS ctid, count(*) FROM items GROUP BY ctid",
+ &loaded,
+ ),
+ (
+ "SELECT lower(category) AS c, count(*) FROM items GROUP BY c HAVING count(*) > 1",
+ ¬_loaded,
+ ),
+ ] {
+ let ast = pg_raw_parse::parse(sql).unwrap();
+ let error = build(&ast, schema, false).unwrap_err();
+ assert!(
+ matches!(
+ error,
+ Error::UnsupportedGroupBy(_) | Error::UnsupportedHaving(_)
+ ),
+ "{sql}"
+ );
+ }
+ }
+
+ #[test]
+ fn having_groups_by_alias_and_expression() {
+ let schema = items_schema();
+ // (query, shard query, merged GROUP BY columns)
+ for (sql, shard_sql, group_by) in [
+ (
+ "SELECT lower(category) AS c, count(*) FROM items GROUP BY c HAVING count(*) > 1",
+ "SELECT lower(category) AS c, count(*), count(*) AS __pgdog_having_0 \
+ FROM items GROUP BY c HAVING count(*) > 1 OR true",
+ vec![0],
+ ),
+ (
+ "SELECT count(*) FROM items GROUP BY lower(category), 1 HAVING count(*) > 1",
+ "SELECT count(*), count(*) AS __pgdog_having_0, lower(category) AS __pgdog_having_1 \
+ FROM items GROUP BY lower(category), 1 HAVING count(*) > 1 OR true",
+ vec![2, 0],
+ ),
+ ] {
+ let ast = pg_raw_parse::parse(sql).unwrap();
+ let rewrite = build(&ast, &schema, false)
+ .unwrap()
+ .expect("HAVING requires a rewrite");
+ assert_eq!(rewrite.sql.as_ref(), shard_sql, "{sql}");
+ let plan = rewrite.plan.expect("projection plan");
+ let aggregate = plan.having.as_ref().expect("HAVING plan").aggregate();
+ assert_eq!(aggregate.group_by(), group_by, "{sql}");
+ }
+ }
+
#[test]
fn unsupported_having_queries_fail_closed() {
for sql in [
- // Groups can only be matched across shards on columns and ordinals.
- "SELECT lower(customer_id), COUNT(*) FROM purchases \
- GROUP BY lower(customer_id) HAVING COUNT(*) > 2",
// Star expansion shifts the positions aggregates are merged by.
"SELECT * FROM purchases GROUP BY customer_id HAVING COUNT(*) > 2",
"SELECT p.*, COUNT(*) FROM purchases p GROUP BY customer_id HAVING COUNT(*) > 2",
^ permalink raw [nested|flat] 8+ messages in thread
* Re: [pgdogdev/pgdog] PR #2050: feat: cross-shard GROUP BY on SELECT aliases, and alias/expression keys with HAVING
@ 2026-11-17 17:02 "codecov[bot] (bot) (@codecov[bot])" <noreply+codecov[bot]@github.com>
6 siblings, 0 replies; 8+ messages in thread
From: codecov[bot] (bot) (@codecov[bot]) @ 2026-11-17 17:02 UTC (permalink / raw)
To: pgdogdev/pgdog <noreply+pgdogdev-pgdog@github.com>
## [Codecov](https://app.codecov.io/gh/pgdogdev/pgdog/pull/2050?dropdown=coverage&src=pr&el=h1&utm_me...) Report
:x: Patch coverage is `97.26027%` with `8 lines` in your changes missing coverage. Please review.
| [Files with missing lines](https://app.codecov.io/gh/pgdogdev/pgdog/pull/2050?dropdown=coverage&src=pr&el=tree&utm_...) | Patch % | Lines |
|---|---|---|
| [pgdog/src/frontend/router/parser/aggregate.rs](https://app.codecov.io/gh/pgdogdev/pgdog/pull/2050?src=pr&el=tree&utm_medium=referral&ut...) | 97.58% | [3 Missing :warning: ](https://app.codecov.io/gh/pgdogdev/pgdog/pull/2050?src=pr&el=tree&utm_medium=referral&ut...) |
| [...ontend/router/parser/rewrite/statement/group\_by.rs](https://app.codecov.io/gh/pgdogdev/pgdog/pull/2050?src=pr&el=tree&utm_medium=referral&ut...) | 81.81% | [2 Missing :warning: ](https://app.codecov.io/gh/pgdogdev/pgdog/pull/2050?src=pr&el=tree&utm_medium=referral&ut...) |
| [...tend/router/parser/rewrite/statement/projection.rs](https://app.codecov.io/gh/pgdogdev/pgdog/pull/2050?src=pr&el=tree&utm_medium=referral&ut...) | 98.59% | [2 Missing :warning: ](https://app.codecov.io/gh/pgdogdev/pgdog/pull/2050?src=pr&el=tree&utm_medium=referral&ut...) |
| [...frontend/router/parser/rewrite/statement/having.rs](https://app.codecov.io/gh/pgdogdev/pgdog/pull/2050?src=pr&el=tree&utm_medium=referral&ut...) | 93.33% | [1 Missing :warning: ](https://app.codecov.io/gh/pgdogdev/pgdog/pull/2050?src=pr&el=tree&utm_medium=referral&ut...) |
:loudspeaker: Thoughts on this report? [Let us know!](https://github.com/codecov/feedback/issues/255)
^ permalink raw [nested|flat] 8+ messages in thread
* Re: [pgdogdev/pgdog] PR #2050: feat: cross-shard GROUP BY on SELECT aliases, and alias/expression keys with HAVING
@ 2026-11-17 17:41 "github-actions[bot] (bot) (@github-actions[bot])" <noreply+github-actions[bot]@github.com>
6 siblings, 0 replies; 8+ messages in thread
From: github-actions[bot] (bot) (@github-actions[bot]) @ 2026-11-17 17:41 UTC (permalink / raw)
To: pgdogdev/pgdog <noreply+pgdogdev-pgdog@github.com>
<!-- metal-bench -->
**Metal bench (arm64) failed.** 5 of 520 measures outside bounds.
| suite | throughput | cpu/txn | user cycles/txn | user instr/txn | kernel cycles/txn | kernel instr/txn | ctx/txn |
|---|---|---|---|---|---|---|---|
| pooler | | 19.02 (-0.1% ± 2.5%) | 17,950 (+0.2% ± 1.2%) | 31,403 (-0.0% ± 0.10%) | 30,733 (-0.2% ± 5.0%) | 51,020 (-0.0% ± 0.3%) | |
| lb | | 19.66 (+0.1% ± 1.5%) | 18,627 (+0.3% ± 1.1%) | 32,315 (-0.0% ± 0.03%) | 31,509 (-0.2% ± 2.7%) | 52,139 (-0.1% ± 0.4%) | |
| sharding-w2 | | 32.14 (+0.2% ± 1.2%) | 43,493 (+0.0% ± 1.2%) | 94,929 (+0.0% ± 0.01%) | 40,047 (+0.6% ± 2.2%) | 53,712 (-0.0% ± 0.1%) | 1.548 (-0.0% ± 0.2%) |
| sharding-w8 | 248,256 (+0.0% ± 2.3%) | 28.75 (+0.0% ± 2.6%) | 44,564 (+0.6% ± 0.7%) | 50,475 (+0.0% ± 0.2%) | 34,809 (-0.8% ± 5.4%) | 42,363 (-0.0% ± 0.1%) | 0.1705 (-0.7% ± 3.7%) |
<details><summary>Counters per txn</summary>
| suite | frontend stall | l1i refill | backend stall |
|---|---|---|---|
| pooler | 7,536 (+0.8% ± 2.8%) | 2,647 (+0.1% ± 1.1%) | |
| lb | 8,016 (+1.2% ± 3.0%) | 2,715 (+0.4% ± 1.3%) | |
| sharding-w2 | 17,897 (+0.4% ± 2.8%) | 4,162 (+0.5% ± 2.0%) | |
| sharding-w8 | 20,075 (+0.1% ± 1.3%) | 4,132 (-0.1% ± 1.6%) | |
</details>
| benchmark | measure | result | baseline | change | bound |
|---|---|---|---|---|---|
| extended_cached::aggregate | instructions | 17,667 | 17,403 | **+1.52% ± 0.00%** | +1% |
| extended_cold::begin | instructions | 11,325 | 11,088 | **+2.14% ± 0.00%** | +1% |
| extended_cold::set | instructions | 15,171 | 14,722 | **+3.05% ± 0.00%** | +1% |
| full_named_cached::aggregate | instructions | 136,288 | 134,359 | **+1.44% ± 0.00%** | +1% |
| full_named_cached::order_limit_offset | instructions | 185,783 | 182,864 | **+1.60% ± 0.00%** | +1% |
Microbench: 502 of 507 measures within bounds.
<details><summary>Hot code per txn</summary>
| path | base | head | change |
|---|---|---|---|
| pooler | 113.1 KB | 113.9 KB | **+0.8 KB** |
| sharding-w2 | 169.3 KB | 167.8 KB | **-1.5 KB** |
pooler:
| crate | base | head | change |
|---|---|---|---|
| pgdog::frontend::client::query_engine | 19.7 KB | 20.2 KB | +0.5 KB |
| tokio | 18.5 KB | 18.4 KB | -0.1 KB |
| pgdog::backend::pool | 17.8 KB | 17.5 KB | -0.2 KB |
| aws-lc (TLS crypto) | 10.1 KB | 10.1 KB | +0.0 KB |
| rustls (TLS) | 8.3 KB | 8.4 KB | +0.1 KB |
| pgdog::frontend (other) | 7.8 KB | 8.0 KB | +0.2 KB |
| pgdog::backend::server | 7.8 KB | 7.8 KB | -0.1 KB |
| other | 5.8 KB | 6.3 KB | +0.6 KB |
| everything else | 17.4 KB | 17.2 KB | -0.2 KB |
| function | head | change |
|---|---|---|
| `pgdog::frontend::client::Client::run::{{closure}}` | 5.6 KB | +0.2 KB |
| `pgdog::frontend::client::query_engine::query::<impl pgdog::frontend::client::query_engine:` | 5.4 KB | +0.2 KB |
| `pgdog::frontend::client::query_engine::QueryEngine::handle::{{closure}}` | 4.1 KB | +0.1 KB |
| `pgdog::frontend::client::query_engine::query::<impl pgdog::frontend::client::query_engine:` | 3.4 KB | +0.1 KB |
| `tokio::runtime::task::raw::poll` | 3.1 KB | -0.2 KB |
sharding-w2:
| crate | base | head | change |
|---|---|---|---|
| pgdog::frontend::router | 29.4 KB | 29.2 KB | -0.2 KB |
| pgdog::frontend::client::query_engine | 21.2 KB | 21.0 KB | -0.2 KB |
| tokio | 18.7 KB | 18.5 KB | -0.2 KB |
| pgdog::backend::pool | 18.4 KB | 18.2 KB | -0.2 KB |
| aws-lc (TLS crypto) | 13.2 KB | 13.1 KB | -0.1 KB |
| other | 10.0 KB | 10.2 KB | +0.2 KB |
| pgdog::frontend (other) | 9.1 KB | 9.1 KB | +0.0 KB |
| rustls (TLS) | 8.1 KB | 8.2 KB | +0.1 KB |
| everything else | 41.2 KB | 40.4 KB | -0.8 KB |
| function | head | change |
|---|---|---|
| `pgdog::frontend::client::Client::run::{{closure}}` | 6.4 KB | +0.1 KB |
| `pgdog::frontend::client::query_engine::query::<impl pgdog::frontend::client::query_engine:` | 5.1 KB | +0.0 KB |
| `pgdog::frontend::router::parser::query::select::<impl pgdog::frontend::router::parser::que` | 3.9 KB | +0.6 KB |
| `pgdog::frontend::client::query_engine::QueryEngine::handle::{{closure}}` | 3.9 KB | -0.1 KB |
| `tokio::runtime::task::raw::poll` | 3.3 KB | +0.1 KB |
</details>
<details><summary>lb flamegraph vs 0eda9a90</summary>

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results/murex-group-by-alias/6d5f51818ae7f85fa74910bb93f4...) for hover, zoom and search.

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results/murex-group-by-alias/6d5f51818ae7f85fa74910bb93f4...).
</details>
<details><summary>microbench flamegraph vs 0eda9a90</summary>

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results/murex-group-by-alias/6d5f51818ae7f85fa74910bb93f4...) for hover, zoom and search.

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results/murex-group-by-alias/6d5f51818ae7f85fa74910bb93f4...).
</details>
<details><summary>pooler flamegraph vs 0eda9a90</summary>

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results/murex-group-by-alias/6d5f51818ae7f85fa74910bb93f4...) for hover, zoom and search.

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results/murex-group-by-alias/6d5f51818ae7f85fa74910bb93f4...).
</details>
<details><summary>sharding-w2 flamegraph vs 0eda9a90</summary>

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results/murex-group-by-alias/6d5f51818ae7f85fa74910bb93f4...) for hover, zoom and search.

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results/murex-group-by-alias/6d5f51818ae7f85fa74910bb93f4...).
</details>
<details><summary>sharding-w8 flamegraph vs 0eda9a90</summary>

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results/murex-group-by-alias/6d5f51818ae7f85fa74910bb93f4...) for hover, zoom and search.

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results/murex-group-by-alias/6d5f51818ae7f85fa74910bb93f4...).
</details>
<details><summary>Logs</summary>
[lb](https://s3.console.aws.amazon.com/s3/object/pgdog-metal-bench?prefix=results/murex-group-by-alias/6d...), [microbench](https://s3.console.aws.amazon.com/s3/object/pgdog-metal-bench?prefix=results/murex-group-by-alias/6d...), [pooler](https://s3.console.aws.amazon.com/s3/object/pgdog-metal-bench?prefix=results/murex-group-by-alias/6d...), [sharding-w2](https://s3.console.aws.amazon.com/s3/object/pgdog-metal-bench?prefix=results/murex-group-by-alias/6d...), [sharding-w8](https://s3.console.aws.amazon.com/s3/object/pgdog-metal-bench?prefix=results/murex-group-by-alias/6d...), [verdict.json](https://s3.console.aws.amazon.com/s3/object/pgdog-metal-bench?prefix=results/murex-group-by-alias/6d...)
</details>
Compared 6d5f5181 with 0eda9a90 on m8g.metal-24xl (spot).
^ permalink raw [nested|flat] 8+ messages in thread
* Re: [pgdogdev/pgdog] PR #2050: feat: cross-shard GROUP BY on SELECT aliases, and alias/expression keys with HAVING
@ 2026-11-17 17:42 "github-actions[bot] (bot) (@github-actions[bot])" <noreply+github-actions[bot]@github.com>
6 siblings, 0 replies; 8+ messages in thread
From: github-actions[bot] (bot) (@github-actions[bot]) @ 2026-11-17 17:42 UTC (permalink / raw)
To: pgdogdev/pgdog <noreply+pgdogdev-pgdog@github.com>
<!-- metal-bench-x86 -->
**Metal bench (x86) failed.** 3 of 520 measures outside bounds.
| suite | throughput | cpu/txn | user cycles/txn | user instr/txn | kernel cycles/txn | kernel instr/txn | ctx/txn |
|---|---|---|---|---|---|---|---|
| pooler | | 34.77 (+0.1% ± 0.2%) | 23,014 (+0.3% ± 0.4%) | 32,727 (-0.0% ± 0.02%) | 57,966 (+0.0% ± 0.5%) | 38,572 (-0.0% ± 0.3%) | |
| lb | | 35.81 (+0.0% ± 0.3%) | 24,242 (+0.0% ± 1.3%) | 33,687 (-0.0% ± 0.03%) | 58,945 (-0.0% ± 0.3%) | 39,199 (+0.0% ± 0.2%) | |
| sharding-w2 | | 56.42 (+0.2% ± 1.3%) | 53,368 (+0.7% ± 1.6%) | 98,582 (+0.0% ± 0.01%) | 72,963 (+0.0% ± 1.9%) | 43,083 (-0.0% ± 0.8%) | 1.39 (-0.1% ± 0.4%) |
| sharding-w8 | 147,151 (-0.1% ± 3.1%) | 48.64 (+0.3% ± 2.3%) | 58,048 (-0.1% ± 0.8%) | 54,061 (+0.0% ± 0.2%) | 65,538 (+0.6% ± 4.3%) | 34,230 (-0.0% ± 0.3%) | 0.1711 (+0.9% ± 3.6%) |
<details><summary>Counters per txn</summary>
| suite | frontend stall | l1i refill | backend stall |
|---|---|---|---|
| pooler | 74,526 (+0.4% ± 0.6%) | 3,661 (-0.1% ± 0.09%) | |
| lb | 77,641 (-0.1% ± 1.6%) | 3,795 (-0.1% ± 0.2%) | |
| sharding-w2 | 162,484 (+1.1% ± 4.4%) | 6,199 (+1.7% ± 0.8%) | |
| sharding-w8 | 124,392 (+0.8% ± 3.8%) | 5,049 (+1.4% ± 0.5%) | |
</details>
| benchmark | measure | result | baseline | change | bound |
|---|---|---|---|---|---|
| full_named_cached::aggregate | instructions | 143,248 | 140,659 | **+1.84% ± 0.00%** | +1% |
| full_named_cached::order_limit_offset | instructions | 199,167 | 194,907 | **+2.19% ± 0.00%** | +1% |
| simple_cold::set | instructions | 13,644 | 13,367 | **+2.07% ± 0.00%** | +1% |
Microbench: 504 of 507 measures within bounds.
<details><summary>Microbench latency: 1 benches changed more than 3%</summary>
| benchmark | latency | baseline | change | instructions change |
|---|---|---|---|---|
| extended_cached::having | 3,069 ns | 2,976 ns | +3.13% ± 0.36% | +0.07% ± 0.00% |
</details>
<details><summary>Hot code per txn</summary>
| path | base | head | change |
|---|---|---|---|
| pooler | 107.4 KB | 110.2 KB | **+2.8 KB** |
| sharding-w2 | 165.1 KB | 167.5 KB | **+2.4 KB** |
pooler:
| crate | base | head | change |
|---|---|---|---|
| pgdog::frontend::client::query_engine | 21.2 KB | 21.9 KB | +0.6 KB |
| tokio | 17.6 KB | 17.8 KB | +0.2 KB |
| pgdog::backend::pool | 16.6 KB | 17.2 KB | +0.6 KB |
| pgdog::frontend (other) | 9.1 KB | 8.9 KB | -0.2 KB |
| pgdog::backend::server | 7.2 KB | 7.8 KB | +0.5 KB |
| aws-lc (TLS crypto) | 7.1 KB | 7.6 KB | +0.6 KB |
| rustls (TLS) | 6.9 KB | 7.0 KB | +0.1 KB |
| other | 5.6 KB | 5.9 KB | +0.3 KB |
| everything else | 16.1 KB | 16.1 KB | +0.1 KB |
| function | head | change |
|---|---|---|
| `pgdog::frontend::client::Client::run::{{closure}}` | 6.8 KB | -0.3 KB |
| `pgdog::frontend::client::query_engine::query::<impl pgdog::frontend::client::query_engine:` | 6.4 KB | +0.1 KB |
| `pgdog::frontend::client::query_engine::QueryEngine::handle::{{closure}}` | 4.8 KB | +0.4 KB |
| `pgdog::frontend::client::query_engine::query::<impl pgdog::frontend::client::query_engine:` | 3.9 KB | +0.1 KB |
| `tokio::runtime::task::raw::poll` | 3.6 KB | +0.1 KB |
sharding-w2:
| crate | base | head | change |
|---|---|---|---|
| pgdog::frontend::router | 26.4 KB | 27.6 KB | +1.1 KB |
| pgdog::frontend::client::query_engine | 23.4 KB | 23.4 KB | +0.0 KB |
| pgdog::backend::pool | 18.4 KB | 18.9 KB | +0.4 KB |
| tokio | 18.2 KB | 18.6 KB | +0.4 KB |
| other | 10.4 KB | 10.6 KB | +0.2 KB |
| aws-lc (TLS crypto) | 9.8 KB | 10.4 KB | +0.6 KB |
| pgdog::frontend (other) | 10.2 KB | 9.9 KB | -0.2 KB |
| jemalloc | 8.9 KB | 8.8 KB | -0.1 KB |
| everything else | 39.4 KB | 39.4 KB | +0.0 KB |
| function | head | change |
|---|---|---|
| `pgdog::frontend::client::Client::run::{{closure}}` | 7.5 KB | -0.2 KB |
| `pgdog::frontend::client::query_engine::query::<impl pgdog::frontend::client::query_engine:` | 6.2 KB | -0.1 KB |
| `pgdog::frontend::client::query_engine::QueryEngine::handle::{{closure}}` | 4.6 KB | +0.0 KB |
| `pgdog::frontend::router::parser::query::select::<impl pgdog::frontend::router::parser::que` | 4.4 KB | +0.5 KB |
| `tokio::runtime::task::raw::poll` | 3.9 KB | +0.1 KB |
</details>
<details><summary>lb flamegraph vs 0eda9a90</summary>

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results-x86/murex-group-by-alias/6d5f51818ae7f85fa74910bb...) for hover, zoom and search.

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results-x86/murex-group-by-alias/6d5f51818ae7f85fa74910bb...).
</details>
<details><summary>microbench flamegraph vs 0eda9a90</summary>

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results-x86/murex-group-by-alias/6d5f51818ae7f85fa74910bb...) for hover, zoom and search.

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results-x86/murex-group-by-alias/6d5f51818ae7f85fa74910bb...).
</details>
<details><summary>pooler flamegraph vs 0eda9a90</summary>

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results-x86/murex-group-by-alias/6d5f51818ae7f85fa74910bb...) for hover, zoom and search.

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results-x86/murex-group-by-alias/6d5f51818ae7f85fa74910bb...).
</details>
<details><summary>sharding-w2 flamegraph vs 0eda9a90</summary>

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results-x86/murex-group-by-alias/6d5f51818ae7f85fa74910bb...) for hover, zoom and search.

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results-x86/murex-group-by-alias/6d5f51818ae7f85fa74910bb...).
</details>
<details><summary>sharding-w8 flamegraph vs 0eda9a90</summary>

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results-x86/murex-group-by-alias/6d5f51818ae7f85fa74910bb...) for hover, zoom and search.

[Open interactive](https://pgdog-metal-bench.s3.amazonaws.com/results-x86/murex-group-by-alias/6d5f51818ae7f85fa74910bb...).
</details>
<details><summary>Logs</summary>
[lb](https://s3.console.aws.amazon.com/s3/object/pgdog-metal-bench?prefix=results-x86/murex-group-by-alia...), [microbench](https://s3.console.aws.amazon.com/s3/object/pgdog-metal-bench?prefix=results-x86/murex-group-by-alia...), [pooler](https://s3.console.aws.amazon.com/s3/object/pgdog-metal-bench?prefix=results-x86/murex-group-by-alia...), [sharding-w2](https://s3.console.aws.amazon.com/s3/object/pgdog-metal-bench?prefix=results-x86/murex-group-by-alia...), [sharding-w8](https://s3.console.aws.amazon.com/s3/object/pgdog-metal-bench?prefix=results-x86/murex-group-by-alia...), [verdict.json](https://s3.console.aws.amazon.com/s3/object/pgdog-metal-bench?prefix=results-x86/murex-group-by-alia...)
</details>
Compared 6d5f5181 with 0eda9a90 on c7a.metal-48xl (spot).
^ permalink raw [nested|flat] 8+ messages in thread
* Re: [pgdogdev/pgdog] PR #2050: feat: cross-shard GROUP BY on SELECT aliases, and alias/expression keys with HAVING
@ 2026-11-18 20:00 "levkk (@levkk)" <noreply+levkk@github.com>
6 siblings, 0 replies; 8+ messages in thread
From: levkk (@levkk) @ 2026-11-18 20:00 UTC (permalink / raw)
To: pgdogdev/pgdog <noreply+pgdogdev-pgdog@github.com>
(on pgdog/src/frontend/router/parser/aggregate.rs:266)
nit: don't think most of these need to be `pub(crate)`.
^ permalink raw [nested|flat] 8+ messages in thread
* Re: [pgdogdev/pgdog] PR #2050 (approved): feat: cross-shard GROUP BY on SELECT aliases, and alias/expression keys with HAVING
@ 2026-11-18 20:01 "levkk (@levkk)" <noreply+levkk@github.com>
6 siblings, 0 replies; 8+ messages in thread
From: levkk (@levkk) @ 2026-11-18 20:01 UTC (permalink / raw)
To: pgdogdev/pgdog <noreply+pgdogdev-pgdog@github.com>
^ permalink raw [nested|flat] 8+ messages in thread
* Re: [pgdogdev/pgdog] PR #2050: feat: cross-shard GROUP BY on SELECT aliases, and alias/expression keys with HAVING
@ 2026-11-19 12:30 "murex971 (@murex971)" <noreply+murex971@github.com>
6 siblings, 0 replies; 8+ messages in thread
From: murex971 (@murex971) @ 2026-11-19 12:30 UTC (permalink / raw)
To: pgdogdev/pgdog <noreply+pgdogdev-pgdog@github.com>
@murex971 closed this.
^ permalink raw [nested|flat] 8+ messages in thread
* Re: [pgdogdev/pgdog] PR #2050: feat: cross-shard GROUP BY on SELECT aliases, and alias/expression keys with HAVING
@ 2026-11-19 12:30 "murex971 (@murex971)" <noreply+murex971@github.com>
6 siblings, 0 replies; 8+ messages in thread
From: murex971 (@murex971) @ 2026-11-19 12:30 UTC (permalink / raw)
To: pgdogdev/pgdog <noreply+pgdogdev-pgdog@github.com>
@murex971 merged this (commit fbad51d6d85d).
^ permalink raw [nested|flat] 8+ messages in thread
end of thread, other threads:[~2026-11-19 12:30 UTC | newest]
Thread overview: 8+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
2026-11-17 16:58 [pgdogdev/pgdog] PR #2050: feat: cross-shard GROUP BY on SELECT aliases, and alias/expression keys with HAVING "murex971 (@murex971)" <noreply+murex971@github.com>
2026-11-17 17:02 ` "codecov[bot] (bot) (@codecov[bot])" <noreply+codecov[bot]@github.com>
2026-11-17 17:41 ` "github-actions[bot] (bot) (@github-actions[bot])" <noreply+github-actions[bot]@github.com>
2026-11-17 17:42 ` "github-actions[bot] (bot) (@github-actions[bot])" <noreply+github-actions[bot]@github.com>
2026-11-18 20:00 ` "levkk (@levkk)" <noreply+levkk@github.com>
2026-11-18 20:01 ` Re: [pgdogdev/pgdog] PR #2050 (approved): feat: cross-shard GROUP BY on SELECT aliases, and alias/expression keys with HAVING "levkk (@levkk)" <noreply+levkk@github.com>
2026-11-19 12:30 ` "murex971 (@murex971)" <noreply+murex971@github.com>
2026-11-19 12:30 ` "murex971 (@murex971)" <noreply+murex971@github.com>
This inbox is served by DDX for PostgreSQL; see mirroring instructions
for how to clone and mirror all data and code used for this inbox