fix: support aggregation with non-equality conditions in scalar subqueries by ck89119 · Pull Request #24053 · matrixorigin/matrixone

ck89119 · 2026-04-03T15:02:50Z

What type of PR is this?

BUG

Which issue(s) this PR fixes:

What this PR does / why we need it:

When a scalar subquery contains an aggregate function with non-equality correlated predicates (e.g. <, >=), the planner rejected it with a NYI error.

Root cause: pullupThroughAgg adds inner expressions from non-eq predicates to GROUP BY, producing multiple rows per outer row, which breaks SINGLE JOIN semantics.

Fix: Bypass the inner AGG, use LEFT JOIN with all predicates applied directly to the raw inner rows, then add a new AGG on top that groups by outer columns. This way the aggregate operates on all matching rows correctly. Also converts starcount to count(inner_col) so that NULL rows from LEFT JOIN are not counted.

…eries (matrixorigin#23942) When a scalar subquery contains an aggregate function with non-equality correlated predicates (e.g. <, >=), the planner rejected it with NYI. The root cause: pullupThroughAgg adds inner expressions from non-eq predicates to GROUP BY, producing multiple rows per outer row, which breaks SINGLE JOIN semantics. Fix: bypass the inner AGG, use LEFT JOIN with all predicates applied directly to the raw inner rows, then add a new AGG on top that groups by outer columns. This way the aggregate operates on all matching rows correctly. Also converts starcount to count(inner_col) so that NULL rows from LEFT JOIN are not counted.

qodo-code-review · 2026-04-03T15:03:15Z

Review Summary by Qodo

Support aggregation with non-equality conditions in scalar subqueries

🐞 Bug fix

Walkthroughs

Description

• Support aggregation with non-equality conditions in scalar subqueries
• Bypass inner AGG and use LEFT JOIN with re-aggregation on top
• Replace starcount with count(inner_col) to handle NULL rows correctly
• Convert NULL aggregate results to 0 for COUNT functions

Diagram

flowchart LR
  A["Scalar Subquery<br/>with Non-Eq Agg"] --> B["Bypass Inner AGG"]
  B --> C["LEFT JOIN<br/>All Predicates"]
  C --> D["New AGG<br/>Group by Outer Cols"]
  D --> E["Replace starcount<br/>with count"]
  E --> F["Handle NULL<br/>Results"]

File Changes

1. pkg/sql/plan/build_test.go 🧪 Tests +1/-1

Add test for non-equality aggregate scalar subquery

• Added test case for non-equality aggregate scalar subquery
• Moved previously failing test from error cases to passing cases
• Test validates `SELECT * FROM NATION where N_REGIONKEY > (select max(R_REGIONKEY) from REGION
 where R_REGIONKEY < N_REGIONKEY)`

pkg/sql/plan/build_test.go

2. pkg/sql/plan/flatten_subquery.go 🐞 Bug fix +216/-5

Implement aggregation with non-equality predicates handling

• Replaced NYI error with new flattenScalarSubqueryWithNonEqAgg function implementation
• Added helper functions: findAggNodeBelow, getFirstColRef, replaceGroupTagRefs
• Implements LEFT JOIN strategy with re-aggregation on outer columns
• Converts starcount to count(inner_col) to skip NULL rows from LEFT JOIN
• Wraps COUNT results with CASE/ISNULL to convert NULL to 0

pkg/sql/plan/flatten_subquery.go

3. test/distributed/cases/dml/select/subquery.result 🧪 Tests +120/-103

Update test results for non-equality aggregate subqueries

• Updated test results to show successful execution of previously failing queries
• Queries with non-equality aggregate scalar subqueries now return correct results
• Formatting changes: tabs replaced with spaces for consistency
• Multiple test cases now pass that previously returned NYI errors

test/distributed/cases/dml/select/subquery.result

qodo-code-review · 2026-04-03T15:03:16Z

Code Review by Qodo

🐞 Bugs (0) 📘 Rule violations (0) 📎 Requirement gaps (0) 🎨 UX Issues (0)

1. ~~Outer duplicates collapsed~~ ☑ 🐞 ≡

Description

flattenScalarSubqueryWithNonEqAgg groups by all outer columns, which collapses duplicate outer rows
when the outer source is a subquery/derived table (no hidden row identity), changing scalar
correlated subquery semantics. The scalar aggregate can be evaluated once per distinct outer values
instead of once per outer row.

Code

pkg/sql/plan/flatten_subquery.go[R497-565]

+	// Collect outer columns for GROUP BY.
+	// Reuse the outer binding tag as the AGG's group tag so that existing
+	// column references to the outer table remain valid after the AGG.
+	if len(ctx.bindings) == 0 {
+		return 0, nil, moerr.NewNYIf(builder.GetContext(),
+			"aggregation with non equal predicate in scalar subquery will be supported in future version")
+	}
+	var outerGroupBy []*plan.Expr
+	for _, binding := range ctx.bindings {
+		for i := range binding.cols {
+			outerGroupBy = append(outerGroupBy, &plan.Expr{
+				Typ:  *binding.types[i],
+				Expr: &plan.Expr_Col{Col: &plan.ColRef{RelPos: binding.tag, ColPos: int32(i)}},
+			})
+		}
+	}
+	// Use the first outer binding's tag as groupTag so outer column refs
+	// (RelPos == binding.tag) resolve through the AGG node directly.
+	reuseGroupTag := ctx.bindings[0].tag
+
+	// Build the aggregate expressions — deep copy so we don't mutate the
+	// original AGG node.
+	aggExprs := make([]*plan.Expr, len(aggNode.AggList))
+	for i, agg := range aggNode.AggList {
+		aggExprs[i] = DeepCopyExpr(agg)
+	}
+
+	// LEFT JOIN produces a NULL row for non-matching outer rows.
+	// starcount/count(*) would count that NULL row as 1 instead of 0.
+	// Fix: replace starcount(const) with count(inner_col) so NULLs are
+	// skipped.  We pick the first column from the inner scan node.
+	for _, agg := range aggExprs {
+		if f, ok := agg.Expr.(*plan.Expr_F); ok && f.F.Func.ObjName == "starcount" {
+			innerCol := builder.getFirstColRef(innerID)
+			if innerCol == nil {
+				continue
+			}
+			argType := makeTypeByPlan2Expr(innerCol)
+			fGet, err := function.GetFunctionByName(builder.GetContext(), "count", []types.Type{argType})
+			if err != nil {
+				return 0, nil, err
+			}
+			f.F.Func.ObjName = "count"
+			f.F.Func.Obj = fGet.GetEncodedOverloadID()
+			f.F.Args = []*plan.Expr{innerCol}
+			retType := fGet.GetReturnType()
+			agg.Typ = makePlan2Type(&retType)
+		}
+	}
+
+	// LEFT JOIN outer with inner scan, all predicates as join conditions
+	nodeID = builder.appendNode(&plan.Node{
+		NodeType: plan.Node_JOIN,
+		Children: []int32{nodeID, innerID},
+		JoinType: plan.Node_LEFT,
+		OnList:   joinPreds,
+		SpillMem: builder.joinSpillMem,
+	}, ctx)
+
+	// New AGG: group by outer columns, compute aggregates on raw inner rows
+	newAggTag := builder.genNewBindTag()
+	nodeID = builder.appendNode(&plan.Node{
+		NodeType:    plan.Node_AGG,
+		Children:    []int32{nodeID},
+		GroupBy:     outerGroupBy,
+		AggList:     aggExprs,
+		BindingTags: []int32{reuseGroupTag, newAggTag},
+		SpillMem:    builder.aggSpillMem,
+	}, ctx)

Evidence

The rewrite builds outerGroupBy by iterating every column of every outer binding and then creates
a new AGG with GroupBy: outerGroupBy. For derived-table bindings, the planner explicitly marks all
columns as non-hidden (no hidden Row_ID/row identity), so grouping by these columns can merge
identical outer rows.

pkg/sql/plan/flatten_subquery.go[497-565]
pkg/sql/plan/query_builder.go[5144-5188]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The new LEFT JOIN + re-AGG rewrite groups by all outer columns, which collapses duplicate outer rows when the outer input does not carry a unique row-identity column (common for derived tables/subqueries). This violates correlated scalar subquery semantics (evaluation per outer row).
### Issue Context
Derived-table bindings are created with `colIsHidden[i] = false` for every column, so there is no hidden `Row_ID` to preserve per-row identity.
### Fix Focus Areas
- pkg/sql/plan/flatten_subquery.go[497-565]
- pkg/sql/plan/query_builder.go[5144-5188]
### Suggested fix direction
- Ensure the re-AGG groups by a stable per-row identity from the outer input.
- Prefer grouping by an existing non-null unique hidden column (e.g., `catalog.Row_ID`) **if present**.
- If not present (derived tables), inject a synthetic per-row key before the LEFT JOIN (e.g., a window `row_number()` / internal unique sequence) and include it in `GroupBy`.
- Add a regression test where the outer side is a derived table producing duplicate rows and verify results are not collapsed.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

2. ~~Outer join tags break~~ ☑ 🐞 ≡

Description

The inserted AGG only exposes BindingTags: []int32{reuseGroupTag, newAggTag} using the first outer
binding’s tag, so columns from other outer bindings/tags become inaccessible above the AGG. In
multi-table outer queries, this can lead to invalid column references or wrong results after the
rewrite.

Code

pkg/sql/plan/flatten_subquery.go[R504-565]

+	var outerGroupBy []*plan.Expr
+	for _, binding := range ctx.bindings {
+		for i := range binding.cols {
+			outerGroupBy = append(outerGroupBy, &plan.Expr{
+				Typ:  *binding.types[i],
+				Expr: &plan.Expr_Col{Col: &plan.ColRef{RelPos: binding.tag, ColPos: int32(i)}},
+			})
+		}
+	}
+	// Use the first outer binding's tag as groupTag so outer column refs
+	// (RelPos == binding.tag) resolve through the AGG node directly.
+	reuseGroupTag := ctx.bindings[0].tag
+
+	// Build the aggregate expressions — deep copy so we don't mutate the
+	// original AGG node.
+	aggExprs := make([]*plan.Expr, len(aggNode.AggList))
+	for i, agg := range aggNode.AggList {
+		aggExprs[i] = DeepCopyExpr(agg)
+	}
+
+	// LEFT JOIN produces a NULL row for non-matching outer rows.
+	// starcount/count(*) would count that NULL row as 1 instead of 0.
+	// Fix: replace starcount(const) with count(inner_col) so NULLs are
+	// skipped.  We pick the first column from the inner scan node.
+	for _, agg := range aggExprs {
+		if f, ok := agg.Expr.(*plan.Expr_F); ok && f.F.Func.ObjName == "starcount" {
+			innerCol := builder.getFirstColRef(innerID)
+			if innerCol == nil {
+				continue
+			}
+			argType := makeTypeByPlan2Expr(innerCol)
+			fGet, err := function.GetFunctionByName(builder.GetContext(), "count", []types.Type{argType})
+			if err != nil {
+				return 0, nil, err
+			}
+			f.F.Func.ObjName = "count"
+			f.F.Func.Obj = fGet.GetEncodedOverloadID()
+			f.F.Args = []*plan.Expr{innerCol}
+			retType := fGet.GetReturnType()
+			agg.Typ = makePlan2Type(&retType)
+		}
+	}
+
+	// LEFT JOIN outer with inner scan, all predicates as join conditions
+	nodeID = builder.appendNode(&plan.Node{
+		NodeType: plan.Node_JOIN,
+		Children: []int32{nodeID, innerID},
+		JoinType: plan.Node_LEFT,
+		OnList:   joinPreds,
+		SpillMem: builder.joinSpillMem,
+	}, ctx)
+
+	// New AGG: group by outer columns, compute aggregates on raw inner rows
+	newAggTag := builder.genNewBindTag()
+	nodeID = builder.appendNode(&plan.Node{
+		NodeType:    plan.Node_AGG,
+		Children:    []int32{nodeID},
+		GroupBy:     outerGroupBy,
+		AggList:     aggExprs,
+		BindingTags: []int32{reuseGroupTag, newAggTag},
+		SpillMem:    builder.aggSpillMem,
+	}, ctx)

Evidence

The rewrite groups by columns from *all* outer bindings but reuses only the first binding’s tag as
the AGG group tag. Downstream code treats AGG output as only {groupTag, aggregateTag}
(BindingTags[0]/[1]), implying other binding tags are not available above an AGG node.

pkg/sql/plan/flatten_subquery.go[504-565]
pkg/sql/plan/pushdown.go[44-55]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The new AGG node is created with `BindingTags: []int32{reuseGroupTag, newAggTag}` where `reuseGroupTag` is `ctx.bindings[0].tag`. If the outer query context has multiple bindings (e.g., `t1 JOIN t2`), column refs with `RelPos == t2.tag` will no longer resolve above the inserted AGG.
### Issue Context
The rewrite builds `outerGroupBy` for *all* bindings, but only exposes a single group tag.
### Fix Focus Areas
- pkg/sql/plan/flatten_subquery.go[504-565]
- pkg/sql/plan/pushdown.go[44-55]
### Suggested fix direction
- Either:
1) Restrict this rewrite to contexts where `len(ctx.bindings) == 1` (single outer binding), returning NYI otherwise; **or**
2) Implement a proper remapping strategy so that all outer columns referenced above the new AGG are rewritten to the AGG’s `groupTag`/col positions (and ensure the planner/binder state is updated accordingly).
- Add a regression test with a multi-table outer query where the scalar subquery references one table but the SELECT list references columns from both tables.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

3. ~~COUNT(*) rewrite wrong~~ ☑ 🐞 ≡

Description

The starcount→count rewrite uses the first column of a TABLE_SCAN found on the first-child path,
which can be nullable or not represent row existence for complex inner plans, so it can undercount
vs COUNT(*). If no TABLE_SCAN is found, the rewrite is skipped and LEFT JOIN can return 1 (not 0)
for no-match rows.

Code

pkg/sql/plan/flatten_subquery.go[R524-545]

+	// LEFT JOIN produces a NULL row for non-matching outer rows.
+	// starcount/count(*) would count that NULL row as 1 instead of 0.
+	// Fix: replace starcount(const) with count(inner_col) so NULLs are
+	// skipped.  We pick the first column from the inner scan node.
+	for _, agg := range aggExprs {
+		if f, ok := agg.Expr.(*plan.Expr_F); ok && f.F.Func.ObjName == "starcount" {
+			innerCol := builder.getFirstColRef(innerID)
+			if innerCol == nil {
+				continue
+			}
+			argType := makeTypeByPlan2Expr(innerCol)
+			fGet, err := function.GetFunctionByName(builder.GetContext(), "count", []types.Type{argType})
+			if err != nil {
+				return 0, nil, err
+			}
+			f.F.Func.ObjName = "count"
+			f.F.Func.Obj = fGet.GetEncodedOverloadID()
+			f.F.Args = []*plan.Expr{innerCol}
+			retType := fGet.GetReturnType()
+			agg.Typ = makePlan2Type(&retType)
+		}
+	}

Evidence

The rewrite replaces starcount with count(innerCol) where innerCol is the *first column* of
the first TABLE_SCAN found by walking only the first-child chain; it can return nil (skipping
rewrite) or a nullable column, which makes count(innerCol) differ from COUNT(*). The repo’s mock
schema includes tables whose first column is nullable, demonstrating that counting the first column
can undercount compared to count(*).

pkg/sql/plan/flatten_subquery.go[524-545]
pkg/sql/plan/flatten_subquery.go[626-642]
pkg/sql/plan/mock.go[565-575]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
To fix LEFT JOIN null-rows, the code rewrites `starcount` (COUNT(*)) into `count(first_inner_col)`. This is not equivalent to COUNT(*) when that column can be NULL for matching rows, and the rewrite can be skipped entirely if `getFirstColRef` can’t find a TABLE_SCAN, leaving COUNT(*) incorrect on non-matches.
### Issue Context
- `getFirstColRef` walks only the first-child chain and can return nil.
- Counting a nullable column is not COUNT(*) semantics.
### Fix Focus Areas
- pkg/sql/plan/flatten_subquery.go[524-545]
- pkg/sql/plan/flatten_subquery.go[626-642]
### Suggested fix direction
- Instead of counting an arbitrary inner column, project a guaranteed-non-null “match marker” from the inner side before the LEFT JOIN (e.g., a constant `1` with `NotNullable=true`). After the LEFT JOIN this marker becomes NULL only for non-matching outer rows.
- Rewrite `starcount` to `count(match_marker_col)`.
- Ensure the rewrite cannot silently skip (i.e., if you can’t produce a marker, fail/NYI rather than returning wrong COUNT results).
- Add tests:
- COUNT(*) where inner rows contain NULLs in the first column
- COUNT(*) with inner subquery shape that has no TABLE_SCAN on the first-child chain (or otherwise forces `getFirstColRef` to fail).

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

4. ~~Non-eq detection too broad~~ ☑ 🐞 ≡

Description

findNonEqPred returns true for any function whose ObjName != "=", including logical "and"/"or", so
predicates that are conjunctions of equality comparisons can be misclassified as non-equality and
routed into the new rewrite. This unnecessarily broadens the rewrite’s applicability and can trigger
its edge-case failures.

Code

pkg/sql/plan/flatten_subquery.go[446]
return false

Evidence

pullupCorrelatedPredicates lifts whole filter expressions as-is (it does not split AND/OR), so a
correlated predicate can have top-level function ObjName "and". findNonEqPred only checks the
top-level function name and treats anything other than "=" as non-equality.

pkg/sql/plan/flatten_subquery.go[437-446]
pkg/sql/plan/flatten_subquery.go[689-707]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`findNonEqPred` misclassifies predicates like `and(=(...),=(...))` as non-equality because it only checks the top-level function name. This can incorrectly trigger the new scalar-agg rewrite.
### Issue Context
Correlated predicates are lifted from FILTER nodes without splitting conjunctions/disjunctions.
### Fix Focus Areas
- pkg/sql/plan/flatten_subquery.go[437-446]
- pkg/sql/plan/flatten_subquery.go[689-707]
### Suggested fix direction
- Implement a recursive check that specifically looks for non-equality comparison operators (`<`, `<=`, `>`, `>=`, `<>`) anywhere in the predicate expression tree.
- Treat logical operators (`and`, `or`, `not`) as containers and recurse into args.
- Add a regression test with equality-only correlated predicates combined with AND, ensuring it does not take the non-eq rewrite path.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

ⓘ The new review experience is currently in Beta. Learn more

Copilot

Pull request overview

This PR fixes planning of scalar correlated aggregate subqueries that include non-equality predicates (e.g. <, >=), which previously failed with a NYI error due to a non-semantics-preserving pullupThroughAgg rewrite.

Changes:

Adds a dedicated rewrite path for scalar aggregate subqueries with non-equality correlated predicates by bypassing the inner AGG, using a LEFT JOIN, and re-aggregating grouped by outer columns.
Adjusts COUNT semantics under LEFT JOIN by rewriting starcount to count(inner.Row_ID) and ensuring COUNT returns 0 (not NULL) on no-match.
Updates/extends tests and expected results to cover the new supported behavior and to reflect the new NYI message for derived-table outer bindings.

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 3 comments.

File	Description
`pkg/sql/plan/flatten_subquery.go`	Implements new flattening/rewrite logic for scalar aggregate subqueries with non-equality correlated predicates, plus helper functions.
`pkg/sql/plan/build_test.go`	Adds a regression plan-build test that should now pass for a non-eq correlated scalar aggregate subquery.
`test/distributed/cases/dml/select/subquery.result`	Updates golden outputs to reflect newly supported correlated scalar aggregates (and related formatting/precision expectations).
`test/distributed/cases/hint/hint_cte.result`	Updates expected NYI output message for derived-table outer bindings.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

…ery flatten pullupThroughAgg appends pulled-up inner expressions to aggNode.GroupBy, so the previous len(aggNode.GroupBy) > 1 guard mistakenly rejected queries with two correlated predicates (one eq + one non-eq) even when the user did not write GROUP BY. Use subCtx.groups, which only holds the user's original GROUP BY, to make the guard precise. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

mergify · 2026-04-08T09:44:07Z

Merge Queue Status

✅ Entered queue — 2026-04-08 09:44 UTC · Rule: main
✅ Checks passed · in-place
✅ Merged — 2026-04-08 10:40 UTC · at d68b36868bbe5ffd9b69a3b0fa76bfdf902d1aa1

This pull request spent 56 minutes 24 seconds in the queue, including 56 minutes 7 seconds running CI.

Required conditions to merge

ck89119 requested review from aunjgr, heni02 and ouyuanning as code owners April 3, 2026 15:02

ck89119 had a problem deploying to ci April 3, 2026 15:03 — with GitHub Actions Error

ck89119 temporarily deployed to ci April 3, 2026 15:03 — with GitHub Actions Inactive

ck89119 had a problem deploying to ci April 3, 2026 15:03 — with GitHub Actions Error

ck89119 temporarily deployed to ci April 3, 2026 15:03 — with GitHub Actions Inactive

matrix-meow added the size/M Denotes a PR that changes [100,499] lines label Apr 3, 2026

Merge branch 'main' into fix-23942-v2

da160c8

mergify Bot temporarily deployed to ci April 3, 2026 15:04 Inactive

mergify Bot had a problem deploying to ci April 3, 2026 15:04 Failure

mergify Bot temporarily deployed to ci April 3, 2026 15:04 Inactive

mergify Bot had a problem deploying to ci April 3, 2026 15:04 Failure

mergify Bot temporarily deployed to ci April 3, 2026 15:04 Inactive

mergify Bot had a problem deploying to ci April 3, 2026 15:04 Failure

mergify Bot temporarily deployed to ci April 3, 2026 15:04 Inactive

ck89119 temporarily deployed to ci April 7, 2026 09:08 — with GitHub Actions Inactive

ck89119 had a problem deploying to ci April 7, 2026 09:08 — with GitHub Actions Failure

ck89119 requested a review from Copilot April 7, 2026 09:20

Copilot started reviewing on behalf of ck89119 April 7, 2026 09:21 View session

Copilot AI reviewed Apr 7, 2026

View reviewed changes

Comment thread pkg/sql/plan/flatten_subquery.go Outdated

Comment thread pkg/sql/plan/flatten_subquery.go

Comment thread pkg/sql/plan/flatten_subquery.go Outdated

test: add non-eq scalar subquery guards

d603189

ck89119 had a problem deploying to ci April 7, 2026 10:54 — with GitHub Actions Failure

ck89119 temporarily deployed to ci April 7, 2026 10:54 — with GitHub Actions Inactive

ck89119 had a problem deploying to ci April 7, 2026 10:54 — with GitHub Actions Failure

ck89119 temporarily deployed to ci April 7, 2026 10:54 — with GitHub Actions Inactive

ck89119 temporarily deployed to ci April 7, 2026 10:55 — with GitHub Actions Inactive

ck89119 had a problem deploying to ci April 7, 2026 10:55 — with GitHub Actions Failure

ck89119 temporarily deployed to ci April 8, 2026 07:22 — with GitHub Actions Inactive

ck89119 had a problem deploying to ci April 8, 2026 07:22 — with GitHub Actions Failure

ck89119 temporarily deployed to ci April 8, 2026 07:22 — with GitHub Actions Inactive

heni02 approved these changes Apr 8, 2026

View reviewed changes

aunjgr approved these changes Apr 8, 2026

View reviewed changes

Merge branch 'main' into fix-23942-v2

d68b368

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

fix: support aggregation with non-equality conditions in scalar subqueries#24053

fix: support aggregation with non-equality conditions in scalar subqueries#24053
mergify[bot] merged 7 commits intomatrixorigin:mainfrom
ck89119:fix-23942-v2

ck89119 commented Apr 3, 2026

Uh oh!

qodo-code-review Bot commented Apr 3, 2026

Uh oh!

qodo-code-review Bot commented Apr 3, 2026 •

edited

Loading

Uh oh!

Copilot AI left a comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

mergify Bot commented Apr 8, 2026 •

edited

Loading

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

5 participants

Conversation

ck89119 commented Apr 3, 2026

What type of PR is this?

Which issue(s) this PR fixes:

What this PR does / why we need it:

Uh oh!

qodo-code-review Bot commented Apr 3, 2026

Review Summary by Qodo

Walkthroughs

File Changes

Uh oh!

qodo-code-review Bot commented Apr 3, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Code Review by Qodo

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Uh oh!

Uh oh!

Uh oh!

mergify Bot commented Apr 8, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Merge Queue Status

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

5 participants

qodo-code-review Bot commented Apr 3, 2026 •

edited

Loading

mergify Bot commented Apr 8, 2026 •

edited

Loading