You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@skywalking.apache.org by ha...@apache.org on 2026/05/14 09:17:54 UTC
(skywalking-banyandb) 01/02: feat(query/vectorized/measure)!: remove AggregationEnabled flag — GroupBy+Agg dispatch is default-on
This is an automated email from the ASF dual-hosted git repository.
hanahmily pushed a commit to branch vectorized-query
in repository https://gitbox.apache.org/repos/asf/skywalking-banyandb.git
commit 32fb720a376d62a032a87c07e9f9daf509aa2f0e
Author: Hongtao Gao <ha...@gmail.com>
AuthorDate: Thu May 14 07:20:47 2026 +0000
feat(query/vectorized/measure)!: remove AggregationEnabled flag — GroupBy+Agg dispatch is default-on
The flag served its purpose: a kill-switch while the operator and bridge
were being engineered toward row-path parity. With the integration parity
gate at 488/488 specs green, the kill-switch is dead weight and the only
remaining reason to keep it would be a code-path users could trip into
that diverges from the row path. There isn't one.
Drops:
- VectorizedConfig.AggregationEnabled field + its plumbing
- --measure-vectorized-aggregation-enabled CLI flag in banyand/measure
- the cfg.AggregationEnabled gate in dispatch.Dispatch (lines 134-142)
- TestDispatch_GroupByAgg_FlagOff_FallsThrough + the
dispatchCfgWithAgg helper that pinned the flag's behavior
- --measure-vectorized-aggregation-enabled=true from the parity gate
standalone (the flag's the only place it was set)
- the satisfied TODO(G8d) in executor_test.go that asked for the
operator-pipeline bridge that has now landed
- stale doc fragments in banyand/measure/query.go,
dispatch.go's eligibility block, and dispatch_test.go that
described the flag's existence
Rollback path stays --measure-vectorized-enabled=false (kills the entire
vec subsystem); GroupBy+Agg specifically can no longer be partially
disabled.
via [HAPI](https://hapi.run)
---
banyand/measure/measure.go | 10 +---
banyand/measure/query.go | 10 ++--
pkg/query/vectorized/measure/config.go | 14 ++---
pkg/query/vectorized/measure/plan/dispatch.go | 13 +----
pkg/query/vectorized/measure/plan/dispatch_test.go | 59 +++++-----------------
pkg/query/vectorized/measure/plan/executor_test.go | 13 -----
.../standalone/query/vectorized_test.go | 1 -
7 files changed, 24 insertions(+), 96 deletions(-)
diff --git a/banyand/measure/measure.go b/banyand/measure/measure.go
index a797156cc..76a8c1ae3 100644
--- a/banyand/measure/measure.go
+++ b/banyand/measure/measure.go
@@ -174,19 +174,13 @@ func (m *measure) VectorizedConfig() vmeasure.VectorizedConfig {
}
// bindVectorizedFlags wires VectorizedConfig fields to a run.FlagSet. The
-// defaults match vmeasure.DefaultConfig — Enabled=false, BatchSize=1024,
-// QueryMemoryMiB=256 — so config loaders that omit these flags retain the
-// pre-G4 row-only behavior.
+// defaults match vmeasure.DefaultConfig.
func bindVectorizedFlags(flagS *run.FlagSet, cfg *vmeasure.VectorizedConfig) {
defaults := vmeasure.DefaultConfig()
flagS.BoolVar(&cfg.Enabled, "measure-vectorized-enabled", defaults.Enabled,
- "enable the vectorized measure query path (off by default; flip after soak)")
+ "enable the vectorized measure query path")
flagS.IntVar(&cfg.BatchSize, "measure-vectorized-batch-size", defaults.BatchSize,
"row count per vectorized batch")
flagS.IntVar(&cfg.QueryMemoryMiB, "measure-vectorized-query-memory-mib", defaults.QueryMemoryMiB,
"per-query memory budget for the vectorized path, in MiB")
- flagS.BoolVar(&cfg.AggregationEnabled, "measure-vectorized-aggregation-enabled",
- defaults.AggregationEnabled,
- "route GroupBy+Agg requests through the vectorized aggregation pipeline "+
- "instead of the row-path aggregator (default false; flip after egress parity is verified)")
}
diff --git a/banyand/measure/query.go b/banyand/measure/query.go
index 3d5f82ef1..6a442f743 100644
--- a/banyand/measure/query.go
+++ b/banyand/measure/query.go
@@ -228,12 +228,12 @@ func (m *measure) Query(ctx context.Context, mqo model.MeasureQueryOptions) (mqr
// projection. Falls back to nil on schema-build failure; PullBatch
// checks for nil and returns a clean error rather than degrading
// the row-path Pull().
- // G8d.2: thread GroupBy + Agg through so BuildBatchSchema emits native
+ // Thread GroupBy + Agg through so BuildBatchSchema emits native
// column types for the agg-relevant columns. Plain queries get
- // passthrough as before; queries that the vec subsystem will fold
- // over get native int64/float64/string/etc. columns ready for the
- // BatchAggregation operator (computeKey + fold). The storage decoders
- // (banyand/measure/batch_decode.go) already handle both column shapes.
+ // passthrough; GroupBy+Agg queries get native int64/float64/string
+ // columns the BatchAggregation operator reads directly (computeKey +
+ // fold). Storage decoders (banyand/measure/batch_decode.go) handle
+ // both column shapes.
result.batchSchema, _ = vmeasure.BuildBatchSchema(m.schema, model.MeasureQueryOptions{
TagProjection: result.tagProjection,
FieldProjection: mqo.FieldProjection,
diff --git a/pkg/query/vectorized/measure/config.go b/pkg/query/vectorized/measure/config.go
index df46b947f..6d0a4a7ae 100644
--- a/pkg/query/vectorized/measure/config.go
+++ b/pkg/query/vectorized/measure/config.go
@@ -24,20 +24,12 @@ type VectorizedConfig struct {
BatchSize int
QueryMemoryMiB int
Enabled bool
- // AggregationEnabled opens the dispatch gate to GroupBy+Agg requests
- // (G8d.2 ships the schema/storage bridge but parity-preserving
- // aggregation egress is still being engineered). Default false so
- // production keeps routing GroupBy+Agg through the row path until
- // the egress contract matches row-path output byte-for-byte.
- AggregationEnabled bool
}
// DefaultConfig returns the v1 default — enabled, 1024-row batches, 256 MiB
-// per-query memory budget, aggregation gate off. v1 ships Enabled true post-
-// soak/bench-gate rollout (G5e); AggregationEnabled stays false until the
-// vec aggregation egress reaches row-path parity. To roll back the vec
-// path entirely, pass --measure-vectorized-enabled=false on the standalone
-// or data-node command line and restart.
+// per-query memory budget. To roll back the vec path entirely, pass
+// --measure-vectorized-enabled=false on the standalone or data-node command
+// line and restart.
func DefaultConfig() VectorizedConfig {
return VectorizedConfig{Enabled: true, BatchSize: 1024, QueryMemoryMiB: 256}
}
diff --git a/pkg/query/vectorized/measure/plan/dispatch.go b/pkg/query/vectorized/measure/plan/dispatch.go
index cffe1efe1..d1d07fc2f 100644
--- a/pkg/query/vectorized/measure/plan/dispatch.go
+++ b/pkg/query/vectorized/measure/plan/dispatch.go
@@ -86,8 +86,8 @@ func FellThroughCount() int64 { return fellThroughCount.Load() }
//
// Eligibility gate (v1):
// - cfg.Enabled must be true
-// - request must NOT carry GroupBy or Agg (column-type bridging at the
-// scan source still pending; see executor.go's TODO(G8d))
+// - request may carry GroupBy+Agg as a pair (scalar reduce + raw
+// GroupBy are deferred); aggProjectionCoverage must also hold
// - request must NOT carry Top (BatchTop's single-heap semantic differs
// from the row path's per-timestamp top-N)
// - request must carry TimeRange (storage requires a bounded window)
@@ -131,15 +131,6 @@ func Dispatch(
hasGroupBy := req.GetGroupBy() != nil
hasAgg := req.GetAgg() != nil
if hasGroupBy || hasAgg {
- // G8d.2 wires the schema/storage bridge (BuildBatchSchema emits
- // native columns for GroupBy keys + Agg field, storage decoders
- // honor it) so the operator pipeline is ready when the egress
- // reaches row-path parity. Until then, AggregationEnabled gates
- // the dispatch gate; default false keeps GroupBy+Agg on the row
- // path so the parity suite stays green.
- if !cfg.AggregationEnabled {
- return nil, "", false, nil
- }
// GroupBy and Agg must travel as a pair (scalar reduce + raw
// groupby are deferred). Either alone falls through.
if hasGroupBy != hasAgg {
diff --git a/pkg/query/vectorized/measure/plan/dispatch_test.go b/pkg/query/vectorized/measure/plan/dispatch_test.go
index c8a8a2532..d0c923e4b 100644
--- a/pkg/query/vectorized/measure/plan/dispatch_test.go
+++ b/pkg/query/vectorized/measure/plan/dispatch_test.go
@@ -36,14 +36,6 @@ func dispatchCfg(enabled bool) measure.VectorizedConfig {
return measure.VectorizedConfig{Enabled: enabled, BatchSize: 1024, QueryMemoryMiB: 16}
}
-// dispatchCfgWithAgg returns a vec-enabled config with the G8d.2
-// aggregation gate flipped on so dispatch handles GroupBy+Agg requests.
-func dispatchCfgWithAgg() measure.VectorizedConfig {
- cfg := dispatchCfg(true)
- cfg.AggregationEnabled = true
- return cfg
-}
-
func bareReq() *measurev1.QueryRequest {
return &measurev1.QueryRequest{
Name: "demo",
@@ -73,34 +65,8 @@ func TestDispatch_NotEnabled_FallsThrough(t *testing.T) {
}
}
-// TestDispatch_GroupByAgg_FlagOff_FallsThrough pins the G8d.2 default:
-// even a fully-covered GroupBy+Agg request falls through when
-// AggregationEnabled is false (the default). This is the load-bearing
-// behavior that keeps the integration parity suite green while the
-// vec aggregation egress is engineered to match row-path output.
-func TestDispatch_GroupByAgg_FlagOff_FallsThrough(t *testing.T) {
- req := bareReq()
- req.GroupBy = &measurev1.QueryRequest_GroupBy{
- TagProjection: projTagProj(),
- FieldName: "value",
- }
- req.Agg = &measurev1.QueryRequest_Aggregation{
- Function: modelv1.AggregationFunction_AGGREGATION_FUNCTION_SUM,
- FieldName: "value",
- }
- _, _, handled, err := Dispatch(context.Background(),
- req, nil, nil, nil, nil, dispatchCfg(true)) // AggregationEnabled = false (default)
- if err != nil {
- t.Fatalf("flag-off fallthrough must not error: %v", err)
- }
- if handled {
- t.Fatal("GroupBy+Agg must fall through when AggregationEnabled is false")
- }
-}
-
// TestDispatch_GroupByWithoutAgg_FallsThrough covers the pair check
-// (GroupBy and Agg must travel together). Uses the agg-enabled config
-// so we reach the pair check rather than the flag-off gate.
+// (GroupBy and Agg must travel together).
func TestDispatch_GroupByWithoutAgg_FallsThrough(t *testing.T) {
req := bareReq()
req.GroupBy = &measurev1.QueryRequest_GroupBy{
@@ -108,7 +74,7 @@ func TestDispatch_GroupByWithoutAgg_FallsThrough(t *testing.T) {
FieldName: "value",
}
_, _, handled, err := Dispatch(context.Background(),
- req, nil, nil, nil, nil, dispatchCfgWithAgg())
+ req, nil, nil, nil, nil, dispatchCfg(true))
if err != nil {
t.Fatalf("GroupBy-without-Agg fallthrough must not error: %v", err)
}
@@ -126,7 +92,7 @@ func TestDispatch_AggWithoutGroupBy_FallsThrough(t *testing.T) {
FieldName: "value",
}
_, _, handled, err := Dispatch(context.Background(),
- req, nil, nil, nil, nil, dispatchCfgWithAgg())
+ req, nil, nil, nil, nil, dispatchCfg(true))
if err != nil {
t.Fatalf("Agg-without-GroupBy fallthrough must not error: %v", err)
}
@@ -185,7 +151,7 @@ func TestDispatch_GroupByAggUncoveredProjection_FallsThrough(t *testing.T) {
req := bareReq()
c.mutate(req)
_, _, handled, err := Dispatch(context.Background(),
- req, nil, nil, nil, nil, dispatchCfgWithAgg())
+ req, nil, nil, nil, nil, dispatchCfg(true))
if err != nil {
t.Fatalf("uncovered projection must not error: %v", err)
}
@@ -408,13 +374,12 @@ func TestDispatch_Counters_TrackFellThroughCalls(t *testing.T) {
}
}
-// TestDispatch_GroupByAggCovered_ReachesEcQuery confirms G8d.2 has
-// opened the dispatch gate for GroupBy+Agg requests whose projection
-// covers both the GroupBy keys and the Agg field. The fakeEC returns
-// nil so dispatch falls through after ec.Query (matching the empty-
-// result branch) — what matters is that ec.Query was invoked at all,
-// proving the eligibility gate let the request through. With G8d.1
-// this would have been rejected before any ec interaction.
+// TestDispatch_GroupByAggCovered_ReachesEcQuery confirms the dispatch
+// gate admits GroupBy+Agg requests whose projection covers both the
+// GroupBy keys and the Agg field. fakeEC returns nil so dispatch falls
+// through after ec.Query (matching the empty-result branch) — what
+// matters is that ec.Query was invoked at all, proving the eligibility
+// gate let the request through.
func TestDispatch_GroupByAggCovered_ReachesEcQuery(t *testing.T) {
measureSchema := testMeasureSchema()
// nolint:staticcheck // SA1019 — row-path BuildSchema is the only schema builder until G8 replaces it.
@@ -436,7 +401,7 @@ func TestDispatch_GroupByAggCovered_ReachesEcQuery(t *testing.T) {
}
iter, planStr, handled, err := Dispatch(context.Background(),
- req, metadata, measureSchema, logicalSchema, ec, dispatchCfgWithAgg())
+ req, metadata, measureSchema, logicalSchema, ec, dispatchCfg(true))
if err != nil {
t.Fatalf("covered GroupBy+Agg must not error before ec.Query: %v", err)
}
@@ -444,7 +409,7 @@ func TestDispatch_GroupByAggCovered_ReachesEcQuery(t *testing.T) {
// Surface the other return values for debugging when the gate
// regression resurfaces — they're all zero-valued today because
// ec.Query returned (nil, nil) and dispatch fell through.
- t.Fatalf("covered GroupBy+Agg must reach ec.Query (G8d.2 gate); "+
+ t.Fatalf("covered GroupBy+Agg must reach ec.Query (dispatch gate); "+
"got iter=%v planStr=%q handled=%v", iter, planStr, handled)
}
}
diff --git a/pkg/query/vectorized/measure/plan/executor_test.go b/pkg/query/vectorized/measure/plan/executor_test.go
index a0bd86d59..f2148874e 100644
--- a/pkg/query/vectorized/measure/plan/executor_test.go
+++ b/pkg/query/vectorized/measure/plan/executor_test.go
@@ -123,19 +123,6 @@ func TestExecute_GroupByAgg_EmitsAggregatedRowsWithNilTimestamp(t *testing.T) {
}
}
-// TODO(G8d): an end-to-end Analyze+Execute test against the analyzer-
-// produced BatchSchema would exercise the agg pipeline against the same
-// column layout the scan source emits in production. Today
-// BuildBatchSchema uses passthrough *modelv1.FieldValue columns (to keep
-// row-path egress zero-alloc), but BatchAggregation.fold requires native
-// int64/float64. G8d must either:
-// - convert passthrough → native via a fusible at the scan-source
-// boundary when the pipeline contains a fold operator, or
-// - teach BatchAggregation to fold over *modelv1.FieldValue.
-// Until that bridge lands, the executor tests above use a hand-built
-// schema with native typed columns to verify executor correctness in
-// isolation.
-
func TestExecute_BuildError_SurfacesAsExecuteError(t *testing.T) {
schema, _ := buildScanInput(t)
scan := NewScan(schema, ScanParams{}) // Source intentionally unset
diff --git a/test/integration/standalone/query/vectorized_test.go b/test/integration/standalone/query/vectorized_test.go
index 5a974ddf7..abd037352 100644
--- a/test/integration/standalone/query/vectorized_test.go
+++ b/test/integration/standalone/query/vectorized_test.go
@@ -89,7 +89,6 @@ var _ = ginkgo.Describe("vectorized parity", ginkgo.Ordered, func() {
config := setup.PropertyClusterConfig(dfWriter)
addr, _, closeFn := setup.ClosableStandalone(config, path, ports,
"--measure-vectorized-enabled=true",
- "--measure-vectorized-aggregation-enabled=true",
)
stopFn = func() {
closeFn()