diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 80416a1..e65770a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -69,12 +69,17 @@ jobs: - name: Verify stats and endpoint queries against PostgreSQL 16 env: BEACON_TEST_POSTGRES_DSN: postgres://postgres:backup-ci-only@127.0.0.1:5432/postgres?sslmode=disable - run: go test ./db -run '^Test(Signal|Paths|PacketSummaries|PacketEndpointsResolveLive|ObserverMetrics|RouteEvidence|RouteEvidenceIndex|AnalyticsRetention|AnalyticsRetentionConcurrent|DeleteOldPacketsBatches|MeshMapperCatalogue|ChannelMessageScopes|NodeLocationReset|RunMigrations[A-Za-z]*|KnownRoutesIndexSet|PacketsDomainChecks|Reconfirm[A-Za-z]*|BigintCursors|RouteSearchHopOrder|StatsNodeTypesSplit|ListKnownRoutes|ListKnownRoutesMatchesLegacy|KnownRoutesCursorTies|KnownRoutesUnanalyzedRegion|KnownRoutesHopStatementsStayCustom|KnownRoutePaginationTies|RouteRetentionCutoffsExact|DeleteExpiredRoutes|DeleteGraceRoutesSlice|GraceWatermarkHeldByLockedRow|OpenPoolsSettings|PlanRouterClassCUnnamed|APIStoreHopStatementsUnnamed|PgStatStatementsMigrationGuarded|DBStatements|DBStatementsNoExtension|PgStatStatementsMigrationNoCreatableSchema|IndexHealthBaselineOnReindex|UnusedIndexes|PgActivity|RollHourSetsWorkMem|SmallTableIndexSet|NodeReadersAfterIndexDrops|ObserverChannelReadersAfterIndexDrops|UpsertChannelWriteThrough|UpsertChannelHashOnlyWriteThrough|ReadOnlyPoolsRejectWrites|ListPacketsGlobalMatchesLegacy|PacketsGlobalCursorTies|ListPacketsWindowInvertedRows|PacketsLatestObserverTie|NodesLegacyCursorMatchesToday|NodesPageCursorTies|ObserversLegacyCursorMatchesToday|ObserversNextCursorFromLastSeen|ObserverAdvertsPartialIndex|AdvertsWaitForPayloadTypeBackfill|StatsProbeMatchesToday|TraceTagsKeysetMatchesToday|TelemetrySinceMatchesCatchAll|TraceTagPagination|TraceTagPaginationTies|TraceSummarySurvivesMissedHearing)Postgres$' -count=1 -v + run: go test ./db -run '^Test(Signal|Paths|PacketSummaries|PacketEndpointsResolveLive|ObserverMetrics|RouteEvidence|RouteEvidenceIndex|AnalyticsRetention|AnalyticsRetentionConcurrent|DeleteOldPacketsBatches|MeshMapperCatalogue|ChannelMessageScopes|NodeLocationReset|RunMigrations[A-Za-z]*|KnownRoutesIndexSet|PacketsDomainChecks|Reconfirm[A-Za-z]*|BigintCursors|RouteSearchHopOrder|StatsNodeTypesSplit|ListKnownRoutes|ListKnownRoutesMatchesLegacy|KnownRoutesCursorTies|KnownRoutesUnanalyzedRegion|KnownRoutesHopStatementsStayCustom|KnownRoutePaginationTies|RouteRetentionCutoffsExact|DeleteExpiredRoutes|DeleteGraceRoutesSlice|GraceWatermarkHeldByLockedRow|OpenPoolsSettings|PlanRouterClassCUnnamed|APIStoreHopStatementsUnnamed|PgStatStatementsMigrationGuarded|DBStatements|DBStatementsNoExtension|PgStatStatementsMigrationNoCreatableSchema|IndexHealthBaselineOnReindex|UnusedIndexes|PgActivity|RollHourSetsWorkMem|SmallTableIndexSet|NodeReadersAfterIndexDrops|ObserverChannelReadersAfterIndexDrops|UpsertChannelWriteThrough|UpsertChannelHashOnlyWriteThrough|ReadOnlyPoolsRejectWrites|ListPacketsGlobalMatchesLegacy|PacketsGlobalCursorTies|ListPacketsWindowInvertedRows|PacketsLatestObserverTie|NodesLegacyCursorMatchesToday|NodesPageCursorTies|ObserversLegacyCursorMatchesToday|ObserversNextCursorFromLastSeen|ObserverAdvertsPartialIndex|AdvertsWaitForPayloadTypeBackfill|StatsProbeMatchesToday|TraceTagsKeysetMatchesToday|TelemetrySinceMatchesCatchAll|TraceTagPagination|TraceTagPaginationTies|TraceSummarySurvivesMissedHearing|CmiMigrationsIndexSet|InsertChannelMessageSeed[A-Za-z]*|AddChannelMessageIATA|CmiSeedAndAddRace|CmiInitAndBackfill|CmiMessageRangeReconcile|CmiObservationRangeReconcile|CmiBackfillRetries23503|WaitForPreBootWriters|ChannelMessagesByIATAsMatchesLegacy|ChannelMessagesZeroHitRegion|CmiTrustLifecycle|CmiFirstVerification)Postgres$' -count=1 -v + + - name: Verify the channel message site rule against PostgreSQL 16 + env: + BEACON_TEST_POSTGRES_DSN: postgres://postgres:backup-ci-only@127.0.0.1:5432/postgres?sslmode=disable + run: go test ./internal/ingest -run '^Test(CmiAddOnDecryptFailure|CmiCleanIngestReconcilesNothing)Postgres$' -count=1 -v - name: Verify route retention task against PostgreSQL 16 env: BEACON_TEST_POSTGRES_DSN: postgres://postgres:backup-ci-only@127.0.0.1:5432/postgres?sslmode=disable - run: go test ./internal/background -run '^Test(RouteRetentionTask|PayloadTypeBackfill|PayloadTypeBackfillProbe)Postgres$' -count=1 -v + run: go test ./internal/background -run '^Test(RouteRetentionTask|PayloadTypeBackfill|PayloadTypeBackfillProbe|CmiBootRepair|CmiReadOnlyTrust)Postgres$' -count=1 -v # Builds the fixture once; the planguard tests below reuse it (PLANGUARD_FIXTURE_DSN) after checking that its # marker records a build of the same files. diff --git a/cmd/beacon/main.go b/cmd/beacon/main.go index 1cfd278..76d5af5 100644 --- a/cmd/beacon/main.go +++ b/cmd/beacon/main.go @@ -165,6 +165,14 @@ func main() { os.Exit(1) } } + // The read-model boot repair waits for every transaction that began before this instant. + bootTS, err := db.DatabaseNow(ctx, pools.Maint) + if err != nil { + slog.Error("reading the database clock failed", "component", "startup", "error", err) + os.Exit(1) + } + // Trust in each read model is per process: earned by this boot's repair, dropped by any writer's failure. + readModels := &db.ReadModels{Cmi: db.NewTrust("cmi", resolved.ReadModelCmiEnabled, db.CmiTrustPolicy)} // Three stores: ingest writes, background and operator work, and API reads. The API store // routes each statement by plan class through the guards; it never runs background jobs. @@ -172,9 +180,9 @@ func main() { guard := guards.New(guards.Options{Enforce: enforce, ForceObserve: layout == planpolicy.Single, Budget: resolved.GuardsBudget}) // Ingest and maintenance share one channel id cache; the API never writes channels. channelIDs := db.NewChannelIDCache() - ingestStore := db.New(pools.Ingest, pools.Ingest, resolved.ClockDriftThreshold, resolved.NodeStaleThreshold, db.WithChannelIDs(channelIDs)) - maintStore := db.New(pools.Maint, pools.Maint, resolved.ClockDriftThreshold, resolved.NodeStaleThreshold, db.WithChannelIDs(channelIDs)) - apiStore := db.NewAPIStore(pools, layout, guard, resolved.ClockDriftThreshold, resolved.NodeStaleThreshold) + ingestStore := db.New(pools.Ingest, pools.Ingest, resolved.ClockDriftThreshold, resolved.NodeStaleThreshold, db.WithChannelIDs(channelIDs), db.WithReadModels(readModels)) + maintStore := db.New(pools.Maint, pools.Maint, resolved.ClockDriftThreshold, resolved.NodeStaleThreshold, db.WithChannelIDs(channelIDs), db.WithReadModels(readModels)) + apiStore := db.NewAPIStore(pools, layout, guard, resolved.ClockDriftThreshold, resolved.NodeStaleThreshold, db.WithReadModels(readModels)) if err := maintStore.PreloadChannelIDs(ctx); err != nil { slog.Warn("channel id preload failed; known channels upsert until cached", "component", "startup", "error", err) } else { @@ -483,6 +491,25 @@ func main() { if repeaterImporter != nil && cfg.MeshMapper.Repeaters.Enabled { tasks = append(tasks, background.Task{Name: "meshmapper.repeaters", Interval: meshmapper.PollInterval, Run: repeaterImporter.Refresh}) } + cmiJobs := &background.CmiJobs{ + Begin: func(ctx context.Context) (background.CmiSession, bool, error) { + s, ok, err := maintStore.BeginCmi(ctx) + if s == nil { + return nil, ok, err + } + return s, ok, err + }, + Wait: func(ctx context.Context) error { + return db.WaitForPreBootWriters(ctx, pools.Maint, bootTS, time.Minute) + }, + Trust: readModels.Cmi, + Interval: background.CmiInterval, + } + if mode.Jobs { + tasks = append(tasks, cmiJobs.Task()) + } else { + go background.CmiReadOnlyWatch(ctx, maintStore.CheckCmiReadOnly, readModels.Cmi, background.CmiInterval) + } pgSource, pgTask := planguardWiring(ctx, resolved.PlanguardDailyCheck, mode.Jobs, pools.Maint) if pgTask != nil { tasks = append(tasks, *pgTask) @@ -495,6 +522,7 @@ func main() { if mode.Jobs { scheduler := background.New(tasks) go scheduler.Start(ctx) + go cmiJobs.Boot(ctx) } // ── HTTP server ────────────────────────────────────────────────────────── diff --git a/config.yaml.example b/config.yaml.example index 33d8592..385fd6b 100644 --- a/config.yaml.example +++ b/config.yaml.example @@ -77,6 +77,13 @@ ratelimit: #planguard: # daily_check: false +# Read models. Serve region and scope channel message pages from channel_message_iatas once this process has +# repaired and verified it. false serves every page from the original statements; the table is still maintained, +# so turning it back on needs only a restart. +#readmodels: +# cmi: +# enabled: true + # MeshMapper integrations (optional, require a regional or grouped-region API key). # Your local MeshMapper regional or grouped-region admin can generate the key. # A grouped-region key covers multiple regions. diff --git a/db/background_state.go b/db/background_state.go index cd6bc67..2c4541f 100644 --- a/db/background_state.go +++ b/db/background_state.go @@ -15,7 +15,12 @@ import ( // LoadState unmarshals the background_state value under key into v. It returns false, nil when // the key has no row. func (s *Store) LoadState(ctx context.Context, key string, v any) (bool, error) { - raw, err := s.q.GetBackgroundState(ctx, key) + return loadState(ctx, s.q, key, v) +} + +// loadState reads key through q, which may be bound to one connection or a transaction. +func loadState(ctx context.Context, q sqlc.Querier, key string, v any) (bool, error) { + raw, err := q.GetBackgroundState(ctx, key) if errors.Is(err, pgx.ErrNoRows) { return false, nil } diff --git a/db/baseline_integration_test.go b/db/baseline_integration_test.go index a4c7665..15858f7 100644 --- a/db/baseline_integration_test.go +++ b/db/baseline_integration_test.go @@ -39,6 +39,14 @@ func applyBaseline(t *testing.T, ctx context.Context, tx pgx.Tx) { if _, err := tx.Exec(ctx, string(ddl)); err != nil { t.Fatal(err) } + // and the read-model table the message writer maintains + cmi, err := migrationFiles.ReadFile("migrations/" + cmiMigrations[0]) + if err != nil { + t.Fatal(err) + } + if _, err := tx.Exec(ctx, string(cmi)); err != nil { + t.Fatal(err) + } if _, err := tx.Exec(ctx, "INSERT INTO iata_codes (iata) VALUES ('YVR'),('YYJ'),('YYZ'),('YOW')"); err != nil { t.Fatal(err) } diff --git a/db/channel_scopes_integration_test.go b/db/channel_scopes_integration_test.go index ab9a9c4..ffbaabd 100644 --- a/db/channel_scopes_integration_test.go +++ b/db/channel_scopes_integration_test.go @@ -46,7 +46,7 @@ func TestChannelMessageScopesPostgres(t *testing.T) { t.Fatal(err) } defer tx.Rollback(context.Background()) - for _, table := range []string{"transport_scopes", "packets", "packet_observations", "channels", "channel_messages"} { + for _, table := range []string{"transport_scopes", "packets", "packet_observations", "channels", "channel_messages", "channel_message_iatas"} { if _, err := tx.Exec(ctx, "CREATE TEMP TABLE "+table+" (LIKE public."+table+" INCLUDING ALL) ON COMMIT DROP"); err != nil { t.Fatal(err) } diff --git a/db/channels.go b/db/channels.go index d988112..b9c4773 100644 --- a/db/channels.go +++ b/db/channels.go @@ -7,6 +7,8 @@ import ( "context" "encoding/hex" "errors" + "log/slog" + "math" "time" sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" @@ -217,24 +219,164 @@ func (s *Store) GetChannel(ctx context.Context, channelID int32) (*api.Channel, return &channel, nil } +// InsertChannelMessage stores a message and, in the same statement, the site of every stored observation of +// its packet. If that statement fails for any reason but cancellation, the message is stored without its sites +// (the read-model reconcile adds them), so no error path loses a message today's statement would store. func (s *Store) InsertChannelMessage(ctx context.Context, m ingest.InsertChannelMessageParams) (*ingest.InsertedChannelMessage, error) { params := sqlc.InsertChannelMessageParams{ChannelID: int32(m.ChannelID), PacketHash: m.PacketHash, SenderName: &m.SenderName, Content: &m.Content, SentAt: pgtype.Timestamptz{Time: m.SentAt, Valid: true}, Column6: m.Historical} row, err := s.q.InsertChannelMessage(ctx, params) if errors.Is(err, pgx.ErrNoRows) { return nil, nil // duplicate } + if err != nil { + // Whatever happens next, a page may miss this packet's sites until the reconcile: the fallback stores the + // message without them, and a failed insert's Add finds no message while another lane's is in flight. + s.readModels.invalidateCmi("a channel message insert failed") + } + if err != nil && ctx.Err() == nil { + slog.Warn("channel message site seed failed; storing the message without it", "component", "db", "packet_hash", hex.EncodeToString(m.PacketHash), "error", err) + unseeded, uerr := s.q.InsertChannelMessageUnseeded(ctx, sqlc.InsertChannelMessageUnseededParams(params)) + if errors.Is(uerr, pgx.ErrNoRows) { + return nil, nil // duplicate + } + if uerr != nil { + return nil, uerr + } + row, err = sqlc.InsertChannelMessageRow(unseeded), nil + } if err != nil { return nil, err } return &ingest.InsertedChannelMessage{ID: row.ID, Scope: row.ScopeName, ScopeStatus: api.RecordedChannelScopeStatus(row.ScopeName, row.TransportCodesPresent)}, nil } +// AddChannelMessageIATA records iata as a site of the packet's message, when the packet has one. +// found says the packet has a committed message, so the site is recorded. A failure drops cmi trust until the next +// reconcile adds the pair. +func (s *Store) AddChannelMessageIATA(ctx context.Context, packetHash []byte, iata string) (bool, error) { + found, err := s.q.AddChannelMessageIATA(ctx, sqlc.AddChannelMessageIATAParams{PacketHash: packetHash, Iata: iata}) + if err != nil { + s.readModels.invalidateCmi("a message site was not recorded") + } + return found, err +} + +// ListChannelMessages serves /channels/{id}/messages (channelID set) and /messages. func (s *Store) ListChannelMessages(ctx context.Context, channelID *int32, since time.Time, limit int32, iatas []string, scope string, cursor int64) (api.Page[api.ChannelMessage], error) { + return listChannelMessages(ctx, s.q, s.readModels.cmiTrusted(), channelID, since, limit, iatas, scope, cursor) +} + +// listChannelMessages runs one statement per request shape. A zero since is "no since", nil and empty iatas are +// "no region", "" is "no scope". The shapes filtered by site, and those filtered by scope without since, read +// channel_message_iatas; without useReadModel they run today's statement unchanged. The others never read it. +func listChannelMessages(ctx context.Context, q sqlc.Querier, useReadModel bool, channelID *int32, since time.Time, limit int32, iatas []string, scope string, cursor int64) (api.Page[api.ChannelMessage], error) { + hasSince, hasSites, hasScope := !since.IsZero(), len(iatas) > 0, scope != "" + // Sites with a since or a scope across every channel have no index that bounds both: each site's range would + // be walked until enough rows pass the filter, so today's statement serves them, trusted or not. + allChannelsFiltered := channelID == nil && hasSites && (hasSince || hasScope) + if allChannelsFiltered || ((hasSites || (hasScope && !hasSince)) && !useReadModel) { + return listChannelMessagesLegacy(ctx, q, channelID, since, limit, iatas, scope, cursor) + } + var scopeID *int32 + if hasScope { + id, err := q.GetTransportScopeByName(ctx, scope) + if errors.Is(err, pgx.ErrNoRows) { + return api.Page[api.ChannelMessage]{Items: []api.ChannelMessage{}}, nil + } + if err != nil { + return api.Page[api.ChannelMessage]{}, err + } + scopeID = &id + } + sites := dedupeSites(iatas) + cursorID := cursor + if cursor == 0 { + cursorID = math.MaxInt64 + } + pageLimit := limit + 1 + ts := pgtype.Timestamptz{Time: since, Valid: true} + + var rows []sqlc.ListChannelMessagesRow + var err error + switch { + case channelID != nil && hasSince: + rows, err = convertRows(q.ListChannelMessagesSinceWalk(ctx, sqlc.ListChannelMessagesSinceWalkParams{ChannelID: *channelID, Since: ts, Iatas: sites, ScopeID: scopeID, CursorID: cursorID, PageLimit: pageLimit})) + case channelID != nil && hasSites && hasScope: + rows, err = convertRows(q.ListChannelMessagesByIATAsScoped(ctx, sqlc.ListChannelMessagesByIATAsScopedParams{Iatas: sites, ChannelID: *channelID, ScopeID: *scopeID, CursorID: cursorID, PageLimit: pageLimit})) + case channelID != nil && hasSites: + rows, err = convertRows(q.ListChannelMessagesByIATAs(ctx, sqlc.ListChannelMessagesByIATAsParams{Iatas: sites, ChannelID: *channelID, CursorID: cursorID, PageLimit: pageLimit})) + case channelID != nil && hasScope: + rows, err = convertRows(q.ListChannelMessagesPlainScoped(ctx, sqlc.ListChannelMessagesPlainScopedParams{ChannelID: *channelID, ScopeID: *scopeID, CursorID: cursorID, PageLimit: pageLimit})) + case channelID != nil: + rows, err = convertRows(q.ListChannelMessagesPlain(ctx, sqlc.ListChannelMessagesPlainParams{ChannelID: *channelID, CursorID: cursorID, PageLimit: pageLimit})) + case hasSites: + rows, err = convertRows(q.ListAllChannelMessagesByIATAs(ctx, sqlc.ListAllChannelMessagesByIATAsParams{Iatas: sites, CursorID: cursorID, PageLimit: pageLimit})) + case hasSince: + rows, err = convertRows(q.ListAllChannelMessagesSince(ctx, sqlc.ListAllChannelMessagesSinceParams{Since: ts, ScopeID: scopeID, CursorID: cursorID, PageLimit: pageLimit})) + case hasScope: + rows, err = convertRows(q.ListAllChannelMessagesPlainScoped(ctx, sqlc.ListAllChannelMessagesPlainScopedParams{ScopeID: *scopeID, CursorID: cursorID, PageLimit: pageLimit})) + default: + rows, err = convertRows(q.ListAllChannelMessagesPlain(ctx, sqlc.ListAllChannelMessagesPlainParams{CursorID: cursorID, PageLimit: pageLimit})) + } + if err != nil { + return api.Page[api.ChannelMessage]{}, err + } + hasMore := len(rows) > int(limit) + if hasMore { + rows = rows[:limit] + } + messages := make([]api.ChannelMessage, 0, len(rows)) + for _, v := range rows { + messages = append(messages, toChannelMessage(v.ID, v.PacketHashHex, v.ChannelHash, v.SenderName, v.Content, v.SentAt, v.ObservationCount, v.ScopeName, v.TransportCodesPresent)) + } + var nextCursor *int64 + if hasMore && len(messages) > 0 { + last := messages[len(messages)-1].ID + nextCursor = &last + } + return api.Page[api.ChannelMessage]{Items: messages, NextCursor: nextCursor, HasMore: hasMore}, nil +} + +// dedupeSites drops repeated codes in one pass, keeping first-occurrence order; never nil. +func dedupeSites(iatas []string) []string { + sites := make([]string, 0, len(iatas)) + seen := make(map[string]struct{}, len(iatas)) + for _, iata := range iatas { + if _, dup := seen[iata]; !dup { + seen[iata] = struct{}{} + sites = append(sites, iata) + } + } + return sites +} + +// messageRow is every list statement's row: the columns of sqlc.ListChannelMessagesRow. +type messageRow interface { + sqlc.ListChannelMessagesByIATAsRow | sqlc.ListChannelMessagesByIATAsScopedRow | sqlc.ListChannelMessagesPlainRow | + sqlc.ListChannelMessagesPlainScopedRow | sqlc.ListChannelMessagesSinceWalkRow | sqlc.ListAllChannelMessagesByIATAsRow | + sqlc.ListAllChannelMessagesPlainRow | + sqlc.ListAllChannelMessagesPlainScopedRow | sqlc.ListAllChannelMessagesSinceRow +} + +func convertRows[R messageRow](rows []R, err error) ([]sqlc.ListChannelMessagesRow, error) { + if err != nil { + return nil, err + } + out := make([]sqlc.ListChannelMessagesRow, len(rows)) + for i, r := range rows { + out[i] = sqlc.ListChannelMessagesRow(r) + } + return out, nil +} + +// listChannelMessagesLegacy is today's statement pair: one join over every observation, filtered in place. It +// serves the shapes that read the read model while this process does not trust it. +func listChannelMessagesLegacy(ctx context.Context, q sqlc.Querier, channelID *int32, since time.Time, limit int32, iatas []string, scope string, cursor int64) (api.Page[api.ChannelMessage], error) { ts := pgtype.Timestamptz{Time: since, Valid: !since.IsZero()} var messages []api.ChannelMessage var hasMore bool if channelID == nil { - rows, err := s.q.ListAllChannelMessages(ctx, sqlc.ListAllChannelMessagesParams{ + rows, err := q.ListAllChannelMessages(ctx, sqlc.ListAllChannelMessagesParams{ Column1: ts, Column2: iatas, Column3: scope, @@ -253,7 +395,7 @@ func (s *Store) ListChannelMessages(ctx context.Context, channelID *int32, since messages = append(messages, toChannelMessage(v.ID, v.PacketHashHex, v.ChannelHash, v.SenderName, v.Content, v.SentAt, v.ObservationCount, v.ScopeName, v.TransportCodesPresent)) } } else { - rows, err := s.q.ListChannelMessages(ctx, sqlc.ListChannelMessagesParams{ + rows, err := q.ListChannelMessages(ctx, sqlc.ListChannelMessagesParams{ ChannelID: *channelID, Column2: ts, Column3: iatas, diff --git a/db/channels_test.go b/db/channels_test.go index 4807f06..22e6a52 100644 --- a/db/channels_test.go +++ b/db/channels_test.go @@ -6,6 +6,8 @@ package db import ( "context" "errors" + "math" + "strings" "sync" "testing" "time" @@ -346,7 +348,7 @@ func TestListChannelMessages_DBError(t *testing.T) { mock := mockdb.NewMockQuerier(ctrl) mock.EXPECT(). - ListAllChannelMessages(gomock.Any(), gomock.Any()). + ListAllChannelMessagesPlain(gomock.Any(), gomock.Any()). Return(nil, errors.New("db error")) store := &Store{q: mock} @@ -690,3 +692,198 @@ func TestUpsertChannelFallbackErrorForgetsKey(t *testing.T) { t.Fatal("a key whose row is gone stayed cached") } } + +// earnedCmi returns read models whose cmi trust is earned. +func earnedCmi() *ReadModels { + tr := NewTrust("cmi_dispatch_test", true, CmiTrustPolicy) + tr.Earn() + return &ReadModels{Cmi: tr} +} + +func TestListChannelMessagesDispatch(t *testing.T) { + ch := int32(7) + since := time.Date(2026, 10, 18, 6, 48, 0, 0, time.UTC) + ts := pgtype.Timestamptz{Time: since, Valid: true} + scope := int32(3) + const maxCursor = int64(math.MaxInt64) + type call func(m *mockdb.MockQuerier) + scopeLookup := func(m *mockdb.MockQuerier) { + m.EXPECT().GetTransportScopeByName(gomock.Any(), "#fr").Return(scope, nil) + } + cases := []struct { + name string + channel *int32 + since time.Time + iatas []string + scope string + trusted bool + expect []call + }{ + {"by sites", &ch, time.Time{}, []string{"YUL", "YUL", "YOW"}, "", true, []call{func(m *mockdb.MockQuerier) { + m.EXPECT().ListChannelMessagesByIATAs(gomock.Any(), sqlc.ListChannelMessagesByIATAsParams{Iatas: []string{"YUL", "YOW"}, ChannelID: 7, CursorID: maxCursor, PageLimit: 51}).Return([]sqlc.ListChannelMessagesByIATAsRow{{ID: 1}}, nil) + }}}, + {"by sites and scope", &ch, time.Time{}, []string{"YUL"}, "#fr", true, []call{scopeLookup, func(m *mockdb.MockQuerier) { + m.EXPECT().ListChannelMessagesByIATAsScoped(gomock.Any(), sqlc.ListChannelMessagesByIATAsScopedParams{Iatas: []string{"YUL"}, ChannelID: 7, ScopeID: 3, CursorID: maxCursor, PageLimit: 51}).Return(nil, nil) + }}}, + {"plain nil sites", &ch, time.Time{}, nil, "", true, []call{func(m *mockdb.MockQuerier) { + m.EXPECT().ListChannelMessagesPlain(gomock.Any(), sqlc.ListChannelMessagesPlainParams{ChannelID: 7, CursorID: maxCursor, PageLimit: 51}).Return(nil, nil) + }}}, + {"plain empty sites untrusted", &ch, time.Time{}, []string{}, "", false, []call{func(m *mockdb.MockQuerier) { + m.EXPECT().ListChannelMessagesPlain(gomock.Any(), sqlc.ListChannelMessagesPlainParams{ChannelID: 7, CursorID: maxCursor, PageLimit: 51}).Return(nil, nil) + }}}, + {"plain scoped", &ch, time.Time{}, nil, "#fr", true, []call{scopeLookup, func(m *mockdb.MockQuerier) { + m.EXPECT().ListChannelMessagesPlainScoped(gomock.Any(), sqlc.ListChannelMessagesPlainScopedParams{ChannelID: 7, ScopeID: 3, CursorID: maxCursor, PageLimit: 51}).Return(nil, nil) + }}}, + {"since walk with sites and scope", &ch, since, []string{"YUL"}, "#fr", true, []call{scopeLookup, func(m *mockdb.MockQuerier) { + m.EXPECT().ListChannelMessagesSinceWalk(gomock.Any(), sqlc.ListChannelMessagesSinceWalkParams{ChannelID: 7, Since: ts, Iatas: []string{"YUL"}, ScopeID: &scope, CursorID: maxCursor, PageLimit: 51}).Return(nil, nil) + }}}, + {"since walk untrusted reads no cmi", &ch, since, nil, "", false, []call{func(m *mockdb.MockQuerier) { + m.EXPECT().ListChannelMessagesSinceWalk(gomock.Any(), sqlc.ListChannelMessagesSinceWalkParams{ChannelID: 7, Since: ts, Iatas: []string{}, CursorID: maxCursor, PageLimit: 51}).Return(nil, nil) + }}}, + {"all by sites", nil, time.Time{}, []string{"YUL"}, "", true, []call{func(m *mockdb.MockQuerier) { + m.EXPECT().ListAllChannelMessagesByIATAs(gomock.Any(), sqlc.ListAllChannelMessagesByIATAsParams{Iatas: []string{"YUL"}, CursorID: maxCursor, PageLimit: 51}).Return(nil, nil) + }}}, + // Sites with a scope or a since across every channel: each site's range has no bound on the scope or since, + // so these run today's statement, trusted or not. + {"all by sites and scope", nil, time.Time{}, []string{"YUL"}, "#fr", true, []call{func(m *mockdb.MockQuerier) { + m.EXPECT().ListAllChannelMessages(gomock.Any(), sqlc.ListAllChannelMessagesParams{Column1: pgtype.Timestamptz{}, Column2: []string{"YUL"}, Column3: "#fr", Column4: 0, Limit: 51}).Return(nil, nil) + }}}, + {"all by sites since", nil, since, []string{"YUL"}, "", true, []call{func(m *mockdb.MockQuerier) { + m.EXPECT().ListAllChannelMessages(gomock.Any(), sqlc.ListAllChannelMessagesParams{Column1: ts, Column2: []string{"YUL"}, Column3: "", Column4: 0, Limit: 51}).Return(nil, nil) + }}}, + {"all since scoped untrusted reads no cmi", nil, since, nil, "#fr", false, []call{scopeLookup, func(m *mockdb.MockQuerier) { + m.EXPECT().ListAllChannelMessagesSince(gomock.Any(), sqlc.ListAllChannelMessagesSinceParams{Since: ts, ScopeID: &scope, CursorID: maxCursor, PageLimit: 51}).Return(nil, nil) + }}}, + {"all plain untrusted", nil, time.Time{}, nil, "", false, []call{func(m *mockdb.MockQuerier) { + m.EXPECT().ListAllChannelMessagesPlain(gomock.Any(), sqlc.ListAllChannelMessagesPlainParams{CursorID: maxCursor, PageLimit: 51}).Return(nil, nil) + }}}, + {"all plain scoped", nil, time.Time{}, nil, "#fr", true, []call{scopeLookup, func(m *mockdb.MockQuerier) { + m.EXPECT().ListAllChannelMessagesPlainScoped(gomock.Any(), sqlc.ListAllChannelMessagesPlainScopedParams{ScopeID: 3, CursorID: maxCursor, PageLimit: 51}).Return(nil, nil) + }}}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + ctrl := gomock.NewController(t) + m := mockdb.NewMockQuerier(ctrl) + for _, e := range c.expect { + e(m) + } + s := &Store{q: m} + if c.trusted { + s.readModels = earnedCmi() + } + page, err := s.ListChannelMessages(context.Background(), c.channel, c.since, 50, c.iatas, c.scope, 0) + if err != nil || page.Items == nil { + t.Fatalf("page = %+v, %v", page, err) + } + }) + } + + // Every shape that reads cmi runs today's statement, with today's params, when cmi is not trusted. + disabled := NewTrust("cmi_dispatch_disabled", false, CmiTrustPolicy) + disabled.Earn() + dropped := NewTrust("cmi_dispatch_dropped", true, CmiTrustPolicy) + dropped.Earn() + for range 3 { + dropped.ObserveRun(1) + } + untrusted := map[string]*ReadModels{ + "nil": nil, "nil trust": {}, "not earned": {Cmi: NewTrust("cmi_dispatch_new", true, CmiTrustPolicy)}, + "disabled": {Cmi: disabled}, "dropped": {Cmi: dropped}, + } + shapes := []struct { + channel *int32 + since time.Time + iatas []string + scope string + }{ + {&ch, time.Time{}, []string{"YUL"}, ""}, {&ch, time.Time{}, []string{"YUL"}, "#fr"}, {&ch, time.Time{}, nil, "#fr"}, + {&ch, since, []string{"YUL"}, ""}, {nil, time.Time{}, []string{"YUL"}, ""}, {nil, time.Time{}, []string{"YUL"}, "#fr"}, + {nil, since, []string{"YUL"}, "#fr"}, {nil, time.Time{}, nil, "#fr"}, + } + for name, rm := range untrusted { + for i, sh := range shapes { + ctrl := gomock.NewController(t) + m := mockdb.NewMockQuerier(ctrl) + legacyTS := pgtype.Timestamptz{Time: sh.since, Valid: !sh.since.IsZero()} + if sh.channel != nil { + m.EXPECT().ListChannelMessages(gomock.Any(), sqlc.ListChannelMessagesParams{ChannelID: 7, Column2: legacyTS, Column3: sh.iatas, Column4: sh.scope, Column5: 0, Limit: 51}).Return(nil, nil) + } else { + m.EXPECT().ListAllChannelMessages(gomock.Any(), sqlc.ListAllChannelMessagesParams{Column1: legacyTS, Column2: sh.iatas, Column3: sh.scope, Column4: 0, Limit: 51}).Return(nil, nil) + } + s := &Store{q: m, readModels: rm} + if _, err := s.ListChannelMessages(context.Background(), sh.channel, sh.since, 50, sh.iatas, sh.scope, 0); err != nil { + t.Fatalf("%s shape %d: %v", name, i, err) + } + ctrl.Finish() + } + } + + // An unknown scope answers an empty page with no list query; another lookup error is returned. + for _, trusted := range []bool{true, false} { + ctrl := gomock.NewController(t) + m := mockdb.NewMockQuerier(ctrl) + m.EXPECT().GetTransportScopeByName(gomock.Any(), "#nope").Return(int32(0), pgx.ErrNoRows) + s := &Store{q: m} + var shapeChannel *int32 + shapeSince := time.Time{} + if trusted { + s.readModels = earnedCmi() + } else { + shapeSince = since // untrusted, only the non-cmi shapes look the scope up + } + page, err := s.ListChannelMessages(context.Background(), shapeChannel, shapeSince, 50, nil, "#nope", 0) + if err != nil || page.Items == nil || len(page.Items) != 0 || page.HasMore || page.NextCursor != nil { + t.Fatalf("unknown scope: %+v, %v", page, err) + } + ctrl.Finish() + } + ctrl := gomock.NewController(t) + m := mockdb.NewMockQuerier(ctrl) + m.EXPECT().GetTransportScopeByName(gomock.Any(), "#fr").Return(int32(0), errors.New("lookup failed")) + if _, err := (&Store{q: m, readModels: earnedCmi()}).ListChannelMessages(context.Background(), &ch, time.Time{}, 50, nil, "#fr", 0); err == nil { + t.Fatal("lookup error not returned") + } + + // Cursors: 0 is the newest page, any other value is passed as given; limit+1 rows fetched. + for _, cur := range []int64{-1, 3_000_000_000} { + ctrl := gomock.NewController(t) + m := mockdb.NewMockQuerier(ctrl) + m.EXPECT().ListChannelMessagesPlain(gomock.Any(), sqlc.ListChannelMessagesPlainParams{ChannelID: 7, CursorID: cur, PageLimit: 51}).Return(nil, nil) + if _, err := (&Store{q: m}).ListChannelMessages(context.Background(), &ch, time.Time{}, 50, nil, "", cur); err != nil { + t.Fatal(err) + } + ctrl.Finish() + } + ctrl = gomock.NewController(t) + m = mockdb.NewMockQuerier(ctrl) + rows := make([]sqlc.ListChannelMessagesPlainRow, 51) + for i := range rows { + rows[i] = sqlc.ListChannelMessagesPlainRow{ID: int64(100 - i)} + } + m.EXPECT().ListChannelMessagesPlain(gomock.Any(), gomock.Any()).Return(rows, nil) + page, err := (&Store{q: m}).ListChannelMessages(context.Background(), &ch, time.Time{}, 50, nil, "", 0) + if err != nil || len(page.Items) != 50 || !page.HasMore || page.NextCursor == nil || *page.NextCursor != 51 { + t.Fatalf("page of 51 = %d items, hasMore %v, next %v, %v", len(page.Items), page.HasMore, page.NextCursor, err) + } +} + +// Site lists come from the request with no cap: the dedupe is one pass, keeps first-occurrence order and is never nil. +func TestDedupeSitesLargeList(t *testing.T) { + in := make([]string, 200_000) + for i := range in { + in[i] = []string{"YUL", "YOW", "YYZ"}[i%3] + } + in[199_999] = "ZZZ" + start := time.Now() + got := dedupeSites(in) + if d := time.Since(start); d > time.Second { + t.Fatalf("200K codes took %s", d) + } + if strings.Join(got, ",") != "YUL,YOW,YYZ,ZZZ" { + t.Fatalf("dedupe = %v", got) + } + if empty := dedupeSites(nil); empty == nil || len(empty) != 0 { + t.Fatalf("nil input gave %#v", empty) + } +} diff --git a/db/cmi.go b/db/cmi.go new file mode 100644 index 0000000..6c9194d --- /dev/null +++ b/db/cmi.go @@ -0,0 +1,420 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package db + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "log/slog" + "math/rand/v2" + "reflect" + "time" + + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" +) + +const ( + cmiStateKey = "cmi" + // cmiBackfillBatch is the message ids one fill covers, in the backfill and the reconcile's message part. + cmiBackfillBatch int64 = 10_000 + // cmiObsSlice is the observation ids one fill of the reconcile's observation part covers. + cmiObsSlice int64 = 500_000 + // cmiFillAttempts bounds the retries of a fill that lost a message to a concurrent cascade (23503). + cmiFillAttempts = 3 + // cmiVerifyMessages is the width of each message range the verification checks exactly. + cmiVerifyMessages int64 = 2_000 + // cmiBatchPause separates backfill batches. + cmiBatchPause = 100 * time.Millisecond +) + +// CmiState is background_state['cmi']: the one-off backfill's progress and the reconcile watermarks. Nothing in it +// says the table is exact; each process earns that at boot. +type CmiState struct { + BackfillMaxID int64 `json:"backfill_max_id"` + BackfilledToID int64 `json:"backfilled_to_id"` + Complete bool `json:"complete"` + ObsPrevHi int64 `json:"obs_prev_hi"` + ObsHi int64 `json:"obs_hi"` + MsgPrevHi int64 `json:"msg_prev_hi"` + MsgHi int64 `json:"msg_hi"` + FirstVerifiedAt *time.Time `json:"first_verified_at,omitempty"` +} + +// CmiSession holds the cmi lock on one maintenance connection; every statement and state write goes through it. +type CmiSession struct { + conn *pgxpool.Conn + q *sqlc.Queries + state CmiState + // fills and retries count fill statements and 23503 retries, for tests. + fills, retries int + pause time.Duration // between backfill batches; 0 = cmiBatchPause, < 0 = none +} + +func (c *CmiSession) batchPause() time.Duration { + switch { + case c.pause < 0: + return 0 + case c.pause == 0: + return cmiBatchPause + } + return c.pause +} + +// BeginCmi takes the cmi lock for this schema on a dedicated connection. ok is false when another session holds it. +func (s *Store) BeginCmi(ctx context.Context) (*CmiSession, bool, error) { + if s.pool == nil { + return nil, false, errors.New("cmi: store has no dedicated pool") + } + conn, err := s.pool.Acquire(ctx) + if err != nil { + return nil, false, err + } + var ok bool + if err := conn.QueryRow(ctx, "SELECT pg_try_advisory_lock($1, hashtext(current_schema()))", cmiReconcileLockKey).Scan(&ok); err != nil { + conn.Release() + return nil, false, err + } + if !ok { + conn.Release() + return nil, false, nil + } + return &CmiSession{conn: conn, q: sqlc.New(conn)}, true, nil +} + +// Close releases the lock and the connection. If the unlock fails, the connection is closed, which drops the lock. +func (c *CmiSession) Close(ctx context.Context) { + if c.conn == nil { + return + } + if _, err := c.conn.Exec(ctx, "SELECT pg_advisory_unlock($1, hashtext(current_schema()))", cmiReconcileLockKey); err != nil { + _ = c.conn.Conn().Close(ctx) + } + c.conn.Release() + c.conn = nil +} + +// State returns the state as of the session's last read or write. +func (c *CmiSession) State() CmiState { return c.state } + +func (c *CmiSession) save(ctx context.Context) error { + return saveState(ctx, c.q, cmiStateKey, c.state) +} + +// Init loads the persisted state or, on first use, records where the backfill must reach and starts both +// reconcile ranges at the current maxima. +func (c *CmiSession) Init(ctx context.Context) (CmiState, error) { + var st CmiState + found, err := loadState(ctx, c.q, cmiStateKey, &st) + if err != nil { + return CmiState{}, fmt.Errorf("cmi state: %w", err) + } + if found { + c.state = st + return st, nil + } + msgHi, err := c.q.MaxChannelMessageID(ctx) + if err != nil { + return CmiState{}, err + } + obsHi, err := c.q.MaxObservationID(ctx) + if err != nil { + return CmiState{}, err + } + first, err := c.q.NextChannelMessageID(ctx, 0) + if err != nil { + return CmiState{}, err + } + c.state = CmiState{ + BackfillMaxID: msgHi, BackfilledToID: max(first-1, 0), Complete: msgHi == 0, + ObsPrevHi: obsHi, ObsHi: obsHi, MsgPrevHi: msgHi, MsgHi: msgHi, + } + return c.state, c.save(ctx) +} + +// fill runs one idempotent fill, retrying only when a message was cascaded away between the statement's snapshot +// and its foreign key check (SQLSTATE 23503). +func (c *CmiSession) fill(ctx context.Context, run func() (int64, error)) (int64, error) { + var err error + for attempt := 1; attempt <= cmiFillAttempts; attempt++ { + c.fills++ + var n int64 + if n, err = run(); err == nil { + return n, nil + } + var pgErr *pgconn.PgError + if !errors.As(err, &pgErr) || pgErr.Code != "23503" || attempt == cmiFillAttempts { + break + } + c.retries++ + } + return 0, err +} + +func (c *CmiSession) fillMessages(ctx context.Context, after, through int64) (int64, error) { + return c.fill(ctx, func() (int64, error) { + return c.q.FillChannelMessageIATAsByMessages(ctx, sqlc.FillChannelMessageIATAsByMessagesParams{AfterID: after, ThroughID: through}) + }) +} + +// Backfill fills cmi oldest to newest in batches of cmiBackfillBatch message ids, jumping id gaps, until it +// reaches BackfillMaxID (then Complete) or budget is spent. Progress is saved after every batch. +func (c *CmiSession) Backfill(ctx context.Context, budget time.Duration) (CmiState, error) { + deadline := time.Now().Add(budget) + for !c.state.Complete && time.Now().Before(deadline) { + if err := ctx.Err(); err != nil { + return c.state, err + } + next, err := c.q.NextChannelMessageID(ctx, c.state.BackfilledToID) + if err != nil { + return c.state, err + } + if next == 0 || next > c.state.BackfillMaxID { + c.state.Complete = true + if err := c.save(ctx); err != nil { + return c.state, err + } + slog.Info("cmi backfill complete", "component", "readmodel", "max_id", c.state.BackfillMaxID) + break + } + hi := min(next-1+cmiBackfillBatch, c.state.BackfillMaxID) + if _, err := c.fillMessages(ctx, next-1, hi); err != nil { + return c.state, fmt.Errorf("cmi backfill (%d, %d]: %w", next-1, hi, err) + } + c.state.BackfilledToID = hi + if err := c.save(ctx); err != nil { + return c.state, err + } + // A short pause between batches leaves room for ingest's writes and WAL on large deployments. + select { + case <-ctx.Done(): + return c.state, ctx.Err() + case <-time.After(c.batchPause()): + } + } + return c.state, nil +} + +// Reconcile fills the observation ids and the message ids that arrived since the run before last, so each range +// overlaps the previous run by one interval, and advances both watermarks monotonically. It returns the rows the +// two parts inserted: anything above zero was written by a path that bypassed the read model. +func (c *CmiSession) Reconcile(ctx context.Context) (int64, error) { + obsHi, err := c.q.MaxObservationID(ctx) + if err != nil { + return 0, err + } + msgHi, err := c.q.MaxChannelMessageID(ctx) + if err != nil { + return 0, err + } + var rows int64 + for lo := c.state.ObsPrevHi; lo < obsHi; lo += cmiObsSlice { + hi := min(lo+cmiObsSlice, obsHi) + n, err := c.fill(ctx, func() (int64, error) { + return c.q.FillChannelMessageIATAsByObservations(ctx, sqlc.FillChannelMessageIATAsByObservationsParams{AfterID: lo, ThroughID: hi}) + }) + if err != nil { + return rows, fmt.Errorf("cmi reconcile observations (%d, %d]: %w", lo, hi, err) + } + rows += n + } + for after := c.state.MsgPrevHi; ; { + next, err := c.q.NextChannelMessageID(ctx, after) + if err != nil { + return rows, err + } + if next == 0 || next > msgHi { + break + } + hi := min(next-1+cmiBackfillBatch, msgHi) + n, err := c.fillMessages(ctx, next-1, hi) + if err != nil { + return rows, fmt.Errorf("cmi reconcile messages (%d, %d]: %w", next-1, hi, err) + } + rows += n + after = hi + } + st := c.state + st.ObsPrevHi, st.ObsHi = st.ObsHi, max(obsHi, st.ObsHi) + st.MsgPrevHi, st.MsgHi = st.MsgHi, max(msgHi, st.MsgHi) + c.state = st + return rows, c.save(ctx) +} + +// CmiVerification is the outcome of one verification pass. +type CmiVerification struct { + Missing, Extra int64 // the exact check over the sampled message ranges + PagesCompared int + PageDiffs []string // "channel 7 iatas [YUL] cursor 0: legacy 51 rows, cmi 50 rows, first difference at 12" +} + +// OK reports a clean pass. +func (v CmiVerification) OK() bool { return v.Missing == 0 && v.Extra == 0 && len(v.PageDiffs) == 0 } + +// verifyRanges returns the newest cmiVerifyMessages-wide message range below MsgHi and one random range of the same +// width below it, as (after, through] pairs. +func (c *CmiSession) verifyRanges(first int64) [][2]int64 { + hi := c.state.MsgHi + ranges := [][2]int64{{max(hi-cmiVerifyMessages, 0), hi}} + if lo := max(first-1, 0); hi-cmiVerifyMessages-lo > cmiVerifyMessages { + start := lo + rand.Int64N(hi-cmiVerifyMessages-lo-cmiVerifyMessages) + ranges = append(ranges, [2]int64{start, start + cmiVerifyMessages}) + } + return ranges +} + +// checkRanges runs the exact check over ranges through q, counting observations up to ObsHi. +func (c *CmiSession) checkRanges(ctx context.Context, q sqlc.Querier, ranges [][2]int64) (CmiVerification, error) { + var v CmiVerification + for _, r := range ranges { + row, err := q.CheckChannelMessageIATAs(ctx, sqlc.CheckChannelMessageIATAsParams{ObsThrough: c.state.ObsHi, AfterID: r[0], ThroughID: r[1]}) + if err != nil { + return v, err + } + v.Missing += row.Missing + v.Extra += row.Extra + } + return v, nil +} + +// Verify is the first-time verification: it reconciles, VACUUMs and ANALYZEs the table (the index-only scans need +// its visibility map), then in one read-only snapshot runs the exact check over the newest messages and one random +// range below them, and compares today's and the read model's pages on the busiest recent sites and scopes, from +// the newest message and from a deeper cursor. The first pass is persisted as FirstVerifiedAt. An in-flight Add can +// make one attempt differ; the caller retries every interval. +func (c *CmiSession) Verify(ctx context.Context) (CmiVerification, error) { + if _, err := c.Reconcile(ctx); err != nil { + return CmiVerification{}, err + } + if _, err := c.conn.Exec(ctx, "VACUUM (ANALYZE) channel_message_iatas"); err != nil { + return CmiVerification{}, fmt.Errorf("cmi vacuum: %w", err) + } + tx, err := c.conn.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.RepeatableRead, AccessMode: pgx.ReadOnly}) + if err != nil { + return CmiVerification{}, err + } + defer tx.Rollback(context.Background()) //nolint:errcheck // read-only + q := sqlc.New(tx) + first, err := q.NextChannelMessageID(ctx, 0) + if err != nil { + return CmiVerification{}, err + } + v, err := c.checkRanges(ctx, q, c.verifyRanges(first)) + if err != nil { + return v, err + } + if err := comparePages(ctx, q, max(c.state.MsgHi-cmiVerifyMessages, 0), &v); err != nil { + return v, err + } + if err := tx.Rollback(ctx); err != nil { + return v, err + } + if !v.OK() { + slog.Error("cmi verification failed; pages stay on the original statements", "component", "readmodel", + "missing", v.Missing, "extra", v.Extra, "pages", v.PagesCompared, "diffs", len(v.PageDiffs), "first", v.PageDiffs[:min(len(v.PageDiffs), 3)]) + return v, nil + } + if c.state.FirstVerifiedAt == nil { + now := time.Now().UTC() + c.state.FirstVerifiedAt = &now + if err := c.save(ctx); err != nil { + return v, err + } + slog.Info("cmi first-time verification passed", "component", "readmodel", "pages", v.PagesCompared) + } + return v, nil +} + +const ( + cmiVerifySites = 5 + cmiVerifyScopes = 3 + cmiVerifyLimit = 50 +) + +// comparePages compares today's statement with the read model's on the busiest sites and scopes among messages +// above after: channel and all-channel pages, from cursor 0 and from page 1's 26th id. +func comparePages(ctx context.Context, q sqlc.Querier, after int64, v *CmiVerification) error { + type request struct { + channel *int32 + iatas []string + scope string + } + var requests []request + sites, err := q.ListChannelMessageIATASamples(ctx, sqlc.ListChannelMessageIATASamplesParams{AfterID: after, RowLimit: cmiVerifySites}) + if err != nil { + return err + } + for _, s := range sites { + requests = append(requests, request{channel: &s.ChannelID, iatas: []string{s.Iata}}, request{iatas: []string{s.Iata}}) + } + scopes, err := q.ListChannelMessageScopeSamples(ctx, sqlc.ListChannelMessageScopeSamplesParams{AfterID: after, RowLimit: cmiVerifyScopes}) + if err != nil { + return err + } + for _, s := range scopes { + requests = append(requests, request{channel: &s.ChannelID, scope: s.Name}, request{scope: s.Name}) + } + for _, r := range requests { + cursors := []int64{0} + for i, cursor := 0, int64(0); i < len(cursors); i++ { + cursor = cursors[i] + legacy, err := listChannelMessages(ctx, q, false, r.channel, time.Time{}, cmiVerifyLimit, r.iatas, r.scope, cursor) + if err != nil { + return err + } + model, err := listChannelMessages(ctx, q, true, r.channel, time.Time{}, cmiVerifyLimit, r.iatas, r.scope, cursor) + if err != nil { + return err + } + v.PagesCompared++ + if !reflect.DeepEqual(legacy, model) { + at := 0 + for at < min(len(legacy.Items), len(model.Items)) && reflect.DeepEqual(legacy.Items[at], model.Items[at]) { + at++ + } + where := "all channels" + if r.channel != nil { + where = fmt.Sprintf("channel %d", *r.channel) + } + v.PageDiffs = append(v.PageDiffs, fmt.Sprintf("%s iatas %v scope %q cursor %d: legacy %d rows, cmi %d rows, first difference at %d", + where, r.iatas, r.scope, cursor, len(legacy.Items), len(model.Items), at)) + } + if cursor == 0 && len(legacy.Items) > cmiVerifyLimit/2 { + cursors = append(cursors, legacy.Items[cmiVerifyLimit/2].ID) + } + } + } + return nil +} + +// CmiReadOnlyCheck is what a read-only server reads to decide whether to trust the table another process maintains. +type CmiReadOnlyCheck struct { + State CmiState + Verification CmiVerification // the exact check over the newest messages + Age time.Duration // since the writer last saved the state, on the database clock + Found bool // the state exists +} + +// CheckCmiReadOnly reads the persisted cmi state, its age, and runs the exact check over the newest messages. It +// writes nothing, so a read-only server can decide whether to trust the table another process maintains. +func (s *Store) CheckCmiReadOnly(ctx context.Context) (CmiReadOnlyCheck, error) { + row, err := s.q.GetBackgroundStateAge(ctx, cmiStateKey) + if errors.Is(err, pgx.ErrNoRows) { + return CmiReadOnlyCheck{}, nil + } + if err != nil { + return CmiReadOnlyCheck{}, err + } + out := CmiReadOnlyCheck{Found: true, Age: time.Duration(row.AgeSeconds * float64(time.Second))} + if err := json.Unmarshal(row.Value, &out.State); err != nil { + return out, fmt.Errorf("cmi state: %w", err) + } + c := &CmiSession{state: out.State} + out.Verification, err = c.checkRanges(ctx, s.q, [][2]int64{{max(out.State.MsgHi-cmiVerifyMessages, 0), out.State.MsgHi}}) + return out, err +} diff --git a/db/cmi_dispatch_integration_test.go b/db/cmi_dispatch_integration_test.go new file mode 100644 index 0000000..e360b92 --- /dev/null +++ b/db/cmi_dispatch_integration_test.go @@ -0,0 +1,428 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package db + +import ( + "context" + "encoding/json" + "fmt" + "math" + "math/rand/v2" + "reflect" + "slices" + "strings" + "testing" + "time" + + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" + "github.com/MeshCore-Beacon/beacon-server/internal/api" + "github.com/MeshCore-Beacon/beacon-server/internal/ingest" + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" +) + +var cmiSites = []string{"YUL", "YOW", "YYZ", "YVR", "YQB", "YHZ"} + +// cmiMessages is the dispatch fixture: messages on channels 7, 8 and 9, written through the real writers (the +// seeded insert after the first hearings, an Add for each later hearing). +type cmiMessages struct { + ids []int64 // every stored message, newest first + tiedAt time.Time // a sent_at several messages share + channel map[int64]int32 +} + +// buildCmiMessages fills f with 120 messages: multi-site packets, repeat hearings at one site, untyped hearings, +// a #fr share, equal sent_at on every tenth message, and one message whose packet has no observation. +func buildCmiMessages(f *cmiFixture) cmiMessages { + f.t.Helper() + f.exec("INSERT INTO iata_codes (iata) VALUES ('YHZ') ON CONFLICT DO NOTHING") + observers := map[string][]uuid.UUID{} + for _, site := range cmiSites { + for n := range 2 { + id := uuid.New() + f.exec("INSERT INTO observers (id, public_key) VALUES ($1, $2)", id, []byte(fmt.Sprintf("%s-%d", site, n))) + observers[site] = append(observers[site], id) + } + } + r := rand.New(rand.NewPCG(4, 2)) + base := time.Date(2026, 10, 18, 12, 0, 0, 0, time.UTC) + out := cmiMessages{tiedAt: base.Add(-30 * time.Minute), channel: map[int64]int32{}} + scope := int32(3) + for i := range 120 { + hash := []byte(fmt.Sprintf("msg-%03d", i)) + params := ingest.UpsertPacketParams{PacketHash: hash, PayloadType: 5, RouteType: 1, RawHeader: []byte{0x15}, RawPayload: []byte{byte(i)}} + if i%4 == 0 { + params.ScopeID = &scope + params.RouteType = 0 + params.TransportCodes = []byte{1, 2, 3, 4} + } + if _, err := f.store.UpsertPacket(f.ctx, params); err != nil { + f.t.Fatal(err) + } + channel := []int32{7, 7, 7, 8, 8, 9}[r.IntN(6)] + sites := slices.Clone(cmiSites) + r.Shuffle(len(sites), func(a, b int) { sites[a], sites[b] = sites[b], sites[a] }) + sites = sites[:1+r.IntN(3)] + if i == 77 { + sites = nil // a message whose packet was never stored as heard + } + hear := func(site string, n int) { + pt := int16(5) + if r.IntN(10) == 0 { + pt = 0 // stored with no payload type + } + o := ingest.InsertObservationParams{PacketHash: hash, ObserverID: observers[site][n], IATA: site, HeardAt: base, HashSize: 1, PayloadType: pt} + if _, _, err := f.store.InsertObservation(f.ctx, o); err != nil { + f.t.Fatal(err) + } + if pt == 0 { + f.exec("UPDATE packet_observations SET payload_type = NULL WHERE packet_hash = $1 AND observer_id = $2", hash, observers[site][n]) + } + } + first := 0 + if len(sites) > 0 { + first = 1 + r.IntN(len(sites)) + } + for _, site := range sites[:first] { + hear(site, 0) + } + sent := base.Add(-time.Duration(i) * time.Minute) + if i%10 == 0 { + sent = out.tiedAt + } + m, err := f.store.InsertChannelMessage(f.ctx, ingest.InsertChannelMessageParams{ChannelID: int(channel), PacketHash: hash, SenderName: "s", Content: fmt.Sprint(i), SentAt: sent}) + if err != nil || m == nil { + f.t.Fatalf("message %d: %+v, %v", i, m, err) + } + out.ids = append(out.ids, m.ID) + out.channel[m.ID] = channel + later := sites[first:] + if len(sites) > 0 && r.IntN(3) == 0 { + later = append(later, sites[0]) // a second observer at a site that already heard it + } + for _, site := range later { + n := 0 + if slices.Contains(sites[:first], site) { + n = 1 + } + hear(site, n) + if _, err := f.store.AddChannelMessageIATA(f.ctx, hash, site); err != nil { + f.t.Fatal(err) + } + } + } + slices.Reverse(out.ids) + f.exec("ANALYZE") + return out +} + +// bogusSites returns n three-letter codes that name no fixture site. +func bogusSites(n int) []string { + out := make([]string, 0, n) + for a := 'A'; a <= 'Z'; a++ { + for b := 'A'; b <= 'Z'; b++ { + for c := 'A'; c <= 'Z'; c++ { + if code := string([]rune{a, b, c}); len(out) < n && !slices.Contains(cmiSites, code) && code != "ZZZ" { + out = append(out, code) + } + } + } + } + return out +} + +// legacyPage is today's statement, through the legacy path, for the same request. +func legacyPage(ctx context.Context, q sqlc.Querier, channelID *int32, since time.Time, limit int32, iatas []string, scope string, cursor int64) (api.Page[api.ChannelMessage], error) { + return listChannelMessagesLegacy(ctx, q, channelID, since, limit, iatas, scope, cursor) +} + +func TestChannelMessagesByIATAsMatchesLegacyPostgres(t *testing.T) { + f := newCmiFixture(t) + fx := buildCmiMessages(f) + if missing, extra := f.definition(); missing != 0 || extra != 0 { + t.Fatalf("fixture: missing %d, extra %d", missing, extra) + } + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute) + defer cancel() + trusted := New(f.pool, nil, 0, 0, WithReadModels(earnedCmi())) + q := sqlc.New(f.pool) + + bogus := bogusSites(5000) + ch7, ch8, ch999 := int32(7), int32(8), int32(999) + channels := []*int32{nil, &ch7, &ch8, &ch999} + siteLists := [][]string{nil, {}, {"YUL"}, {"YUL", "YUL", "YOW"}, {"YUL "}, {"yul"}, {"YULX"}, {""}, cmiSites} + scopes := []string{"", "#fr", "#none", "#unknown", " "} + sinces := []time.Time{{}, time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC), time.Date(2100, 1, 1, 0, 0, 0, 0, time.UTC), fx.tiedAt} + cursors := []int64{0, fx.ids[len(fx.ids)/2], fx.ids[len(fx.ids)-1], math.MaxInt32, math.MaxInt32 + 1, 3_000_000_000, math.MaxInt64, -1} + limits := []int32{1, 2, 3, 50, 200} + + cases, nonEmpty := 0, 0 + compare := func(ch *int32, iatas []string, scope string, since time.Time, cursor int64, limit int32) { + t.Helper() + got, err := trusted.ListChannelMessages(ctx, ch, since, limit, iatas, scope, cursor) + if err != nil { + t.Fatal(err) + } + want, err := legacyPage(ctx, q, ch, since, limit, iatas, scope, cursor) + if err != nil { + t.Fatal(err) + } + cases++ + if len(want.Items) > 0 { + nonEmpty++ + } + if !reflect.DeepEqual(got, want) { + chs := "all" + if ch != nil { + chs = fmt.Sprint(*ch) + } + t.Fatalf("channel %s iatas %d %q scope %q since %v cursor %d limit %d:\n got %+v\nwant %+v", chs, len(iatas), iatas[:min(len(iatas), 3)], scope, since, cursor, limit, got, want) + } + } + for _, ch := range channels { + for _, sites := range siteLists { + for _, scope := range scopes { + for _, since := range sinces { + for _, cursor := range cursors { + for _, limit := range limits { + compare(ch, sites, scope, since, cursor, limit) + } + } + } + } + } + for _, scope := range scopes { + for _, since := range sinces { + for _, cursor := range cursors[:2] { + for _, limit := range []int32{1, 50} { + compare(ch, bogus, scope, since, cursor, limit) + } + } + } + } + } + t.Logf("%d cases identical, %d with rows", cases, nonEmpty) + if nonEmpty < 1000 { + t.Fatalf("only %d of %d cases returned rows: the fixture does not exercise the statements", nonEmpty, cases) + } + + // Cursor chains: both paths walk the same ids, each once, newest first. + chains := []struct { + ch *int32 + iatas []string + scope string + since time.Time + }{ + {&ch7, []string{"YUL"}, "", time.Time{}}, {&ch7, []string{"YUL", "YOW"}, "#fr", time.Time{}}, {&ch7, nil, "#fr", time.Time{}}, + {nil, []string{"YUL"}, "", time.Time{}}, {nil, nil, "#fr", time.Time{}}, {nil, nil, "", fx.tiedAt}, + } + walk := func(page func(cursor int64) (api.Page[api.ChannelMessage], error)) []int64 { + t.Helper() + var ids []int64 + cursor := int64(0) + for range 1000 { + p, err := page(cursor) + if err != nil { + t.Fatal(err) + } + for _, m := range p.Items { + ids = append(ids, m.ID) + } + if !p.HasMore { + return ids + } + cursor = *p.NextCursor + } + t.Fatal("chain did not end") + return nil + } + for i, c := range chains { + for _, limit := range []int32{1, 2, 3} { + got := walk(func(cur int64) (api.Page[api.ChannelMessage], error) { + return trusted.ListChannelMessages(ctx, c.ch, c.since, limit, c.iatas, c.scope, cur) + }) + want := walk(func(cur int64) (api.Page[api.ChannelMessage], error) { + return legacyPage(ctx, q, c.ch, c.since, limit, c.iatas, c.scope, cur) + }) + if !slices.Equal(got, want) || len(got) == 0 { + t.Fatalf("chain %d limit %d: %v, want %v", i, limit, got, want) + } + for j := 1; j < len(got); j++ { + if got[j] >= got[j-1] { + t.Fatalf("chain %d limit %d not strictly descending at %d: %v", i, limit, j, got) + } + } + } + } +} + +// recordingDBTX records the sqlc name of every statement, and the text and args of the last one. +type recordingDBTX struct { + sqlc.DBTX + names []string + sql string + args []any +} + +func (r *recordingDBTX) record(sql string, args []any) { + r.names = append(r.names, sqlcName(sql)) + r.sql, r.args = sql, args +} + +func (r *recordingDBTX) Exec(ctx context.Context, sql string, args ...any) (pgconn.CommandTag, error) { + r.record(sql, args) + return r.DBTX.Exec(ctx, sql, args...) +} + +func (r *recordingDBTX) Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error) { + r.record(sql, args) + return r.DBTX.Query(ctx, sql, args...) +} + +func (r *recordingDBTX) QueryRow(ctx context.Context, sql string, args ...any) pgx.Row { + r.record(sql, args) + return r.DBTX.QueryRow(ctx, sql, args...) +} + +func TestChannelMessagesZeroHitRegionPostgres(t *testing.T) { + f := newCmiFixture(t) + buildCmiMessages(f) + trusted := New(f.pool, nil, 0, 0, WithReadModels(earnedCmi())) + q := sqlc.New(f.pool) + ch := int32(7) + bogus := bogusSites(5000) + cases := []struct { + ch *int32 + iatas []string + scope string + }{ + {&ch, []string{"ZZZ"}, ""}, {nil, []string{"ZZZ"}, ""}, {&ch, []string{"YOW"}, "#none"}, + {&ch, nil, "#none"}, {nil, nil, "#none"}, {&ch, bogus, ""}, {nil, bogus, ""}, + } + for i, c := range cases { + got, err := trusted.ListChannelMessages(f.ctx, c.ch, time.Time{}, 50, c.iatas, c.scope, 0) + if err != nil { + t.Fatal(err) + } + want, err := legacyPage(f.ctx, q, c.ch, time.Time{}, 50, c.iatas, c.scope, 0) + if err != nil { + t.Fatal(err) + } + g, _ := json.Marshal(got) + w, _ := json.Marshal(want) + if string(g) != `{"items":[],"hasMore":false}` || string(g) != string(w) { + t.Fatalf("case %d: %s, today %s", i, g, w) + } + } + + // The zero-hit site reads a few index pages: no scan, no observations. + f.exec("VACUUM ANALYZE channel_message_iatas") + rec := &recordingDBTX{DBTX: f.pool} + if _, err := New(rec, nil, 0, 0, WithReadModels(earnedCmi())).ListChannelMessages(f.ctx, &ch, time.Time{}, 50, []string{"ZZZ"}, "", 0); err != nil { + t.Fatal(err) + } + if rec.names[len(rec.names)-1] != "ListChannelMessagesByIATAs" { + t.Fatalf("statements %v", rec.names) + } + tx, err := f.pool.Begin(f.ctx) + if err != nil { + t.Fatal(err) + } + defer tx.Rollback(context.Background()) //nolint:errcheck + if _, err := tx.Exec(f.ctx, "SET LOCAL enable_seqscan = off; SET LOCAL jit = off"); err != nil { + t.Fatal(err) + } + var plan string + if err := tx.QueryRow(f.ctx, "EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) "+rec.sql, rec.args...).Scan(&plan); err != nil { + t.Fatal(err) + } + var cmiNode map[string]any + var nodes []map[string]any + var visit func(n map[string]any) + visit = func(n map[string]any) { + nodes = append(nodes, n) + if n["Relation Name"] == "channel_message_iatas" { + cmiNode = n + } + if kids, ok := n["Plans"].([]any); ok { + for _, k := range kids { + visit(k.(map[string]any)) + } + } + } + var parsed []map[string]any + if err := json.Unmarshal([]byte(plan), &parsed); err != nil { + t.Fatal(err) + } + visit(parsed[0]["Plan"].(map[string]any)) + if cmiNode == nil || cmiNode["Node Type"] != "Index Only Scan" || cmiNode["Index Name"] != "idx_cmi_channel_site" || cmiNode["Actual Rows"].(float64) != 0 { + t.Fatalf("cmi node %v\n%s", cmiNode, plan) + } + for _, n := range nodes { + if n["Node Type"] == "Seq Scan" || n["Relation Name"] == "packet_observations" { + t.Fatalf("node %v in\n%s", n, plan) + } + } + root := parsed[0]["Plan"].(map[string]any) + if b := root["Shared Hit Blocks"].(float64) + root["Shared Read Blocks"].(float64); b > 10 { + t.Fatalf("zero-hit page read %v buffers", b) + } + + // An unknown scope runs the lookup and nothing else. + rec = &recordingDBTX{DBTX: f.pool} + if _, err := New(rec, nil, 0, 0, WithReadModels(earnedCmi())).ListChannelMessages(f.ctx, nil, time.Time{}, 50, nil, "#unknown", 0); err != nil { + t.Fatal(err) + } + if strings.Join(rec.names, ",") != "GetTransportScopeByName" { + t.Fatalf("an unknown scope ran %v", rec.names) + } +} + +func TestCmiTrustLifecyclePostgres(t *testing.T) { + f := newCmiFixture(t) + buildCmiMessages(f) + rec := &recordingDBTX{DBTX: f.pool} + tr := NewTrust("cmi_lifecycle_test", true, CmiTrustPolicy) + s := New(rec, nil, 0, 0, WithReadModels(&ReadModels{Cmi: tr})) + ch := int32(7) + var first api.Page[api.ChannelMessage] + step := func(label, want string) { + t.Helper() + rec.names = nil + page, err := s.ListChannelMessages(f.ctx, &ch, time.Time{}, 50, []string{"YUL"}, "", 0) + if err != nil { + t.Fatal(err) + } + if got := strings.Join(rec.names, ","); got != want { + t.Fatalf("%s: ran %s, want %s", label, got, want) + } + if len(page.Items) == 0 { + t.Fatalf("%s: empty page", label) + } + if first.Items == nil { + first = page + } else if !reflect.DeepEqual(page, first) { + t.Fatalf("%s: page differs", label) + } + } + step("not earned", "ListChannelMessages") + tr.Earn() + step("earned", "ListChannelMessagesByIATAs") + for range 3 { + tr.ObserveRun(1) + } + step("three repairing runs", "ListChannelMessages") + tr.ObserveRun(0) + tr.ObserveRun(0) + step("two clean runs", "ListChannelMessagesByIATAs") + tr.Invalidate("failed add") + step("a writer failure", "ListChannelMessages") + tr.Repaired(tr.Generation()) + step("the next reconcile", "ListChannelMessagesByIATAs") + disabled := NewTrust("cmi_lifecycle_disabled", false, CmiTrustPolicy) + disabled.Earn() + s.readModels = &ReadModels{Cmi: disabled} + step("disabled", "ListChannelMessages") +} diff --git a/db/cmi_migrations_integration_test.go b/db/cmi_migrations_integration_test.go new file mode 100644 index 0000000..f3b6fb9 --- /dev/null +++ b/db/cmi_migrations_integration_test.go @@ -0,0 +1,109 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package db + +import ( + "strings" + "testing" +) + +// cmiMigrations are the files that build channel_message_iatas, its indexes and the channel walk index. +var cmiMigrations = []string{ + "035_channel_message_iatas.sql", + "036_cmi_channel_site.sql", + "037_cmi_site.sql", + "038_cmi_channel_site_scope.sql", + "039_cmi_channel_scope.sql", + "040_cmi_scope.sql", + "041_channel_messages_channel_id.sql", +} + +// The migrations leave channel_message_iatas and channel_messages with exactly these indexes, all usable, and a +// message's site rows go with it. +func TestCmiMigrationsIndexSetPostgres(t *testing.T) { + ctx, pool := schemaPool(t) + if err := RunMigrations(ctx, pool); err != nil { + t.Fatal(err) + } + checkRecorded(t, ctx, pool, cmiMigrations...) + var schema string + if err := pool.QueryRow(ctx, "SELECT current_schema()").Scan(&schema); err != nil { + t.Fatal(err) + } + want := map[string]string{ + "channel_message_iatas_pkey": "CREATE UNIQUE INDEX channel_message_iatas_pkey ON public.channel_message_iatas USING btree (message_id, iata)", + "idx_cmi_channel_site": "CREATE INDEX idx_cmi_channel_site ON public.channel_message_iatas USING btree (channel_id, iata, message_id DESC)", + "idx_cmi_site": "CREATE INDEX idx_cmi_site ON public.channel_message_iatas USING btree (iata, message_id DESC)", + "idx_cmi_channel_site_scope": "CREATE INDEX idx_cmi_channel_site_scope ON public.channel_message_iatas USING btree (channel_id, iata, scope_id, message_id DESC) WHERE (scope_id IS NOT NULL)", + "idx_cmi_channel_scope": "CREATE INDEX idx_cmi_channel_scope ON public.channel_message_iatas USING btree (channel_id, scope_id, message_id DESC) WHERE (scope_id IS NOT NULL)", + "idx_cmi_scope": "CREATE INDEX idx_cmi_scope ON public.channel_message_iatas USING btree (scope_id, message_id DESC) WHERE (scope_id IS NOT NULL)", + "channel_messages_pkey": "CREATE UNIQUE INDEX channel_messages_pkey ON public.channel_messages USING btree (id)", + "channel_messages_packet_hash_key": "CREATE UNIQUE INDEX channel_messages_packet_hash_key ON public.channel_messages USING btree (packet_hash)", + "idx_channel_messages_channel_id": "CREATE INDEX idx_channel_messages_channel_id ON public.channel_messages USING btree (channel_id, id DESC)", + // Read only by the fallback statements; dropped a release later. + "idx_channel_messages_channel": "CREATE INDEX idx_channel_messages_channel ON public.channel_messages USING btree (channel_id, sent_at DESC)", + "idx_channel_messages_sent_brin": "CREATE INDEX idx_channel_messages_sent_brin ON public.channel_messages USING brin (sent_at)", + } + rows, err := pool.Query(ctx, `SELECT i.indexname, i.indexdef, x.indisvalid AND x.indisready +FROM pg_indexes i JOIN pg_index x ON x.indexrelid = format('%I.%I', i.schemaname, i.indexname)::regclass +WHERE i.schemaname = current_schema() AND i.tablename IN ('channel_message_iatas', 'channel_messages')`) + if err != nil { + t.Fatal(err) + } + got := map[string]string{} + for rows.Next() { + var name, def string + var ok bool + if err := rows.Scan(&name, &def, &ok); err != nil { + t.Fatal(err) + } + if !ok { + t.Errorf("%s is not valid and ready", name) + } + got[name] = strings.Replace(def, " ON "+schema+".", " ON public.", 1) + } + if err := rows.Err(); err != nil { + t.Fatal(err) + } + for name, def := range want { + if got[name] != def { + t.Errorf("%s:\n got %q\nwant %q", name, got[name], def) + } + } + for name := range got { + if _, ok := want[name]; !ok { + t.Errorf("unexpected index %s: %s", name, got[name]) + } + } + + var cols []string + if err := pool.QueryRow(ctx, `SELECT array_agg(column_name || ' ' || data_type || CASE WHEN is_nullable = 'NO' THEN ' NOT NULL' ELSE ' NULL' END ORDER BY ordinal_position) +FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = 'channel_message_iatas'`).Scan(&cols); err != nil { + t.Fatal(err) + } + wantCols := "message_id bigint NOT NULL,iata character NOT NULL,channel_id integer NOT NULL,scope_id integer NULL" + if strings.Join(cols, ",") != wantCols { + t.Errorf("columns = %v, want %s", cols, wantCols) + } + var iataLen int + if err := pool.QueryRow(ctx, `SELECT character_maximum_length FROM information_schema.columns +WHERE table_schema = current_schema() AND table_name = 'channel_message_iatas' AND column_name = 'iata'`).Scan(&iataLen); err != nil || iataLen != 3 { + t.Errorf("iata length = %d, %v; want character(3)", iataLen, err) + } + + // A packet's deletion cascades through its message to the message's site rows. + if _, err := pool.Exec(ctx, ` +INSERT INTO channels (id, channel_hash, name) VALUES (7, '\x11', 'fixture'); +INSERT INTO packets (packet_hash, payload_type, payload_version, route_type, raw_payload, raw_header, first_heard_at, last_heard_at) +VALUES ('\x01', 5, 0, 1, '\x00', '\x15', now(), now()); +INSERT INTO channel_messages (id, channel_id, packet_hash, sent_at) VALUES (3000000001, 7, '\x01', now()); +INSERT INTO channel_message_iatas (message_id, iata, channel_id) VALUES (3000000001, 'YUL', 7); +DELETE FROM packets;`); err != nil { + t.Fatal(err) + } + var left int + if err := pool.QueryRow(ctx, "SELECT count(*) FROM channel_message_iatas").Scan(&left); err != nil || left != 0 { + t.Fatalf("cmi rows after the packet delete = %d, %v", left, err) + } +} diff --git a/db/cmi_reconcile_integration_test.go b/db/cmi_reconcile_integration_test.go new file mode 100644 index 0000000..2477087 --- /dev/null +++ b/db/cmi_reconcile_integration_test.go @@ -0,0 +1,293 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package db + +import ( + "context" + "math" + "testing" + "time" + + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" +) + +const cmiBase = int64(3_000_000_000) + +// unseeded stores a message the way an older binary did: no site rows. +func (f *cmiFixture) unseeded(id int64, channel int32, hash []byte) { + f.t.Helper() + f.exec("INSERT INTO channel_messages (id, channel_id, packet_hash, sender_name, content, sent_at) VALUES ($1, $2, $3, 's', 'c', now())", id, channel, hash) +} + +// check runs the exact check over every message and observation. +func (f *cmiFixture) check() sqlc.CheckChannelMessageIATAsRow { + f.t.Helper() + row, err := f.store.q.CheckChannelMessageIATAs(f.ctx, sqlc.CheckChannelMessageIATAsParams{ObsThrough: math.MaxInt64, AfterID: 0, ThroughID: math.MaxInt64}) + if err != nil { + f.t.Fatal(err) + } + return row +} + +func (f *cmiFixture) count() int { + f.t.Helper() + var n int + if err := f.pool.QueryRow(f.ctx, "SELECT count(*) FROM channel_message_iatas").Scan(&n); err != nil { + f.t.Fatal(err) + } + return n +} + +func (f *cmiFixture) begin() *CmiSession { + f.t.Helper() + c, ok, err := f.store.BeginCmi(f.ctx) + if err != nil || !ok { + f.t.Fatalf("BeginCmi: ok %v, %v", ok, err) + } + f.t.Cleanup(func() { c.Close(context.Background()) }) + return c +} + +func (f *cmiFixture) reconcile(c *CmiSession) int64 { + f.t.Helper() + n, err := c.Reconcile(f.ctx) + if err != nil { + f.t.Fatal(err) + } + return n +} + +func TestCmiInitAndBackfillPostgres(t *testing.T) { + t.Run("empty", func(t *testing.T) { + f := newCmiFixture(t) + c := f.begin() + st, err := c.Init(f.ctx) + if err != nil || st != (CmiState{Complete: true}) { + t.Fatalf("Init = %+v, %v", st, err) + } + if st, err = c.Backfill(f.ctx, time.Minute); err != nil || !st.Complete { + t.Fatalf("Backfill = %+v, %v", st, err) + } + if got := f.check(); got.Missing != 0 || got.Extra != 0 { + t.Fatalf("check = %+v", got) + } + }) + + f := newCmiFixture(t) + var lastObs int64 + ids := []int64{1, 2, 3, 4, 5, 40_001, 40_002, 40_003} + for i, off := range ids { + h := f.packet(string(rune('a'+i)), 3) + f.obs(f.pool, h, "YUL", true) + lastObs = f.obs(f.pool, h, []string{"YOW", "YYZ"}[i%2], true) + f.unseeded(cmiBase+off, 7, h) + } + c := f.begin() + st, err := c.Init(f.ctx) + if err != nil { + t.Fatal(err) + } + maxID := cmiBase + 40_003 + want := CmiState{BackfillMaxID: maxID, BackfilledToID: cmiBase, ObsPrevHi: lastObs, ObsHi: lastObs, MsgPrevHi: maxID, MsgHi: maxID} + if st != want || c.State() != want { + t.Fatalf("Init = %+v, want %+v", st, want) + } + var loaded CmiState + if ok, err := f.store.LoadState(f.ctx, cmiStateKey, &loaded); !ok || err != nil || loaded != want { + t.Fatalf("persisted %+v (%v, %v), want %+v", loaded, ok, err, want) + } + var raw string + if err := f.pool.QueryRow(f.ctx, "SELECT value->>'backfill_max_id' FROM background_state WHERE key = 'cmi'").Scan(&raw); err != nil || raw != "3000040003" { + t.Fatalf("backfill_max_id stored as %q, %v", raw, err) + } + if missing := f.check().Missing; missing != 16 { + t.Fatalf("missing before the backfill = %d, want 16", missing) + } + + st, err = c.Backfill(f.ctx, time.Minute) + if err != nil || !st.Complete || st.BackfilledToID != maxID { + t.Fatalf("Backfill = %+v, %v", st, err) + } + if c.fills != 2 { + t.Fatalf("the backfill ran %d fills, want 2 (the id gap is jumped)", c.fills) + } + if got := f.check(); got.Missing != 0 || got.Extra != 0 { + t.Fatalf("check = %+v", got) + } + before := f.count() + if _, err := c.Backfill(f.ctx, time.Minute); err != nil || f.count() != before || c.fills != 2 { + t.Fatalf("a second backfill: %v, rows %d -> %d, fills %d", err, before, f.count(), c.fills) + } + + // One session per schema at a time; schemas do not contend. + if other, ok, err := f.store.BeginCmi(f.ctx); ok || err != nil { + if other != nil { + other.Close(f.ctx) + } + t.Fatalf("second session in the schema: ok %v, %v", ok, err) + } + g := newCmiFixture(t) + g.begin() +} + +func TestCmiMessageRangeReconcilePostgres(t *testing.T) { + f := newCmiFixture(t) + old := f.packet("old", 3) + f.obs(f.pool, old, "YUL", true) + f.obs(f.pool, old, "YOW", true) + f.obs(f.pool, old, "YYZ", false) + live := f.packet("live", 0) + f.obs(f.pool, live, "YUL", true) + f.message(f.store, 7, live, false) + + c := f.begin() + if _, err := c.Init(f.ctx); err != nil { + t.Fatal(err) + } + if _, err := c.Backfill(f.ctx, time.Minute); err != nil { + t.Fatal(err) + } + if n := f.reconcile(c); n != 0 { + t.Fatalf("clean reconcile repaired %d", n) + } + st := c.State() + + // An older binary imports a key and stores a message for the old packet, without sites. + var m int64 + if err := f.pool.QueryRow(f.ctx, "INSERT INTO channel_messages (channel_id, packet_hash, sent_at) VALUES (8, $1, now()) RETURNING id", old).Scan(&m); err != nil { + t.Fatal(err) + } + obsMax, err := f.store.q.MaxObservationID(f.ctx) + if err != nil { + t.Fatal(err) + } + if _, err := f.store.q.FillChannelMessageIATAsByObservations(f.ctx, sqlc.FillChannelMessageIATAsByObservationsParams{AfterID: st.ObsPrevHi, ThroughID: obsMax}); err != nil { + t.Fatal(err) + } + if missing := f.check().Missing; missing != 3 { + t.Fatalf("the observation range alone left %d missing, want 3", missing) + } + if n := f.reconcile(c); n != 3 { + t.Fatalf("reconcile repaired %d, want 3", n) + } + if got := f.check(); got.Missing != 0 || got.Extra != 0 { + t.Fatalf("check = %+v", got) + } + after := c.State() + if after.MsgHi != m || after.MsgPrevHi != st.MsgHi { + t.Fatalf("message watermarks %d/%d, want %d/%d", after.MsgPrevHi, after.MsgHi, st.MsgHi, m) + } + if n := f.reconcile(c); n != 0 { + t.Fatalf("next run repaired %d", n) + } +} + +func TestCmiObservationRangeReconcilePostgres(t *testing.T) { + f := newCmiFixture(t) + p := f.packet("P", 3) + f.obs(f.pool, p, "YUL", true) + f.message(f.store, 7, p, false) + c := f.begin() + if _, err := c.Init(f.ctx); err != nil { + t.Fatal(err) + } + if _, err := c.Backfill(f.ctx, time.Minute); err != nil { + t.Fatal(err) + } + f.reconcile(c) + prev := c.State() + + // Hearings stored without their Add: a new site, and an untyped observation at another. + f.obs(f.pool, p, "YOW", true) + f.obs(f.pool, p, "YYZ", false) + if n := f.reconcile(c); n != 2 { + t.Fatalf("reconcile repaired %d, want 2", n) + } + if got := f.check(); got.Missing != 0 || got.Extra != 0 { + t.Fatalf("check = %+v", got) + } + st := c.State() + if st.ObsPrevHi != prev.ObsHi || st.ObsHi <= prev.ObsHi { + t.Fatalf("observation watermarks %+v after %+v", st, prev) + } + for range 2 { + before := c.State() + if n := f.reconcile(c); n != 0 { + t.Fatalf("idle run repaired %d", n) + } + after := c.State() + if after.ObsHi < before.ObsHi || after.ObsPrevHi < before.ObsPrevHi || after.MsgHi < before.MsgHi || after.MsgPrevHi < before.MsgPrevHi { + t.Fatalf("watermarks moved back: %+v -> %+v", before, after) + } + } +} + +func TestCmiBackfillRetries23503Postgres(t *testing.T) { + f := newCmiFixture(t) + var hashes [][]byte + for i, site := range []string{"YUL", "YOW", "YYZ"} { + h := f.packet(site, 0) + f.obs(f.pool, h, site, true) + f.unseeded(cmiBase+int64(i)+1, 7, h) + hashes = append(hashes, h) + } + c := f.begin() + if _, err := c.Init(f.ctx); err != nil { + t.Fatal(err) + } + conn, err := f.pool.Acquire(f.ctx) + if err != nil { + t.Fatal(err) + } + defer conn.Release() + tx, err := conn.Begin(f.ctx) + if err != nil { + t.Fatal(err) + } + defer tx.Rollback(context.Background()) //nolint:errcheck + if _, err := tx.Exec(f.ctx, "DELETE FROM packets WHERE packet_hash = $1", hashes[0]); err != nil { + t.Fatal(err) + } + type result struct { + st CmiState + err error + } + done := make(chan result, 1) + pid := c.conn.Conn().PgConn().PID() + go func() { + st, err := c.Backfill(f.ctx, time.Minute) + done <- result{st, err} + }() + deadline := time.Now().Add(10 * time.Second) + for { + var waiting bool + if err := f.pool.QueryRow(f.ctx, "SELECT EXISTS (SELECT 1 FROM pg_locks WHERE pid = $1 AND NOT granted)", pid).Scan(&waiting); err != nil { + t.Fatal(err) + } + if waiting { + break + } + if time.Now().After(deadline) { + t.Fatal("the backfill never waited on the deleting transaction") + } + time.Sleep(5 * time.Millisecond) + } + if err := tx.Commit(f.ctx); err != nil { + t.Fatal(err) + } + r := <-done + if r.err != nil || !r.st.Complete { + t.Fatalf("Backfill = %+v, %v", r.st, r.err) + } + if c.retries != 1 { + t.Fatalf("retries = %d, want 1 (the first attempt fails with 23503)", c.retries) + } + want := []string{"3000000002/YOW/7/0", "3000000003/YYZ/7/0"} + if got := f.rows(); len(got) != 2 || got[0] != want[0] || got[1] != want[1] { + t.Fatalf("rows = %v, want %v", got, want) + } + if got := f.check(); got.Missing != 0 || got.Extra != 0 { + t.Fatalf("check = %+v", got) + } +} diff --git a/db/cmi_verify_integration_test.go b/db/cmi_verify_integration_test.go new file mode 100644 index 0000000..69675e7 --- /dev/null +++ b/db/cmi_verify_integration_test.go @@ -0,0 +1,98 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package db + +import ( + "context" + "testing" + "time" + + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" + "github.com/jackc/pgx/v5/pgxpool" +) + +func TestCmiFirstVerificationPostgres(t *testing.T) { + t.Run("empty", func(t *testing.T) { + f := newCmiFixture(t) + c := f.begin() + if _, err := c.Init(f.ctx); err != nil { + t.Fatal(err) + } + v, err := c.Verify(f.ctx) + if err != nil || !v.OK() || v.PagesCompared != 0 { + t.Fatalf("Verify = %+v, %v", v, err) + } + }) + + f := newCmiFixture(t) + buildCmiMessages(f) + f.exec("TRUNCATE channel_message_iatas") // as on a first install: the backfill fills it + c := f.begin() + if _, err := c.Init(f.ctx); err != nil { + t.Fatal(err) + } + if _, err := c.Backfill(f.ctx, time.Minute); err != nil { + t.Fatal(err) + } + v, err := c.Verify(f.ctx) + if err != nil || !v.OK() || v.PagesCompared < 10 { + t.Fatalf("Verify = %+v, %v", v, err) + } + first := c.State().FirstVerifiedAt + var loaded CmiState + if _, err := f.store.LoadState(f.ctx, cmiStateKey, &loaded); err != nil || first == nil || loaded.FirstVerifiedAt == nil || !loaded.FirstVerifiedAt.Equal(*first) { + t.Fatalf("first_verified_at %v persisted as %+v (%v)", first, loaded, err) + } + var reltuples float64 + if err := f.pool.QueryRow(f.ctx, "SELECT reltuples FROM pg_class WHERE oid = 'channel_message_iatas'::regclass").Scan(&reltuples); err != nil || reltuples <= 0 { + t.Fatalf("reltuples = %v (%v): no ANALYZE", reltuples, err) + } + + // Damage below the watermarks, where no reconcile looks: the newest message of the busiest sampled pair loses + // a site. + samples, err := f.store.q.ListChannelMessageIATASamples(f.ctx, sqlc.ListChannelMessageIATASamplesParams{AfterID: 0, RowLimit: 1}) + if err != nil || len(samples) != 1 { + t.Fatalf("samples %v, %v", samples, err) + } + f.exec(`DELETE FROM channel_message_iatas WHERE (message_id, iata) = ( + SELECT message_id, iata FROM channel_message_iatas WHERE channel_id = $1 AND iata = $2 ORDER BY message_id DESC LIMIT 1)`, samples[0].ChannelID, samples[0].Iata) + v, err = c.Verify(f.ctx) + if err != nil || v.Missing != 1 || v.Extra != 0 || len(v.PageDiffs) == 0 || v.OK() { + t.Fatalf("damaged Verify = %+v, %v", v, err) + } + if got := c.State().FirstVerifiedAt; got == nil || !got.Equal(*first) { + t.Fatalf("first_verified_at moved: %v -> %v", first, got) + } + t.Logf("diffs: %v", v.PageDiffs) + + // Repair, then the read-only check on a read-only pool. + f.exec("TRUNCATE channel_message_iatas") + f.exec("DELETE FROM background_state WHERE key = 'cmi'") + c.Close(f.ctx) + c = f.begin() + if _, err := c.Init(f.ctx); err != nil { + t.Fatal(err) + } + if _, err := c.Backfill(f.ctx, time.Minute); err != nil { + t.Fatal(err) + } + if v, err := c.Verify(f.ctx); err != nil || !v.OK() { + t.Fatalf("Verify after the rebuild = %+v, %v", v, err) + } + cfg := f.pool.Config().Copy() + cfg.ConnConfig.RuntimeParams["default_transaction_read_only"] = "on" + ro, err := pgxpool.NewWithConfig(context.Background(), cfg) + if err != nil { + t.Fatal(err) + } + defer ro.Close() + rc, err := New(ro, ro, 0, 0).CheckCmiReadOnly(f.ctx) + if err != nil || !rc.Found || !rc.Verification.OK() || !rc.State.Complete || rc.State.FirstVerifiedAt == nil || rc.Age < 0 || rc.Age > time.Minute { + t.Fatalf("CheckCmiReadOnly = %+v, %v", rc, err) + } + f.exec("UPDATE background_state SET updated_at = now() - interval '11 minutes' WHERE key = 'cmi'") + if rc, err = New(ro, ro, 0, 0).CheckCmiReadOnly(f.ctx); err != nil || rc.Age < 11*time.Minute || rc.Age > 12*time.Minute { + t.Fatalf("age after 11 minutes = %v, %v", rc.Age, err) + } +} diff --git a/db/cmi_writer_integration_test.go b/db/cmi_writer_integration_test.go new file mode 100644 index 0000000..7782cd4 --- /dev/null +++ b/db/cmi_writer_integration_test.go @@ -0,0 +1,455 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package db + +import ( + "context" + "errors" + "fmt" + "slices" + "testing" + "time" + + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" + "github.com/MeshCore-Beacon/beacon-server/internal/ingest" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgtype" + "github.com/jackc/pgx/v5/pgxpool" +) + +// cmiFixture is a migrated schema whose message and observation ids start above 3,000,000,000, with sites, +// scopes #fr (3) and #none (4), and channels 7, 8 and 9. +type cmiFixture struct { + t *testing.T + ctx context.Context + pool *pgxpool.Pool + store *Store +} + +func newCmiFixture(t *testing.T) *cmiFixture { + t.Helper() + ctx, pool := schemaPool(t) + if err := RunMigrations(ctx, pool); err != nil { + t.Fatal(err) + } + f := &cmiFixture{t: t, ctx: ctx, pool: pool, store: New(pool, pool, 0, 0)} + f.exec(`SELECT setval('channel_messages_id_seq', 3000000000); +SELECT setval('packet_observations_id_seq', 3000000000); +INSERT INTO iata_codes (iata) VALUES ('YUL'),('YOW'),('YYZ'),('YVR'),('YQB'),('BAD'),('ZZZ') ON CONFLICT DO NOTHING; +INSERT INTO transport_scopes (id, name, transport_key, key_fingerprint) VALUES (3, '#fr', '\x00', '\x01'), (4, '#none', '\x02', '\x03'); +INSERT INTO channels (id, channel_hash, name) VALUES (7, '\x11', 'ch7'), (8, '\x12', 'ch8'), (9, '\x13', 'ch9');`) + return f +} + +func (f *cmiFixture) exec(sql string, args ...any) { + f.t.Helper() + if _, err := f.pool.Exec(f.ctx, sql, args...); err != nil { + f.t.Fatal(err) + } +} + +// packet stores a group-text packet with the given scope id (0 = none). +func (f *cmiFixture) packet(hash string, scope int32) []byte { + f.t.Helper() + h := []byte(hash) + var scopeID *int32 + if scope != 0 { + scopeID = &scope + } + f.exec(`INSERT INTO packets (packet_hash, payload_type, payload_version, route_type, scope_id, raw_payload, raw_header, first_heard_at, last_heard_at, observation_count) +VALUES ($1, 5, 0, 1, $2, '\x00', '\x15', now(), now(), 0)`, h, scopeID) + return h +} + +// obs stores one observation of hash at iata by a new observer and returns its id; typed=false leaves payload_type NULL. +func (f *cmiFixture) obs(db execQuerier, hash []byte, iata string, typed bool) int64 { + f.t.Helper() + var pt *int16 + if typed { + v := int16(5) + pt = &v + } + var id int64 + if err := db.QueryRow(f.ctx, `WITH o AS (INSERT INTO observers (public_key) VALUES (decode(md5(random()::text), 'hex')) RETURNING id) +INSERT INTO packet_observations (packet_hash, observer_id, iata, heard_at, path_length_byte, hash_size, hop_count, payload_type) +SELECT $1, o.id, $2, now(), 0, 1, 0, $3 FROM o RETURNING id`, hash, iata, pt).Scan(&id); err != nil { + f.t.Fatal(err) + } + return id +} + +func (f *cmiFixture) message(s *Store, channel int, hash []byte, historical bool) *ingest.InsertedChannelMessage { + f.t.Helper() + m, err := s.InsertChannelMessage(f.ctx, ingest.InsertChannelMessageParams{ChannelID: channel, PacketHash: hash, SenderName: "s", Content: "c", SentAt: time.Now(), Historical: historical}) + if err != nil { + f.t.Fatal(err) + } + return m +} + +// rows lists the cmi rows as "message/iata/channel/scope", in key order. +func (f *cmiFixture) rows() []string { + f.t.Helper() + rows, err := f.pool.Query(f.ctx, "SELECT message_id, iata, channel_id, coalesce(scope_id, 0) FROM channel_message_iatas ORDER BY 1, 2") + if err != nil { + f.t.Fatal(err) + } + out, err := pgx.CollectRows(rows, func(r pgx.CollectableRow) (string, error) { + var m int64 + var iata string + var ch, sc int32 + err := r.Scan(&m, &iata, &ch, &sc) + return fmt.Sprintf("%d/%s/%d/%d", m, iata, ch, sc), err + }) + if err != nil { + f.t.Fatal(err) + } + return out +} + +// definition counts the pairs the read model's definition has and the table lacks, and table pairs no stored +// observation backs, over every message. +func (f *cmiFixture) definition() (missing, extra int64) { + f.t.Helper() + if err := f.pool.QueryRow(f.ctx, `WITH def AS ( + SELECT DISTINCT cm.id AS message_id, po.iata, cm.channel_id, p.scope_id + FROM channel_messages cm JOIN packets p ON p.packet_hash = cm.packet_hash JOIN packet_observations po ON po.packet_hash = cm.packet_hash +), have AS (SELECT message_id, iata, channel_id, scope_id FROM channel_message_iatas) +SELECT (SELECT count(*) FROM (SELECT * FROM def EXCEPT SELECT * FROM have) m), (SELECT count(*) FROM (SELECT * FROM have EXCEPT SELECT * FROM def) x)`).Scan(&missing, &extra); err != nil { + f.t.Fatal(err) + } + return missing, extra +} + +func (f *cmiFixture) checkDefinition(label string) { + f.t.Helper() + if missing, extra := f.definition(); missing != 0 || extra != 0 { + f.t.Fatalf("%s: missing %d, extra %d; rows %v", label, missing, extra, f.rows()) + } +} + +func TestInsertChannelMessageSeedsSitesPostgres(t *testing.T) { + f := newCmiFixture(t) + p := f.packet("P", 3) + f.obs(f.pool, p, "YUL", true) + f.obs(f.pool, p, "YOW", true) + f.obs(f.pool, p, "YUL", true) + m := f.message(f.store, 7, p, true) + if m == nil || m.ID <= 3000000000 { + t.Fatalf("message = %+v", m) + } + want := []string{fmt.Sprintf("%d/YOW/7/3", m.ID), fmt.Sprintf("%d/YUL/7/3", m.ID)} + if got := f.rows(); !slices.Equal(got, want) { + t.Fatalf("rows = %v, want %v", got, want) + } + if again := f.message(f.store, 7, p, true); again != nil { + t.Fatalf("duplicate returned %+v", again) + } + if got := f.rows(); !slices.Equal(got, want) { + t.Fatalf("rows after the duplicate = %v, want %v", got, want) + } + var dirty int + if err := f.pool.QueryRow(f.ctx, "SELECT count(*) FROM analytics_dirty_hours WHERE hour = date_trunc('hour', now(), 'UTC')").Scan(&dirty); err != nil || dirty != 1 { + t.Fatalf("historical message queued %d hours: %v", dirty, err) + } + + // A packet with no observation: the message is stored, with no site. + q := f.packet("Q", 0) + if mq := f.message(f.store, 8, q, false); mq == nil { + t.Fatal("message without observations not stored") + } + if got := f.rows(); !slices.Equal(got, want) { + t.Fatalf("rows = %v, want %v", got, want) + } + f.checkDefinition("seed") +} + +func TestInsertChannelMessageSeedFallbackPostgres(t *testing.T) { + f := newCmiFixture(t) + f.exec("ALTER TABLE channel_message_iatas ADD CONSTRAINT reject_bad CHECK (iata <> 'BAD')") + p := f.packet("P", 0) + f.obs(f.pool, p, "BAD", true) + m := f.message(f.store, 7, p, false) + if m == nil { + t.Fatal("the unseeded statement did not store the message") + } + if got := f.rows(); len(got) != 0 { + t.Fatalf("rows = %v, want none", got) + } + ch, err := f.store.GetChannel(f.ctx, 7) + if err != nil || ch.MessageCount != 1 { + t.Fatalf("message count = %+v, %v; want 1", ch, err) + } + if again := f.message(f.store, 7, p, false); again != nil { + t.Fatalf("duplicate through the fallback returned %+v", again) + } + + // A packet missing from packets: both statements return today's foreign key error. + _, err = f.store.InsertChannelMessage(f.ctx, ingest.InsertChannelMessageParams{ChannelID: 7, PacketHash: []byte("missing"), SentAt: time.Now()}) + var pgErr *pgconn.PgError + if !errors.As(err, &pgErr) || pgErr.Code != "23503" { + t.Fatalf("missing packet: %v, want 23503", err) + } + _, err = f.store.q.InsertChannelMessageUnseeded(f.ctx, sqlc.InsertChannelMessageUnseededParams{ChannelID: 7, PacketHash: []byte("missing"), SentAt: pgtype.Timestamptz{Time: time.Now(), Valid: true}}) + if !errors.As(err, &pgErr) || pgErr.Code != "23503" { + t.Fatalf("missing packet, unseeded: %v, want 23503", err) + } +} + +func TestAddChannelMessageIATAPostgres(t *testing.T) { + f := newCmiFixture(t) + p := f.packet("P", 3) + if found, err := f.store.AddChannelMessageIATA(f.ctx, p, "YOW"); err != nil || found { + t.Fatalf("Add with no message: found %v, %v", found, err) + } + if got := f.rows(); len(got) != 0 { + t.Fatalf("Add with no message wrote %v", got) + } + m := f.message(f.store, 9, p, false) + for range 2 { + if found, err := f.store.AddChannelMessageIATA(f.ctx, p, "YOW"); err != nil || !found { + t.Fatalf("Add with a message: found %v, %v", found, err) + } + } + if got, want := f.rows(), []string{fmt.Sprintf("%d/YOW/9/3", m.ID)}; !slices.Equal(got, want) { + t.Fatalf("rows = %v, want %v", got, want) + } +} + +// cmiLane is one ingest worker on its own connection: an observation commit, then the message insert, then the +// Add when the insert returned no row. +type cmiLane struct { + f *cmiFixture + conn *pgxpool.Conn + tx pgx.Tx + site string + hash []byte +} + +func (f *cmiFixture) lane(site string, hash []byte) *cmiLane { + f.t.Helper() + conn, err := f.pool.Acquire(f.ctx) + if err != nil { + f.t.Fatal(err) + } + f.t.Cleanup(conn.Release) + return &cmiLane{f: f, conn: conn, site: site, hash: hash} +} + +func (l *cmiLane) obs() { l.f.obs(l.conn, l.hash, l.site, true) } + +// icm runs the insert (inside the open transaction when there is one) and, when it returned no row outside a +// transaction, the Add. +func (l *cmiLane) icm(historical bool) *ingest.InsertedChannelMessage { + l.f.t.Helper() + var db sqlc.DBTX = l.conn + if l.tx != nil { + db = l.tx + } + m, err := New(db, nil, 0, 0).InsertChannelMessage(l.f.ctx, ingest.InsertChannelMessageParams{ChannelID: 7, PacketHash: l.hash, SenderName: "s", Content: "c", SentAt: time.Now(), Historical: historical}) + if err != nil { + l.f.t.Fatal(err) + } + if m == nil && l.tx == nil { + l.add() + } + return m +} + +func (l *cmiLane) add() { + l.f.t.Helper() + if _, err := New(l.conn, nil, 0, 0).AddChannelMessageIATA(l.f.ctx, l.hash, l.site); err != nil { + l.f.t.Fatal(err) + } +} + +func (l *cmiLane) open(historical bool) { + l.f.t.Helper() + tx, err := l.conn.Begin(l.f.ctx) + if err != nil { + l.f.t.Fatal(err) + } + l.tx = tx + l.icm(historical) +} + +func (l *cmiLane) end(commit bool) { + l.f.t.Helper() + var err error + if commit { + err = l.tx.Commit(l.f.ctx) + } else { + err = l.tx.Rollback(l.f.ctx) + } + l.tx = nil + if err != nil { + l.f.t.Fatal(err) + } +} + +// icmWaiting starts the lane's insert, waits until Postgres shows it blocked on a lock, and returns a function +// that waits for it (and its Add) to finish. +func (l *cmiLane) icmWaiting() func() *ingest.InsertedChannelMessage { + l.f.t.Helper() + pid := l.conn.Conn().PgConn().PID() + done := make(chan *ingest.InsertedChannelMessage, 1) + failed := make(chan error, 1) + go func() { + m, err := New(l.conn, nil, 0, 0).InsertChannelMessage(l.f.ctx, ingest.InsertChannelMessageParams{ChannelID: 7, PacketHash: l.hash, SenderName: "s", Content: "c", SentAt: time.Now()}) + if err == nil && m == nil { + _, err = New(l.conn, nil, 0, 0).AddChannelMessageIATA(l.f.ctx, l.hash, l.site) + } + if err != nil { + failed <- err + return + } + done <- m + }() + deadline := time.Now().Add(10 * time.Second) + for { + var waiting bool + if err := l.f.pool.QueryRow(l.f.ctx, "SELECT EXISTS (SELECT 1 FROM pg_locks WHERE pid = $1 AND NOT granted)", pid).Scan(&waiting); err != nil { + l.f.t.Fatal(err) + } + if waiting { + break + } + select { + case err := <-failed: + l.f.t.Fatalf("insert did not wait: %v", err) + case m := <-done: + l.f.t.Fatalf("insert did not wait: returned %+v", m) + default: + } + if time.Now().After(deadline) { + l.f.t.Fatal("insert never waited") + } + time.Sleep(5 * time.Millisecond) + } + return func() *ingest.InsertedChannelMessage { + select { + case err := <-failed: + l.f.t.Fatal(err) + case m := <-done: + return m + case <-time.After(10 * time.Second): + l.f.t.Fatal("insert never finished") + } + return nil + } +} + +// Every interleaving of two or three writers of one packet leaves exactly the definition's pairs, with no +// reconcile: the seed covers what its snapshot saw, and every lane that did not create the message adds its site. +func TestCmiSeedAndAddRacePostgres(t *testing.T) { + type sched struct { + name string + run func(f *cmiFixture, hash []byte) + } + schedules := []sched{ + {"sequential", func(f *cmiFixture, h []byte) { + a, b := f.lane("YUL", h), f.lane("YOW", h) + a.obs() + a.icm(false) + b.obs() + b.icm(false) + }}, + {"both_heard_then_a_inserts", func(f *cmiFixture, h []byte) { + a, b := f.lane("YUL", h), f.lane("YOW", h) + a.obs() + b.obs() + a.icm(false) + b.icm(false) + }}, + {"both_heard_then_b_inserts", func(f *cmiFixture, h []byte) { + a, b := f.lane("YUL", h), f.lane("YOW", h) + a.obs() + b.obs() + b.icm(false) + a.icm(false) + }}, + {"b_heard_during_a_insert_and_waits", func(f *cmiFixture, h []byte) { + a, b := f.lane("YUL", h), f.lane("YOW", h) + a.obs() + a.open(false) + b.obs() + wait := b.icmWaiting() + a.end(true) + if m := wait(); m != nil { + f.t.Fatalf("B created %+v", m) + } + }}, + {"b_heard_during_a_insert_inserts_after", func(f *cmiFixture, h []byte) { + a, b := f.lane("YUL", h), f.lane("YOW", h) + a.obs() + a.open(false) + b.obs() + a.end(true) + b.icm(false) + }}, + {"both_heard_b_waits_on_a", func(f *cmiFixture, h []byte) { + a, b := f.lane("YUL", h), f.lane("YOW", h) + a.obs() + b.obs() + a.open(false) + wait := b.icmWaiting() + a.end(true) + wait() + }}, + {"live_waits_on_historical_insert", func(f *cmiFixture, h []byte) { + old, b := f.lane("YYZ", h), f.lane("YOW", h) + old.obs() + old.open(true) + b.obs() + wait := b.icmWaiting() + old.end(true) + wait() + }}, + {"a_rolls_back_while_b_waits", func(f *cmiFixture, h []byte) { + a, b := f.lane("YUL", h), f.lane("YOW", h) + a.obs() + a.open(false) + b.obs() + wait := b.icmWaiting() + a.end(false) + if m := wait(); m == nil { + f.t.Fatal("B did not create the message after A rolled back") + } + }}, + {"two_wait_on_a", func(f *cmiFixture, h []byte) { + a, b, c := f.lane("YUL", h), f.lane("YOW", h), f.lane("YYZ", h) + a.obs() + a.open(false) + b.obs() + c.obs() + waitB := b.icmWaiting() + waitC := c.icmWaiting() + a.end(true) + waitB() + waitC() + }}, + {"later_hearings_same_and_new_site", func(f *cmiFixture, h []byte) { + a := f.lane("YUL", h) + a.obs() + a.icm(false) + a.obs() + a.icm(false) + a.site = "YQB" + a.obs() + a.icm(false) + }}, + } + for _, s := range schedules { + t.Run(s.name, func(t *testing.T) { + f := newCmiFixture(t) + s.run(f, f.packet("race", 3)) + var messages int + if err := f.pool.QueryRow(f.ctx, "SELECT count(*) FROM channel_messages").Scan(&messages); err != nil || messages != 1 { + t.Fatalf("%s: %d messages, %v", s.name, messages, err) + } + f.checkDefinition(s.name) + }) + } +} diff --git a/db/migrations/035_channel_message_iatas.sql b/db/migrations/035_channel_message_iatas.sql new file mode 100644 index 0000000..95e19dc --- /dev/null +++ b/db/migrations/035_channel_message_iatas.sql @@ -0,0 +1,11 @@ +-- Copyright 2026 Beacon Contributors +-- SPDX-License-Identifier: AGPL-3.0-or-later + +-- One row per (channel message, site that heard it); region message pages read this instead of every observation. +CREATE TABLE channel_message_iatas ( + message_id bigint NOT NULL REFERENCES channel_messages(id) ON DELETE CASCADE, + iata character(3) NOT NULL, + channel_id integer NOT NULL, + scope_id integer, + PRIMARY KEY (message_id, iata) +); diff --git a/db/migrations/036_cmi_channel_site.sql b/db/migrations/036_cmi_channel_site.sql new file mode 100644 index 0000000..e25bec9 --- /dev/null +++ b/db/migrations/036_cmi_channel_site.sql @@ -0,0 +1,5 @@ +-- Copyright 2026 Beacon Contributors +-- SPDX-License-Identifier: AGPL-3.0-or-later + +-- Channel pages filtered by site walk one (channel, site) range each. +CREATE INDEX CONCURRENTLY idx_cmi_channel_site ON channel_message_iatas USING btree (channel_id, iata, message_id DESC); diff --git a/db/migrations/037_cmi_site.sql b/db/migrations/037_cmi_site.sql new file mode 100644 index 0000000..a6da879 --- /dev/null +++ b/db/migrations/037_cmi_site.sql @@ -0,0 +1,5 @@ +-- Copyright 2026 Beacon Contributors +-- SPDX-License-Identifier: AGPL-3.0-or-later + +-- All-channel pages filtered by site walk one site range each. +CREATE INDEX CONCURRENTLY idx_cmi_site ON channel_message_iatas USING btree (iata, message_id DESC); diff --git a/db/migrations/038_cmi_channel_site_scope.sql b/db/migrations/038_cmi_channel_site_scope.sql new file mode 100644 index 0000000..736a91f --- /dev/null +++ b/db/migrations/038_cmi_channel_site_scope.sql @@ -0,0 +1,5 @@ +-- Copyright 2026 Beacon Contributors +-- SPDX-License-Identifier: AGPL-3.0-or-later + +-- Channel pages filtered by site and scope. +CREATE INDEX CONCURRENTLY idx_cmi_channel_site_scope ON channel_message_iatas USING btree (channel_id, iata, scope_id, message_id DESC) WHERE (scope_id IS NOT NULL); diff --git a/db/migrations/039_cmi_channel_scope.sql b/db/migrations/039_cmi_channel_scope.sql new file mode 100644 index 0000000..1bd223c --- /dev/null +++ b/db/migrations/039_cmi_channel_scope.sql @@ -0,0 +1,5 @@ +-- Copyright 2026 Beacon Contributors +-- SPDX-License-Identifier: AGPL-3.0-or-later + +-- Channel pages filtered by scope alone: rare and absent scopes read a few entries instead of the channel. +CREATE INDEX CONCURRENTLY idx_cmi_channel_scope ON channel_message_iatas USING btree (channel_id, scope_id, message_id DESC) WHERE (scope_id IS NOT NULL); diff --git a/db/migrations/040_cmi_scope.sql b/db/migrations/040_cmi_scope.sql new file mode 100644 index 0000000..c1c9174 --- /dev/null +++ b/db/migrations/040_cmi_scope.sql @@ -0,0 +1,5 @@ +-- Copyright 2026 Beacon Contributors +-- SPDX-License-Identifier: AGPL-3.0-or-later + +-- All-channel pages filtered by scope alone. +CREATE INDEX CONCURRENTLY idx_cmi_scope ON channel_message_iatas USING btree (scope_id, message_id DESC) WHERE (scope_id IS NOT NULL); diff --git a/db/migrations/041_channel_messages_channel_id.sql b/db/migrations/041_channel_messages_channel_id.sql new file mode 100644 index 0000000..f3829ab --- /dev/null +++ b/db/migrations/041_channel_messages_channel_id.sql @@ -0,0 +1,5 @@ +-- Copyright 2026 Beacon Contributors +-- SPDX-License-Identifier: AGPL-3.0-or-later + +-- Unfiltered channel pages walk the channel by id, the cursor's own column. +CREATE INDEX CONCURRENTLY idx_channel_messages_channel_id ON channel_messages USING btree (channel_id, id DESC); diff --git a/db/planguard/baseline/fixture/cmi.all.bogus5000.auto.json b/db/planguard/baseline/fixture/cmi.all.bogus5000.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.bogus5000.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.bogus5000.custom.json b/db/planguard/baseline/fixture/cmi.all.bogus5000.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.bogus5000.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.bogus5000.generic.json b/db/planguard/baseline/fixture/cmi.all.bogus5000.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.bogus5000.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.codes.auto.json b/db/planguard/baseline/fixture/cmi.all.codes.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.codes.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.codes.custom.json b/db/planguard/baseline/fixture/cmi.all.codes.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.codes.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.codes.generic.json b/db/planguard/baseline/fixture/cmi.all.codes.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.codes.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.empty.auto.json b/db/planguard/baseline/fixture/cmi.all.empty.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.empty.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.empty.custom.json b/db/planguard/baseline/fixture/cmi.all.empty.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.empty.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.empty.generic.json b/db/planguard/baseline/fixture/cmi.all.empty.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.empty.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.list22.auto.json b/db/planguard/baseline/fixture/cmi.all.list22.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.list22.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.list22.custom.json b/db/planguard/baseline/fixture/cmi.all.list22.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.list22.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.list22.deep.auto.json b/db/planguard/baseline/fixture/cmi.all.list22.deep.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.list22.deep.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.list22.deep.custom.json b/db/planguard/baseline/fixture/cmi.all.list22.deep.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.list22.deep.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.list22.deep.generic.json b/db/planguard/baseline/fixture/cmi.all.list22.deep.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.list22.deep.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.list22.generic.json b/db/planguard/baseline/fixture/cmi.all.list22.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.list22.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.new.auto.json b/db/planguard/baseline/fixture/cmi.all.new.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.new.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.new.custom.json b/db/planguard/baseline/fixture/cmi.all.new.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.new.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.new.generic.json b/db/planguard/baseline/fixture/cmi.all.new.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.new.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.at50.auto.json b/db/planguard/baseline/fixture/cmi.all.site.at50.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.at50.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.at50.custom.json b/db/planguard/baseline/fixture/cmi.all.site.at50.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.at50.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.at50.generic.json b/db/planguard/baseline/fixture/cmi.all.site.at50.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.at50.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.cursor_3e9.auto.json b/db/planguard/baseline/fixture/cmi.all.site.cursor_3e9.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.cursor_3e9.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.cursor_3e9.custom.json b/db/planguard/baseline/fixture/cmi.all.site.cursor_3e9.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.cursor_3e9.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.cursor_3e9.generic.json b/db/planguard/baseline/fixture/cmi.all.site.cursor_3e9.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.cursor_3e9.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.deep.auto.json b/db/planguard/baseline/fixture/cmi.all.site.deep.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.deep.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.deep.custom.json b/db/planguard/baseline/fixture/cmi.all.site.deep.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.deep.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.deep.generic.json b/db/planguard/baseline/fixture/cmi.all.site.deep.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.deep.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.limit201.auto.json b/db/planguard/baseline/fixture/cmi.all.site.limit201.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.limit201.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.limit201.custom.json b/db/planguard/baseline/fixture/cmi.all.site.limit201.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.limit201.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.limit201.generic.json b/db/planguard/baseline/fixture/cmi.all.site.limit201.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.limit201.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.page1.auto.json b/db/planguard/baseline/fixture/cmi.all.site.page1.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.page1.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.page1.custom.json b/db/planguard/baseline/fixture/cmi.all.site.page1.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.page1.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.site.page1.generic.json b/db/planguard/baseline/fixture/cmi.all.site.page1.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.site.page1.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.sparse.auto.json b/db/planguard/baseline/fixture/cmi.all.sparse.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.sparse.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.sparse.custom.json b/db/planguard/baseline/fixture/cmi.all.sparse.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.sparse.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.all.sparse.generic.json b/db/planguard/baseline/fixture/cmi.all.sparse.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.all.sparse.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplain.at50.auto.json b/db/planguard/baseline/fixture/cmi.allplain.at50.auto.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplain.at50.auto.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplain.at50.custom.json b/db/planguard/baseline/fixture/cmi.allplain.at50.custom.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplain.at50.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplain.at50.generic.json b/db/planguard/baseline/fixture/cmi.allplain.at50.generic.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplain.at50.generic.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplain.cursor_3e9.auto.json b/db/planguard/baseline/fixture/cmi.allplain.cursor_3e9.auto.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplain.cursor_3e9.auto.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplain.cursor_3e9.custom.json b/db/planguard/baseline/fixture/cmi.allplain.cursor_3e9.custom.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplain.cursor_3e9.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplain.cursor_3e9.generic.json b/db/planguard/baseline/fixture/cmi.allplain.cursor_3e9.generic.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplain.cursor_3e9.generic.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplain.deep.auto.json b/db/planguard/baseline/fixture/cmi.allplain.deep.auto.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplain.deep.auto.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplain.deep.custom.json b/db/planguard/baseline/fixture/cmi.allplain.deep.custom.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplain.deep.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplain.deep.generic.json b/db/planguard/baseline/fixture/cmi.allplain.deep.generic.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplain.deep.generic.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplain.page1.auto.json b/db/planguard/baseline/fixture/cmi.allplain.page1.auto.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplain.page1.auto.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplain.page1.custom.json b/db/planguard/baseline/fixture/cmi.allplain.page1.custom.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplain.page1.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplain.page1.generic.json b/db/planguard/baseline/fixture/cmi.allplain.page1.generic.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplain.page1.generic.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplainscope.absent.custom.json b/db/planguard/baseline/fixture/cmi.allplainscope.absent.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplainscope.absent.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplainscope.at50.custom.json b/db/planguard/baseline/fixture/cmi.allplainscope.at50.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplainscope.at50.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplainscope.cursor_3e9.custom.json b/db/planguard/baseline/fixture/cmi.allplainscope.cursor_3e9.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplainscope.cursor_3e9.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplainscope.deep.custom.json b/db/planguard/baseline/fixture/cmi.allplainscope.deep.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplainscope.deep.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplainscope.limit20.custom.json b/db/planguard/baseline/fixture/cmi.allplainscope.limit20.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplainscope.limit20.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplainscope.limit201.custom.json b/db/planguard/baseline/fixture/cmi.allplainscope.limit201.custom.json new file mode 100644 index 0000000..58f2da3 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplainscope.limit201.custom.json @@ -0,0 +1,18 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Hash Join (Left)", + " Nested Loop", + " Merge Join", + " Index Scan on channels c using channels_pkey scan=Forward", + " Sort", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Hash", + " Seq Scan on transport_scopes ts" +] diff --git a/db/planguard/baseline/fixture/cmi.allplainscope.page1.custom.json b/db/planguard/baseline/fixture/cmi.allplainscope.page1.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplainscope.page1.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allplainscope.rare.custom.json b/db/planguard/baseline/fixture/cmi.allplainscope.rare.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allplainscope.rare.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allsince.cursor.custom.json b/db/planguard/baseline/fixture/cmi.allsince.cursor.custom.json new file mode 100644 index 0000000..c012429 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allsince.cursor.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allsince.cursor_3e9.custom.json b/db/planguard/baseline/fixture/cmi.allsince.cursor_3e9.custom.json new file mode 100644 index 0000000..c012429 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allsince.cursor_3e9.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allsince.future.custom.json b/db/planguard/baseline/fixture/cmi.allsince.future.custom.json new file mode 100644 index 0000000..4a0bdbb --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allsince.future.custom.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Sort", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allsince.page1.custom.json b/db/planguard/baseline/fixture/cmi.allsince.page1.custom.json new file mode 100644 index 0000000..c012429 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allsince.page1.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.allsince.scoped.custom.json b/db/planguard/baseline/fixture/cmi.allsince.scoped.custom.json new file mode 100644 index 0000000..b585280 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.allsince.scoped.custom.json @@ -0,0 +1,16 @@ +[ + "Limit", + " Sort", + " Nested Loop (Semi)", + " Nested Loop (Left)", + " Nested Loop", + " Hash Join", + " Bitmap Heap Scan on packets p", + " Bitmap Index Scan using idx_packets_scope", + " Hash", + " Seq Scan on channel_messages cm", + " Index Scan on channels c using channels_pkey scan=Forward", + " Materialize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.bogus5000.auto.json b/db/planguard/baseline/fixture/cmi.ch.bogus5000.auto.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.bogus5000.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.bogus5000.custom.json b/db/planguard/baseline/fixture/cmi.ch.bogus5000.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.bogus5000.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.bogus5000.generic.json b/db/planguard/baseline/fixture/cmi.ch.bogus5000.generic.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.bogus5000.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.codes.auto.json b/db/planguard/baseline/fixture/cmi.ch.codes.auto.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.codes.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.codes.custom.json b/db/planguard/baseline/fixture/cmi.ch.codes.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.codes.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.codes.generic.json b/db/planguard/baseline/fixture/cmi.ch.codes.generic.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.codes.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.empty.auto.json b/db/planguard/baseline/fixture/cmi.ch.empty.auto.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.empty.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.empty.custom.json b/db/planguard/baseline/fixture/cmi.ch.empty.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.empty.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.empty.generic.json b/db/planguard/baseline/fixture/cmi.ch.empty.generic.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.empty.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.list22.auto.json b/db/planguard/baseline/fixture/cmi.ch.list22.auto.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.list22.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.list22.custom.json b/db/planguard/baseline/fixture/cmi.ch.list22.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.list22.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.list22.deep.auto.json b/db/planguard/baseline/fixture/cmi.ch.list22.deep.auto.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.list22.deep.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.list22.deep.custom.json b/db/planguard/baseline/fixture/cmi.ch.list22.deep.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.list22.deep.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.list22.deep.generic.json b/db/planguard/baseline/fixture/cmi.ch.list22.deep.generic.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.list22.deep.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.list22.generic.json b/db/planguard/baseline/fixture/cmi.ch.list22.generic.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.list22.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.new.auto.json b/db/planguard/baseline/fixture/cmi.ch.new.auto.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.new.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.new.custom.json b/db/planguard/baseline/fixture/cmi.ch.new.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.new.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.new.generic.json b/db/planguard/baseline/fixture/cmi.ch.new.generic.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.new.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.at50.auto.json b/db/planguard/baseline/fixture/cmi.ch.site.at50.auto.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.at50.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.at50.custom.json b/db/planguard/baseline/fixture/cmi.ch.site.at50.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.at50.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.at50.generic.json b/db/planguard/baseline/fixture/cmi.ch.site.at50.generic.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.at50.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.cursor_3e9.auto.json b/db/planguard/baseline/fixture/cmi.ch.site.cursor_3e9.auto.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.cursor_3e9.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.cursor_3e9.custom.json b/db/planguard/baseline/fixture/cmi.ch.site.cursor_3e9.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.cursor_3e9.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.cursor_3e9.generic.json b/db/planguard/baseline/fixture/cmi.ch.site.cursor_3e9.generic.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.cursor_3e9.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.deep.auto.json b/db/planguard/baseline/fixture/cmi.ch.site.deep.auto.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.deep.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.deep.custom.json b/db/planguard/baseline/fixture/cmi.ch.site.deep.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.deep.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.deep.generic.json b/db/planguard/baseline/fixture/cmi.ch.site.deep.generic.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.deep.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.limit201.auto.json b/db/planguard/baseline/fixture/cmi.ch.site.limit201.auto.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.limit201.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.limit201.custom.json b/db/planguard/baseline/fixture/cmi.ch.site.limit201.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.limit201.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.limit201.generic.json b/db/planguard/baseline/fixture/cmi.ch.site.limit201.generic.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.limit201.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.page1.auto.json b/db/planguard/baseline/fixture/cmi.ch.site.page1.auto.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.page1.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.page1.custom.json b/db/planguard/baseline/fixture/cmi.ch.site.page1.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.page1.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.site.page1.generic.json b/db/planguard/baseline/fixture/cmi.ch.site.page1.generic.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.site.page1.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.sparse.auto.json b/db/planguard/baseline/fixture/cmi.ch.sparse.auto.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.sparse.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.sparse.custom.json b/db/planguard/baseline/fixture/cmi.ch.sparse.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.sparse.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ch.sparse.generic.json b/db/planguard/baseline/fixture/cmi.ch.sparse.generic.json new file mode 100644 index 0000000..0a807e2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ch.sparse.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.chscope.list22.custom.json b/db/planguard/baseline/fixture/cmi.chscope.list22.custom.json new file mode 100644 index 0000000..5863373 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.chscope.list22.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.chscope.zerohit.custom.json b/db/planguard/baseline/fixture/cmi.chscope.zerohit.custom.json new file mode 100644 index 0000000..9aede88 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.chscope.zerohit.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.ingest.add.auto.json b/db/planguard/baseline/fixture/cmi.ingest.add.auto.json new file mode 100644 index 0000000..e3b3446 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ingest.add.auto.json @@ -0,0 +1,9 @@ +[ + "Result", + " Nested Loop [InitPlan]", + " Index Scan on channel_messages cm using channel_messages_packet_hash_key scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " ModifyTable on channel_message_iatas [InitPlan]", + " CTE Scan", + " CTE Scan [InitPlan]" +] diff --git a/db/planguard/baseline/fixture/cmi.ingest.insert.auto.json b/db/planguard/baseline/fixture/cmi.ingest.insert.auto.json new file mode 100644 index 0000000..acb40c8 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.ingest.insert.auto.json @@ -0,0 +1,24 @@ +[ + "Nested Loop (Left)", + " ModifyTable on channel_messages [InitPlan]", + " Result", + " ModifyTable on channels c [InitPlan]", + " Nested Loop", + " CTE Scan", + " Index Scan on channels c using channels_pkey scan=Forward", + " ModifyTable on analytics_dirty_hours [InitPlan]", + " Subquery Scan", + " Aggregate partial=Simple [Subquery] {Hashed}", + " Result", + " ModifyTable on channel_message_iatas [InitPlan]", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on packets p_1 using packets_pkey scan=Forward", + " Index Scan on packet_observations po using idx_observations_packet scan=Forward", + " Nested Loop", + " CTE Scan", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.at50.auto.json b/db/planguard/baseline/fixture/cmi.plain.at50.auto.json new file mode 100644 index 0000000..1b10b76 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.at50.auto.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.at50.custom.json b/db/planguard/baseline/fixture/cmi.plain.at50.custom.json new file mode 100644 index 0000000..29c1ab3 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.at50.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.at50.generic.json b/db/planguard/baseline/fixture/cmi.plain.at50.generic.json new file mode 100644 index 0000000..1b10b76 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.at50.generic.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.cursor_3e9.auto.json b/db/planguard/baseline/fixture/cmi.plain.cursor_3e9.auto.json new file mode 100644 index 0000000..1b10b76 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.cursor_3e9.auto.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.cursor_3e9.custom.json b/db/planguard/baseline/fixture/cmi.plain.cursor_3e9.custom.json new file mode 100644 index 0000000..29c1ab3 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.cursor_3e9.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.cursor_3e9.generic.json b/db/planguard/baseline/fixture/cmi.plain.cursor_3e9.generic.json new file mode 100644 index 0000000..1b10b76 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.cursor_3e9.generic.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.deep.auto.json b/db/planguard/baseline/fixture/cmi.plain.deep.auto.json new file mode 100644 index 0000000..1b10b76 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.deep.auto.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.deep.custom.json b/db/planguard/baseline/fixture/cmi.plain.deep.custom.json new file mode 100644 index 0000000..29c1ab3 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.deep.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.deep.generic.json b/db/planguard/baseline/fixture/cmi.plain.deep.generic.json new file mode 100644 index 0000000..1b10b76 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.deep.generic.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.limit201.auto.json b/db/planguard/baseline/fixture/cmi.plain.limit201.auto.json new file mode 100644 index 0000000..1b10b76 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.limit201.auto.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.limit201.custom.json b/db/planguard/baseline/fixture/cmi.plain.limit201.custom.json new file mode 100644 index 0000000..29c1ab3 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.limit201.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.limit201.generic.json b/db/planguard/baseline/fixture/cmi.plain.limit201.generic.json new file mode 100644 index 0000000..1b10b76 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.limit201.generic.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.page1.auto.json b/db/planguard/baseline/fixture/cmi.plain.page1.auto.json new file mode 100644 index 0000000..1b10b76 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.page1.auto.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.page1.custom.json b/db/planguard/baseline/fixture/cmi.plain.page1.custom.json new file mode 100644 index 0000000..29c1ab3 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.page1.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plain.page1.generic.json b/db/planguard/baseline/fixture/cmi.plain.page1.generic.json new file mode 100644 index 0000000..1b10b76 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plain.page1.generic.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plainscope.absent.custom.json b/db/planguard/baseline/fixture/cmi.plainscope.absent.custom.json new file mode 100644 index 0000000..9f648f4 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plainscope.absent.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plainscope.busy.custom.json b/db/planguard/baseline/fixture/cmi.plainscope.busy.custom.json new file mode 100644 index 0000000..6735a2d --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plainscope.busy.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plainscope.cursor_3e9.custom.json b/db/planguard/baseline/fixture/cmi.plainscope.cursor_3e9.custom.json new file mode 100644 index 0000000..6735a2d --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plainscope.cursor_3e9.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plainscope.deep.custom.json b/db/planguard/baseline/fixture/cmi.plainscope.deep.custom.json new file mode 100644 index 0000000..6735a2d --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plainscope.deep.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plainscope.limit201.custom.json b/db/planguard/baseline/fixture/cmi.plainscope.limit201.custom.json new file mode 100644 index 0000000..ffb259d --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plainscope.limit201.custom.json @@ -0,0 +1,17 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Merge Join", + " Index Scan on channels c using channels_pkey scan=Forward", + " Sort", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.plainscope.rare.custom.json b/db/planguard/baseline/fixture/cmi.plainscope.rare.custom.json new file mode 100644 index 0000000..6735a2d --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.plainscope.rare.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.sincewalk.future.custom.json b/db/planguard/baseline/fixture/cmi.sincewalk.future.custom.json new file mode 100644 index 0000000..37ceef2 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.sincewalk.future.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Sort", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel scan=Forward", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward [SubPlan]", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.sincewalk.plain10h.custom.json b/db/planguard/baseline/fixture/cmi.sincewalk.plain10h.custom.json new file mode 100644 index 0000000..1b10b76 --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.sincewalk.plain10h.custom.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/fixture/cmi.sincewalk.site3d.custom.json b/db/planguard/baseline/fixture/cmi.sincewalk.site3d.custom.json new file mode 100644 index 0000000..f15956a --- /dev/null +++ b/db/planguard/baseline/fixture/cmi.sincewalk.site3d.custom.json @@ -0,0 +1,15 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward [SubPlan]", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.bogus5000.auto.json b/db/planguard/baseline/local/cmi.all.bogus5000.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.bogus5000.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.bogus5000.custom.json b/db/planguard/baseline/local/cmi.all.bogus5000.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.bogus5000.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.bogus5000.generic.json b/db/planguard/baseline/local/cmi.all.bogus5000.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.bogus5000.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.codes.auto.json b/db/planguard/baseline/local/cmi.all.codes.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.codes.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.codes.custom.json b/db/planguard/baseline/local/cmi.all.codes.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.codes.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.codes.generic.json b/db/planguard/baseline/local/cmi.all.codes.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.codes.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.empty.auto.json b/db/planguard/baseline/local/cmi.all.empty.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.empty.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.empty.custom.json b/db/planguard/baseline/local/cmi.all.empty.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.empty.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.empty.generic.json b/db/planguard/baseline/local/cmi.all.empty.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.empty.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.list22.auto.json b/db/planguard/baseline/local/cmi.all.list22.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.list22.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.list22.custom.json b/db/planguard/baseline/local/cmi.all.list22.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.list22.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.list22.deep.auto.json b/db/planguard/baseline/local/cmi.all.list22.deep.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.list22.deep.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.list22.deep.custom.json b/db/planguard/baseline/local/cmi.all.list22.deep.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.list22.deep.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.list22.deep.generic.json b/db/planguard/baseline/local/cmi.all.list22.deep.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.list22.deep.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.list22.generic.json b/db/planguard/baseline/local/cmi.all.list22.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.list22.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.at50.auto.json b/db/planguard/baseline/local/cmi.all.site.at50.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.at50.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.at50.custom.json b/db/planguard/baseline/local/cmi.all.site.at50.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.at50.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.at50.generic.json b/db/planguard/baseline/local/cmi.all.site.at50.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.at50.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.cursor_3e9.auto.json b/db/planguard/baseline/local/cmi.all.site.cursor_3e9.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.cursor_3e9.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.cursor_3e9.custom.json b/db/planguard/baseline/local/cmi.all.site.cursor_3e9.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.cursor_3e9.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.cursor_3e9.generic.json b/db/planguard/baseline/local/cmi.all.site.cursor_3e9.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.cursor_3e9.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.deep.auto.json b/db/planguard/baseline/local/cmi.all.site.deep.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.deep.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.deep.custom.json b/db/planguard/baseline/local/cmi.all.site.deep.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.deep.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.deep.generic.json b/db/planguard/baseline/local/cmi.all.site.deep.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.deep.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.limit201.auto.json b/db/planguard/baseline/local/cmi.all.site.limit201.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.limit201.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.limit201.custom.json b/db/planguard/baseline/local/cmi.all.site.limit201.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.limit201.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.limit201.generic.json b/db/planguard/baseline/local/cmi.all.site.limit201.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.limit201.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.page1.auto.json b/db/planguard/baseline/local/cmi.all.site.page1.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.page1.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.page1.custom.json b/db/planguard/baseline/local/cmi.all.site.page1.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.page1.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.site.page1.generic.json b/db/planguard/baseline/local/cmi.all.site.page1.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.site.page1.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.sparse.auto.json b/db/planguard/baseline/local/cmi.all.sparse.auto.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.sparse.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.sparse.custom.json b/db/planguard/baseline/local/cmi.all.sparse.custom.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.sparse.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.all.sparse.generic.json b/db/planguard/baseline/local/cmi.all.sparse.generic.json new file mode 100644 index 0000000..181cf43 --- /dev/null +++ b/db/planguard/baseline/local/cmi.all.sparse.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplain.at50.auto.json b/db/planguard/baseline/local/cmi.allplain.at50.auto.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplain.at50.auto.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplain.at50.custom.json b/db/planguard/baseline/local/cmi.allplain.at50.custom.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplain.at50.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplain.at50.generic.json b/db/planguard/baseline/local/cmi.allplain.at50.generic.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplain.at50.generic.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplain.cursor_3e9.auto.json b/db/planguard/baseline/local/cmi.allplain.cursor_3e9.auto.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplain.cursor_3e9.auto.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplain.cursor_3e9.custom.json b/db/planguard/baseline/local/cmi.allplain.cursor_3e9.custom.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplain.cursor_3e9.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplain.cursor_3e9.generic.json b/db/planguard/baseline/local/cmi.allplain.cursor_3e9.generic.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplain.cursor_3e9.generic.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplain.deep.auto.json b/db/planguard/baseline/local/cmi.allplain.deep.auto.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplain.deep.auto.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplain.deep.custom.json b/db/planguard/baseline/local/cmi.allplain.deep.custom.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplain.deep.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplain.deep.generic.json b/db/planguard/baseline/local/cmi.allplain.deep.generic.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplain.deep.generic.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplain.page1.auto.json b/db/planguard/baseline/local/cmi.allplain.page1.auto.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplain.page1.auto.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplain.page1.custom.json b/db/planguard/baseline/local/cmi.allplain.page1.custom.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplain.page1.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplain.page1.generic.json b/db/planguard/baseline/local/cmi.allplain.page1.generic.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplain.page1.generic.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplainscope.absent.custom.json b/db/planguard/baseline/local/cmi.allplainscope.absent.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplainscope.absent.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplainscope.at50.custom.json b/db/planguard/baseline/local/cmi.allplainscope.at50.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplainscope.at50.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplainscope.cursor_3e9.custom.json b/db/planguard/baseline/local/cmi.allplainscope.cursor_3e9.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplainscope.cursor_3e9.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplainscope.deep.custom.json b/db/planguard/baseline/local/cmi.allplainscope.deep.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplainscope.deep.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplainscope.limit20.custom.json b/db/planguard/baseline/local/cmi.allplainscope.limit20.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplainscope.limit20.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplainscope.limit201.custom.json b/db/planguard/baseline/local/cmi.allplainscope.limit201.custom.json new file mode 100644 index 0000000..8791fc5 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplainscope.limit201.custom.json @@ -0,0 +1,18 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Hash Join (Left)", + " Nested Loop", + " Hash Join", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Hash", + " Seq Scan on channels c", + " Index Scan on packets p using packets_pkey scan=Forward", + " Hash", + " Seq Scan on transport_scopes ts" +] diff --git a/db/planguard/baseline/local/cmi.allplainscope.page1.custom.json b/db/planguard/baseline/local/cmi.allplainscope.page1.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplainscope.page1.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allplainscope.rare.custom.json b/db/planguard/baseline/local/cmi.allplainscope.rare.custom.json new file mode 100644 index 0000000..3354421 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allplainscope.rare.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allsince.cursor.custom.json b/db/planguard/baseline/local/cmi.allsince.cursor.custom.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allsince.cursor.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allsince.cursor_3e9.custom.json b/db/planguard/baseline/local/cmi.allsince.cursor_3e9.custom.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allsince.cursor_3e9.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allsince.future.custom.json b/db/planguard/baseline/local/cmi.allsince.future.custom.json new file mode 100644 index 0000000..cacf22e --- /dev/null +++ b/db/planguard/baseline/local/cmi.allsince.future.custom.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Sort", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Seq Scan on channels c", + " Index Scan on channel_messages cm using idx_channel_messages_channel scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allsince.page1.custom.json b/db/planguard/baseline/local/cmi.allsince.page1.custom.json new file mode 100644 index 0000000..5779d95 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allsince.page1.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Backward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Memoize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.allsince.scoped.custom.json b/db/planguard/baseline/local/cmi.allsince.scoped.custom.json new file mode 100644 index 0000000..959c279 --- /dev/null +++ b/db/planguard/baseline/local/cmi.allsince.scoped.custom.json @@ -0,0 +1,17 @@ +[ + "Limit", + " Sort", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Hash Join", + " Bitmap Heap Scan on packets p", + " Bitmap Index Scan using idx_packets_scope", + " Hash", + " Bitmap Heap Scan on channel_messages cm", + " Bitmap Index Scan using idx_channel_messages_sent_brin", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Materialize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.bogus5000.auto.json b/db/planguard/baseline/local/cmi.ch.bogus5000.auto.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.bogus5000.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.bogus5000.custom.json b/db/planguard/baseline/local/cmi.ch.bogus5000.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.bogus5000.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.bogus5000.generic.json b/db/planguard/baseline/local/cmi.ch.bogus5000.generic.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.bogus5000.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.codes.auto.json b/db/planguard/baseline/local/cmi.ch.codes.auto.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.codes.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.codes.custom.json b/db/planguard/baseline/local/cmi.ch.codes.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.codes.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.codes.generic.json b/db/planguard/baseline/local/cmi.ch.codes.generic.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.codes.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.empty.auto.json b/db/planguard/baseline/local/cmi.ch.empty.auto.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.empty.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.empty.custom.json b/db/planguard/baseline/local/cmi.ch.empty.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.empty.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.empty.generic.json b/db/planguard/baseline/local/cmi.ch.empty.generic.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.empty.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.list22.auto.json b/db/planguard/baseline/local/cmi.ch.list22.auto.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.list22.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.list22.custom.json b/db/planguard/baseline/local/cmi.ch.list22.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.list22.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.list22.deep.auto.json b/db/planguard/baseline/local/cmi.ch.list22.deep.auto.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.list22.deep.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.list22.deep.custom.json b/db/planguard/baseline/local/cmi.ch.list22.deep.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.list22.deep.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.list22.deep.generic.json b/db/planguard/baseline/local/cmi.ch.list22.deep.generic.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.list22.deep.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.list22.generic.json b/db/planguard/baseline/local/cmi.ch.list22.generic.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.list22.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.at50.auto.json b/db/planguard/baseline/local/cmi.ch.site.at50.auto.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.at50.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.at50.custom.json b/db/planguard/baseline/local/cmi.ch.site.at50.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.at50.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.at50.generic.json b/db/planguard/baseline/local/cmi.ch.site.at50.generic.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.at50.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.cursor_3e9.auto.json b/db/planguard/baseline/local/cmi.ch.site.cursor_3e9.auto.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.cursor_3e9.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.cursor_3e9.custom.json b/db/planguard/baseline/local/cmi.ch.site.cursor_3e9.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.cursor_3e9.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.cursor_3e9.generic.json b/db/planguard/baseline/local/cmi.ch.site.cursor_3e9.generic.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.cursor_3e9.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.deep.auto.json b/db/planguard/baseline/local/cmi.ch.site.deep.auto.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.deep.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.deep.custom.json b/db/planguard/baseline/local/cmi.ch.site.deep.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.deep.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.deep.generic.json b/db/planguard/baseline/local/cmi.ch.site.deep.generic.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.deep.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.limit201.auto.json b/db/planguard/baseline/local/cmi.ch.site.limit201.auto.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.limit201.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.limit201.custom.json b/db/planguard/baseline/local/cmi.ch.site.limit201.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.limit201.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.limit201.generic.json b/db/planguard/baseline/local/cmi.ch.site.limit201.generic.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.limit201.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.page1.auto.json b/db/planguard/baseline/local/cmi.ch.site.page1.auto.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.page1.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.page1.custom.json b/db/planguard/baseline/local/cmi.ch.site.page1.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.page1.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.site.page1.generic.json b/db/planguard/baseline/local/cmi.ch.site.page1.generic.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.site.page1.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.sparse.auto.json b/db/planguard/baseline/local/cmi.ch.sparse.auto.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.sparse.auto.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.sparse.custom.json b/db/planguard/baseline/local/cmi.ch.sparse.custom.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.sparse.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ch.sparse.generic.json b/db/planguard/baseline/local/cmi.ch.sparse.generic.json new file mode 100644 index 0000000..8ec08ca --- /dev/null +++ b/db/planguard/baseline/local/cmi.ch.sparse.generic.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.chscope.list22.custom.json b/db/planguard/baseline/local/cmi.chscope.list22.custom.json new file mode 100644 index 0000000..e811552 --- /dev/null +++ b/db/planguard/baseline/local/cmi.chscope.list22.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Sort", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.chscope.zerohit.custom.json b/db/planguard/baseline/local/cmi.chscope.zerohit.custom.json new file mode 100644 index 0000000..5863373 --- /dev/null +++ b/db/planguard/baseline/local/cmi.chscope.zerohit.custom.json @@ -0,0 +1,19 @@ +[ + "Sort", + " Limit [InitPlan]", + " Group", + " Sort", + " Nested Loop", + " Function Scan", + " Limit", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_site_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.ingest.add.auto.json b/db/planguard/baseline/local/cmi.ingest.add.auto.json new file mode 100644 index 0000000..e3b3446 --- /dev/null +++ b/db/planguard/baseline/local/cmi.ingest.add.auto.json @@ -0,0 +1,9 @@ +[ + "Result", + " Nested Loop [InitPlan]", + " Index Scan on channel_messages cm using channel_messages_packet_hash_key scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " ModifyTable on channel_message_iatas [InitPlan]", + " CTE Scan", + " CTE Scan [InitPlan]" +] diff --git a/db/planguard/baseline/local/cmi.ingest.insert.auto.json b/db/planguard/baseline/local/cmi.ingest.insert.auto.json new file mode 100644 index 0000000..a4855c3 --- /dev/null +++ b/db/planguard/baseline/local/cmi.ingest.insert.auto.json @@ -0,0 +1,25 @@ +[ + "Nested Loop (Left)", + " ModifyTable on channel_messages [InitPlan]", + " Result", + " ModifyTable on channels c [InitPlan]", + " Nested Loop", + " CTE Scan", + " Index Scan on channels c using channels_pkey scan=Forward", + " ModifyTable on analytics_dirty_hours [InitPlan]", + " Subquery Scan", + " Aggregate partial=Simple [Subquery] {Hashed}", + " Result", + " ModifyTable on channel_message_iatas [InitPlan]", + " Unique", + " Sort", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on packets p_1 using packets_pkey scan=Forward", + " Index Scan on packet_observations po using idx_observations_packet scan=Forward", + " Nested Loop", + " CTE Scan", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.maint.fill_by_messages.custom.json b/db/planguard/baseline/local/cmi.maint.fill_by_messages.custom.json new file mode 100644 index 0000000..3f398ce --- /dev/null +++ b/db/planguard/baseline/local/cmi.maint.fill_by_messages.custom.json @@ -0,0 +1,9 @@ +[ + "ModifyTable on channel_message_iatas", + " Aggregate partial=Simple {Hashed}", + " Nested Loop", + " Nested Loop", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on packet_observations po using idx_observations_packet scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.maint.fill_by_observations.custom.json b/db/planguard/baseline/local/cmi.maint.fill_by_observations.custom.json new file mode 100644 index 0000000..0cb5b34 --- /dev/null +++ b/db/planguard/baseline/local/cmi.maint.fill_by_observations.custom.json @@ -0,0 +1,10 @@ +[ + "ModifyTable on channel_message_iatas", + " Unique", + " Sort", + " Nested Loop", + " Nested Loop", + " Index Scan on packet_observations po using packet_observations_pkey scan=Forward", + " Index Scan on channel_messages cm using channel_messages_packet_hash_key scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.at50.auto.json b/db/planguard/baseline/local/cmi.plain.at50.auto.json new file mode 100644 index 0000000..6331231 --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.at50.auto.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.at50.custom.json b/db/planguard/baseline/local/cmi.plain.at50.custom.json new file mode 100644 index 0000000..6ea90ff --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.at50.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.at50.generic.json b/db/planguard/baseline/local/cmi.plain.at50.generic.json new file mode 100644 index 0000000..6331231 --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.at50.generic.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.cursor_3e9.auto.json b/db/planguard/baseline/local/cmi.plain.cursor_3e9.auto.json new file mode 100644 index 0000000..6331231 --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.cursor_3e9.auto.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.cursor_3e9.custom.json b/db/planguard/baseline/local/cmi.plain.cursor_3e9.custom.json new file mode 100644 index 0000000..6ea90ff --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.cursor_3e9.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.cursor_3e9.generic.json b/db/planguard/baseline/local/cmi.plain.cursor_3e9.generic.json new file mode 100644 index 0000000..6331231 --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.cursor_3e9.generic.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.deep.auto.json b/db/planguard/baseline/local/cmi.plain.deep.auto.json new file mode 100644 index 0000000..6331231 --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.deep.auto.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.deep.custom.json b/db/planguard/baseline/local/cmi.plain.deep.custom.json new file mode 100644 index 0000000..6ea90ff --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.deep.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.deep.generic.json b/db/planguard/baseline/local/cmi.plain.deep.generic.json new file mode 100644 index 0000000..6331231 --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.deep.generic.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.limit201.auto.json b/db/planguard/baseline/local/cmi.plain.limit201.auto.json new file mode 100644 index 0000000..6331231 --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.limit201.auto.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.limit201.custom.json b/db/planguard/baseline/local/cmi.plain.limit201.custom.json new file mode 100644 index 0000000..6ea90ff --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.limit201.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.limit201.generic.json b/db/planguard/baseline/local/cmi.plain.limit201.generic.json new file mode 100644 index 0000000..6331231 --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.limit201.generic.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.page1.auto.json b/db/planguard/baseline/local/cmi.plain.page1.auto.json new file mode 100644 index 0000000..6331231 --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.page1.auto.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.page1.custom.json b/db/planguard/baseline/local/cmi.plain.page1.custom.json new file mode 100644 index 0000000..6ea90ff --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.page1.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plain.page1.generic.json b/db/planguard/baseline/local/cmi.plain.page1.generic.json new file mode 100644 index 0000000..6331231 --- /dev/null +++ b/db/planguard/baseline/local/cmi.plain.page1.generic.json @@ -0,0 +1,13 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plainscope.absent.custom.json b/db/planguard/baseline/local/cmi.plainscope.absent.custom.json new file mode 100644 index 0000000..6735a2d --- /dev/null +++ b/db/planguard/baseline/local/cmi.plainscope.absent.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plainscope.busy.custom.json b/db/planguard/baseline/local/cmi.plainscope.busy.custom.json new file mode 100644 index 0000000..6735a2d --- /dev/null +++ b/db/planguard/baseline/local/cmi.plainscope.busy.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plainscope.cursor_3e9.custom.json b/db/planguard/baseline/local/cmi.plainscope.cursor_3e9.custom.json new file mode 100644 index 0000000..6735a2d --- /dev/null +++ b/db/planguard/baseline/local/cmi.plainscope.cursor_3e9.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plainscope.deep.custom.json b/db/planguard/baseline/local/cmi.plainscope.deep.custom.json new file mode 100644 index 0000000..6735a2d --- /dev/null +++ b/db/planguard/baseline/local/cmi.plainscope.deep.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.plainscope.limit201.custom.json b/db/planguard/baseline/local/cmi.plainscope.limit201.custom.json new file mode 100644 index 0000000..c77a26e --- /dev/null +++ b/db/planguard/baseline/local/cmi.plainscope.limit201.custom.json @@ -0,0 +1,18 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_scope scan=Forward", + " Hash Join (Left)", + " Nested Loop", + " Hash Join", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Hash", + " Seq Scan on channels c", + " Index Scan on packets p using packets_pkey scan=Forward", + " Hash", + " Seq Scan on transport_scopes ts" +] diff --git a/db/planguard/baseline/local/cmi.plainscope.rare.custom.json b/db/planguard/baseline/local/cmi.plainscope.rare.custom.json new file mode 100644 index 0000000..6735a2d --- /dev/null +++ b/db/planguard/baseline/local/cmi.plainscope.rare.custom.json @@ -0,0 +1,16 @@ +[ + "Sort", + " Limit [InitPlan]", + " Result", + " Unique", + " Index Only Scan on channel_message_iatas i using idx_cmi_channel_scope scan=Forward", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop", + " CTE Scan", + " Index Scan on channel_messages cm using channel_messages_pkey scan=Forward", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.sincewalk.future.custom.json b/db/planguard/baseline/local/cmi.sincewalk.future.custom.json new file mode 100644 index 0000000..37ceef2 --- /dev/null +++ b/db/planguard/baseline/local/cmi.sincewalk.future.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Sort", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop (Semi)", + " Nested Loop", + " Index Scan on channel_messages cm using idx_channel_messages_channel scan=Forward", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward [SubPlan]", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.sincewalk.plain10h.custom.json b/db/planguard/baseline/local/cmi.sincewalk.plain10h.custom.json new file mode 100644 index 0000000..6ea90ff --- /dev/null +++ b/db/planguard/baseline/local/cmi.sincewalk.plain10h.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Memoize", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/baseline/local/cmi.sincewalk.site3d.custom.json b/db/planguard/baseline/local/cmi.sincewalk.site3d.custom.json new file mode 100644 index 0000000..c9e19b6 --- /dev/null +++ b/db/planguard/baseline/local/cmi.sincewalk.site3d.custom.json @@ -0,0 +1,14 @@ +[ + "Limit", + " Nested Loop (Left)", + " Nested Loop", + " Nested Loop", + " Nested Loop (Semi)", + " Index Scan on channel_messages cm using idx_channel_messages_channel_id scan=Forward", + " Index Only Scan on channel_message_iatas i using idx_cmi_site scan=Forward [SubPlan]", + " Index Only Scan on packet_observations po using idx_observations_packet scan=Forward", + " Index Scan on packets p using packets_pkey scan=Forward", + " Materialize", + " Index Scan on channels c using channels_pkey scan=Forward", + " Index Scan on transport_scopes ts using transport_scopes_pkey scan=Forward" +] diff --git a/db/planguard/corpus.yaml b/db/planguard/corpus.yaml index a1c42e6..197935d 100644 --- a/db/planguard/corpus.yaml +++ b/db/planguard/corpus.yaml @@ -52,10 +52,13 @@ tiers: groups: # These groups plan against an overlay schema on the local copy: packets_global against overlay/packets_global.sql # (packets with its new indexes; nodes and observers as migrated), stats_adverts against overlay/stats_adverts.sql - # (packet_observations with the partial adverts index), the pending groups against one a later change builds. + # (packet_observations with the partial adverts index), channel_message_iatas against + # overlay/channel_message_iatas.sql (channel_messages with its channel walk index and the read model; its local run + # passes --search-path, since its resolvers read the read model too), the pending group against one a later change + # builds. packets_global: {search_path: {local: "t_s5a, public"}} packet_sites: {search_path: {local: "t_s2b, public"}} - channel_message_iatas: {search_path: {local: "t_s2b, public"}} + channel_message_iatas: {search_path: {local: "t_s4a, public"}} stats_adverts: {search_path: {local: "t_s7a, public"}} statements: @@ -130,27 +133,28 @@ statements: FilterKnownSites: {file: sql/pending/FilterKnownSites.sql, group: packet_sites, plan: custom, pending: packet_sites} SweepPacketSitesFronts: {file: sql/pending/SweepPacketSitesFronts.sql, group: packet_sites, plan: maint, pending: packet_sites} InsertObservation_end: {file: sql/pending/InsertObservation.sql, kind: dml, group: packet_sites, plan: ingest, pending: packet_sites} - ListChannelMessagesByIATAs: {file: sql/pending/ListChannelMessagesByIATAs.sql, group: channel_message_iatas, plan: cached, admission: region_list, pending: channel_message_iatas} - ListChannelMessagesByIATAsScoped: {file: sql/pending/ListChannelMessagesByIATAsScoped.sql, group: channel_message_iatas, plan: cached, admission: region_list, pending: channel_message_iatas} - ListChannelMessagesPlain: {file: sql/pending/ListChannelMessagesPlain.sql, group: channel_message_iatas, plan: cached, admission: global_page, pending: channel_message_iatas} - ListAllChannelMessagesByIATAs: {file: sql/pending/ListAllChannelMessagesByIATAs.sql, group: channel_message_iatas, plan: cached, admission: region_list, pending: channel_message_iatas} - ListAllChannelMessagesPlain: {file: sql/pending/ListAllChannelMessagesPlain.sql, group: channel_message_iatas, plan: cached, admission: global_page, pending: channel_message_iatas} - ListChannelMessagesPlainScoped: {file: sql/pending/ListChannelMessagesPlainScoped.sql, group: channel_message_iatas, plan: custom, pending: channel_message_iatas} - ListAllChannelMessagesByIATAsScoped: {file: sql/pending/ListAllChannelMessagesByIATAsScoped.sql, group: channel_message_iatas, plan: custom, pending: channel_message_iatas} - ListAllChannelMessagesPlainScoped: {file: sql/pending/ListAllChannelMessagesPlainScoped.sql, group: channel_message_iatas, plan: custom, pending: channel_message_iatas} - ListAllChannelMessagesSince: {file: sql/pending/ListAllChannelMessagesSince.sql, group: channel_message_iatas, plan: custom, pending: channel_message_iatas} - ListAllChannelMessagesByIATAsSince: {file: sql/pending/ListAllChannelMessagesByIATAsSince.sql, group: channel_message_iatas, plan: custom, pending: channel_message_iatas} - ListChannelMessagesSinceWalk: {file: sql/pending/ListChannelMessagesSinceWalk.sql, group: channel_message_iatas, plan: custom, pending: channel_message_iatas} - AddChannelMessageIATA: {file: sql/pending/AddChannelMessageIATA.sql, kind: dml, group: channel_message_iatas, plan: ingest, pending: channel_message_iatas} - FillChannelMessageIATAsByMessages: {file: sql/pending/FillChannelMessageIATAsByMessages.sql, kind: dml, group: channel_message_iatas, plan: maint, pending: channel_message_iatas} + # Channel message pages, one statement per filter shape; the site and scope shapes read channel_message_iatas + # while the server trusts it. The scoped, since and scope-only shapes are planned with their values. Sites with a + # since or a scope across every channel run today's statement (no index bounds both). + ListChannelMessagesByIATAs: {sqlc: ListChannelMessagesByIATAs, group: channel_message_iatas, plan: cached, admission: region_list} + ListAllChannelMessagesByIATAs: {sqlc: ListAllChannelMessagesByIATAs, group: channel_message_iatas, plan: cached, admission: region_list} + ListChannelMessagesPlain: {sqlc: ListChannelMessagesPlain, group: channel_message_iatas, plan: cached, admission: global_page} + ListAllChannelMessagesPlain: {sqlc: ListAllChannelMessagesPlain, group: channel_message_iatas, plan: cached, admission: global_page} + ListChannelMessagesByIATAsScoped: {sqlc: ListChannelMessagesByIATAsScoped, group: channel_message_iatas, plan: custom} + ListChannelMessagesPlainScoped: {sqlc: ListChannelMessagesPlainScoped, group: channel_message_iatas, plan: custom} + ListChannelMessagesSinceWalk: {sqlc: ListChannelMessagesSinceWalk, group: channel_message_iatas, plan: custom} + ListAllChannelMessagesPlainScoped: {sqlc: ListAllChannelMessagesPlainScoped, group: channel_message_iatas, plan: custom} + ListAllChannelMessagesSince: {sqlc: ListAllChannelMessagesSince, group: channel_message_iatas, plan: custom} + AddChannelMessageIATA: {sqlc: AddChannelMessageIATA, kind: dml, group: channel_message_iatas, plan: ingest} + InsertChannelMessage: {sqlc: InsertChannelMessage, kind: dml, group: channel_message_iatas, plan: ingest} + FillChannelMessageIATAsByMessages: {sqlc: FillChannelMessageIATAsByMessages, kind: dml, group: channel_message_iatas, plan: maint} + FillChannelMessageIATAsByObservations: {sqlc: FillChannelMessageIATAsByObservations, kind: dml, group: channel_message_iatas, plan: maint} sort_exempt_sets: hop_group: - {relation: known_routes, index: idx_known_routes_hop_iata, index_cond: "hop_count =", reason: "a hop page sorts one (hop, region) group, bounded by the group size"} latest_observation: - {relation: packet_observations, index_cond: "packet_hash = p.packet_hash", reason: "the latest-observation LATERAL sorts one packet's observations (a few hundred at most)"} - per_site_message_ranges: - - {relation: packets, index: idx_packets_scope_last_heard, index_cond: "scope_id =", reason: "a scope's message page walks one scope's packets newest first and stops at the page"} route_search_top_n: - {relation: known_routes, index_cond: "node_ids &&", reason: "route search and cross sort their GIN matches for the top 500, as today"} - {relation: known_routes, index: idx_known_routes_iata_keyset, index_cond: "iata = ANY", reason: "the same top 500 when the region list is the narrower path"} @@ -189,8 +193,48 @@ resolvers: bwe_deep_id: "SELECT id FROM known_routes WHERE iata >= 'BWE' AND iata <= 'BWE' ORDER BY iata, date_trunc('milliseconds', last_seen, 'UTC') DESC, id DESC OFFSET 5000 LIMIT 1" bwe_deep_ts: "SELECT date_trunc('milliseconds', last_seen, 'UTC') FROM known_routes WHERE iata >= 'BWE' AND iata <= 'BWE' ORDER BY iata, date_trunc('milliseconds', last_seen, 'UTC') DESC, id DESC OFFSET 5000 LIMIT 1" cm_newest_hash: "SELECT packet_hash FROM channel_messages ORDER BY id DESC LIMIT 1" - cmi_all_sites: "SELECT array_agg(DISTINCT iata ORDER BY iata) FROM channel_message_iatas" - cmi_bogus5000: "SELECT array_agg(c ORDER BY c) FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT DISTINCT iata FROM channel_message_iatas) AND c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s" + # Channel message roles are picked among the newest 20,000 channel_message_iatas rows (a pkey range); cursors walk + # at most 5,000 index entries of one channel, site or scope. Zero-hit sites and scopes probe one index entry per + # code or scope. Since times count back from the newest message. + cm_50: "SELECT id FROM channel_messages ORDER BY id DESC OFFSET 49 LIMIT 1" + cm_ch_50: "SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY id DESC OFFSET 49 LIMIT 1" + cm_ch_deep: "SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s" + cm_deep: "SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 20000) s" + cm_fill_hi: "SELECT coalesce(max(id), 0) FROM channel_messages" + cm_fill_lo: "SELECT coalesce(max(id), 0) - 10000 FROM channel_messages" + cm_since10h: "SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1" + cm_since3d: "SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1" + cm_since_cursor: "SELECT min(id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 100) s" + cmi_bogus5000: "SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s" + cmi_ch: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)" + cmi_ch_empty: "SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1" + cmi_ch_list: "SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 22) s" + cmi_ch_site: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]" + cmi_ch_site_50: "SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC OFFSET 49 LIMIT 1" + cmi_ch_site_deep: "SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s" + cmi_ch_sparse: "SELECT ARRAY[iata]::bpchar[] FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) GROUP BY iata ORDER BY count(*), iata LIMIT 1" + cmi_codes: "SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes" + cmi_list: "SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 22) s" + cmi_list13: "SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 13) s" + cmi_new: "SELECT '{NEW}'::bpchar[]" + cmi_sc: "SELECT scope_id FROM (SELECT channel_id, scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1, 2 ORDER BY count(*) DESC, 1, 2 LIMIT 1) s" + cmi_sc_ch: "SELECT channel_id FROM (SELECT channel_id, scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1, 2 ORDER BY count(*) DESC, 1, 2 LIMIT 1) s" + cmi_sc_deep: "SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM (SELECT channel_id, scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1, 2 ORDER BY count(*) DESC, 1, 2 LIMIT 1) p) AND scope_id = (SELECT scope_id FROM (SELECT channel_id, scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1, 2 ORDER BY count(*) DESC, 1, 2 LIMIT 1) p) ORDER BY message_id DESC LIMIT 5000) s" + cmi_sc_list: "SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM (SELECT channel_id, scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1, 2 ORDER BY count(*) DESC, 1, 2 LIMIT 1) p) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 22) s" + cmi_sc_rare: "SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM (SELECT channel_id, scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1, 2 ORDER BY count(*) DESC, 1, 2 LIMIT 1) p) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1" + cmi_scope: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)" + cmi_scope_50: "SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC OFFSET 49 LIMIT 1" + cmi_scope_absent: "SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1" + cmi_scope_deep: "SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s" + cmi_scope_rare: "SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1" + cmi_site: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]" + cmi_site_50: "SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC OFFSET 49 LIMIT 1" + cmi_site_deep: "SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s" + cmi_site_empty: "SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.iata = ic.iata) ORDER BY ic.iata LIMIT 1" + cmi_site_s: "SELECT (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)" + cmi_site_sparse: "SELECT ARRAY[iata]::bpchar[] FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY iata ORDER BY count(*), iata LIMIT 1" + po_fill_hi: "SELECT coalesce(max(id), 0) FROM packet_observations" + po_fill_lo: "SELECT coalesce(max(id), 0) - 340000 FROM packet_observations" g50_id: "SELECT id FROM known_routes ORDER BY date_trunc('milliseconds', last_seen, 'UTC') DESC, id DESC OFFSET 49 LIMIT 1" g50_ts: "SELECT date_trunc('milliseconds', last_seen, 'UTC') FROM known_routes ORDER BY date_trunc('milliseconds', last_seen, 'UTC') DESC, id DESC OFFSET 49 LIMIT 1" global_tie_id: "SELECT max(id) FROM known_routes WHERE date_trunc('milliseconds', last_seen, 'UTC') = (SELECT ts FROM (SELECT date_trunc('milliseconds', last_seen, 'UTC') ts FROM known_routes ORDER BY date_trunc('milliseconds', last_seen, 'UTC') DESC, id DESC LIMIT 20000) s GROUP BY ts HAVING count(*) > 1 ORDER BY ts DESC LIMIT 1)" @@ -886,452 +930,570 @@ entries: driver: [{relation: known_routes, index: idx_known_routes_keyset, index_cond: ["ROW(date_trunc"]}] budget: {buffers: 10, planning_ms: 10} - # ---- channel messages through channel_message_iatas (pending) ---- note: "measured: 3 B on the full local copy (max over modes)" - - id: cmi2.P01 + + # ---- channel messages: site and scope pages through channel_message_iatas, walks by id ---- + - id: cmi.ch.site.page1 stmt: ListChannelMessagesByIATAs - shape: "ch27 YUL p1 lim50" - params: ["{YUL}", 27, 9223372036854775807, 51] + shape: "the busiest channel's busiest site, page 1" + shapes: [dense, page1] + params: [{r: cmi_ch_site}, {r: cmi_ch}, 9223372036854775807, 51] expect: driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 600, planning_ms: 10} - note: "measured: 574 / 574 B (custom / generic), idx ,idx_cmi_channel_site; measured budget <=600" - - id: cmi2.P02 + budget: {buffers: 1131, planning_ms: 10} + note: "measured: 754 / 754 / 754 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.ch.site.limit201 stmt: ListChannelMessagesByIATAs - shape: "ch27 YUL cursor page (2)" - params: ["{YUL}", 27, 17936665, 51] + shape: "the busiest channel's busiest site, page 1, limit 200" + shapes: [dense, page1] + params: [{r: cmi_ch_site}, {r: cmi_ch}, 9223372036854775807, 201] expect: driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 600, planning_ms: 10} - note: "measured: 565 / 565 B (custom / generic), idx ,idx_cmi_channel_site; measured budget <=600" - - id: cmi2.P03 + budget: {buffers: 4418, planning_ms: 10} + note: "measured: 2945 / 2945 / 2945 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.ch.site.deep stmt: ListChannelMessagesByIATAs - shape: "ch27 YUL deep cursor" - params: ["{YUL}", 27, 15018736, 51] + shape: "the busiest channel's busiest site, cursor amid its newest 5,000 messages" + shapes: [dense, deep] + params: [{r: cmi_ch_site}, {r: cmi_ch}, {r: cmi_ch_site_deep}, 51] expect: driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 600, planning_ms: 10} - note: "measured: 499 / 499 B (custom / generic), idx ,idx_cmi_channel_site; measured budget <=600" - - id: cmi2.P04 + budget: {buffers: 1127, planning_ms: 10} + note: "measured: 751 / 751 / 751 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.ch.site.at50 stmt: ListChannelMessagesByIATAs - shape: "zero-hit ch14 GDW" - params: ["{GDW}", 14, 9223372036854775807, 51] + shape: "the busiest channel's busiest site, cursor at page 1's 50th id" + shapes: [dense, tie] + params: [{r: cmi_ch_site}, {r: cmi_ch}, {r: cmi_ch_site_50}, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1136, planning_ms: 10} + note: "measured: 757 / 757 / 757 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.ch.site.cursor_3e9 + stmt: ListChannelMessagesByIATAs + shape: "the busiest channel's busiest site, cursor 3e9" + shapes: [dense, deep] + params: [{r: cmi_ch_site}, {r: cmi_ch}, 3000000000, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1131, planning_ms: 10} + note: "measured: 754 / 754 / 754 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.ch.sparse + stmt: ListChannelMessagesByIATAs + shape: "the busiest channel's quietest recent site, page 1" + shapes: [sparse, page1] + params: [{r: cmi_ch_sparse}, {r: cmi_ch}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 924, planning_ms: 10} + note: "measured: 616 / 616 / 616 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.ch.empty + stmt: ListChannelMessagesByIATAs + shape: "the busiest channel, a known site that never heard it" + shapes: [empty_region, page1] + params: [{r: cmi_ch_empty}, {r: cmi_ch}, 9223372036854775807, 51] expect: driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] budget: {buffers: 10, planning_ms: 10} - note: "measured: 3 / 3 B (custom / generic), idx ,idx_cmi_channel_site; measured budget <=10" - - id: cmi2.P05 + note: "measured: 3 / 3 / 3 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.ch.new stmt: ListChannelMessagesByIATAs - shape: "zero-hit ch27 BLK (valid code)" - params: ["{BLK}", 27, 9223372036854775807, 51] + shape: "the busiest channel, the site its statistics have not seen" + shapes: [stale_region, page1] + tiers: [fixture] + params: [{r: cmi_new}, {r: cmi_ch}, 9223372036854775807, 51] expect: driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] + - id: cmi.ch.list22 + stmt: ListChannelMessagesByIATAs + shape: "the busiest channel, its 22 busiest recent sites, page 1" + shapes: [dense, page1] + params: [{r: cmi_ch_list}, {r: cmi_ch}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 2717, planning_ms: 10} + note: "measured: 1811 / 1811 / 1811 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.ch.list22.deep + stmt: ListChannelMessagesByIATAs + shape: "the busiest channel, its 22 busiest recent sites, deep cursor" + shapes: [dense, deep] + params: [{r: cmi_ch_list}, {r: cmi_ch}, {r: cmi_ch_site_deep}, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 2748, planning_ms: 10} + note: "measured: 1832 / 1832 / 1832 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.ch.codes + stmt: ListChannelMessagesByIATAs + shape: "the busiest channel, every known site" + shapes: [giant_list, page1] + params: [{r: cmi_codes}, {r: cmi_ch}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 30891, planning_ms: 10} + note: "measured: 20594 / 20594 / 20594 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.ch.bogus5000 + stmt: ListChannelMessagesByIATAs + shape: "the busiest channel, 5,000 codes that are no site" + shapes: [giant_list, empty_region] + params: [{r: cmi_bogus5000}, {r: cmi_ch}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 22500, planning_ms: 10} + note: "measured: 15000 / 15000 / 15000 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.all.site.page1 + stmt: ListAllChannelMessagesByIATAs + shape: "/messages, the busiest site, page 1" + shapes: [dense, page1] + params: [{r: cmi_site}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1137, planning_ms: 10} + note: "measured: 758 / 758 / 758 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.all.site.limit201 + stmt: ListAllChannelMessagesByIATAs + shape: "/messages, the busiest site, page 1, limit 200" + shapes: [dense, page1] + params: [{r: cmi_site}, 9223372036854775807, 201] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 4467, planning_ms: 10} + note: "measured: 2978 / 2978 / 2978 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.all.site.deep + stmt: ListAllChannelMessagesByIATAs + shape: "/messages, the busiest site, cursor amid its newest 5,000 messages" + shapes: [dense, deep] + params: [{r: cmi_site}, {r: cmi_site_deep}, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1131, planning_ms: 10} + note: "measured: 754 / 754 / 754 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.all.site.at50 + stmt: ListAllChannelMessagesByIATAs + shape: "/messages, the busiest site, cursor at page 1's 50th id" + shapes: [dense, tie] + params: [{r: cmi_site}, {r: cmi_site_50}, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1136, planning_ms: 10} + note: "measured: 757 / 757 / 757 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.all.site.cursor_3e9 + stmt: ListAllChannelMessagesByIATAs + shape: "/messages, the busiest site, cursor 3e9" + shapes: [dense, deep] + params: [{r: cmi_site}, 3000000000, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1137, planning_ms: 10} + note: "measured: 758 / 758 / 758 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.all.sparse + stmt: ListAllChannelMessagesByIATAs + shape: "/messages, the quietest recent site" + shapes: [sparse, page1] + params: [{r: cmi_site_sparse}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 923, planning_ms: 10} + note: "measured: 615 / 615 / 615 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.all.empty + stmt: ListAllChannelMessagesByIATAs + shape: "/messages, a known site with no message" + shapes: [empty_region, page1] + params: [{r: cmi_site_empty}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] budget: {buffers: 10, planning_ms: 10} - note: "measured: 3 / 3 B (custom / generic), idx ,idx_cmi_channel_site; measured budget <=10" - - id: cmi2.P06 - stmt: ListChannelMessagesByIATAs - shape: "zero-hit ch27 ZZZ" - params: ["{ZZZ}", 27, 9223372036854775807, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 10, planning_ms: 10} - note: "measured: 3 / 3 B (custom / generic), idx ,idx_cmi_channel_site; measured budget <=10" - - id: cmi2.P07 - stmt: ListChannelMessagesByIATAs - shape: "ch27 UK22 p1 lim50" - params: ["{BHX,BLK,BOH,BRS,CAX,CEG,DSA,EMA,EXT,HUY,LCY,LON,LPL,MAN,MME,NQT,NQY,NWI,ORM,PLH,PME,VLY}", 27, 9223372036854775807, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 1500, planning_ms: 10} - note: "measured: 646 / 646 B (custom / generic), idx ,idx_cmi_channel_site; measured budget <=1500" - - id: cmi2.P08 - stmt: ListChannelMessagesByIATAs - shape: "ch27 UK22 deep cursor" - params: ["{BHX,BLK,BOH,BRS,CAX,CEG,DSA,EMA,EXT,HUY,LCY,LON,LPL,MAN,MME,NQT,NQY,NWI,ORM,PLH,PME,VLY}", 27, 15018736, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 1500, planning_ms: 10} - note: "measured: 640 / 640 B (custom / generic), idx ,idx_cmi_channel_site; measured budget <=1500" - - id: cmi2.P09 - stmt: ListChannelMessagesByIATAs - shape: "ch5 SEA lim200" - params: ["{SEA}", 5, 9223372036854775807, 201] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 3333, planning_ms: 10} - note: "measured: 2222 / 2222 B (custom / generic), idx ,idx_cmi_channel_site; 1.5x measured" - - id: cmi2.P10 - stmt: ListChannelMessagesByIATAs - shape: "ch5 ALL625 list lim50" - params: ["{AAB,AAH,AAL,AAR,ABC,ABE,ABI,ABQ,ABX,ABZ,ACH,ACY,ADL,AGS,AHN,AIZ,AKL,ALB,ALC,ALF,ALH,ALL,AMA,AMS,ANC,ANE,ANR,AOH,APF,ATH,ATL,ATW,AUH,AUS,AVL,AVP,AXN,AZO,BBH,BCN,BDL,BEG,BER,BES,BFD,BFL,BGM,BGN,BGR,BHD,BHM,BHS,BHX,BHZ,BJP,BLA,BLE,BLI,BLK,BLL,BNA,BNE,BOD,BOH,BOI,BOJ,BOS,BQN,BRE,BRN,BRQ,BRS,BRU,BTS,BUD,BUF,BUY,BVE,BWE,BWI,BWT,BYG,BYU,BZG,CAE,CAK,CAX,CBG,CBR,CDG,CEB,CEG,CEZ,CFR,CGI,CGN,CHA,CHC,CLE,CLT,CMH,CMI,COA,CON,COS,CPH,CPQ,CPT,CRL,CRW,CRX,CSM,CVG,CVO,CWA,CWB,CZW,DAB,DAL,DAY,DEC,DEN,DET,DFW,DIQ,DLE,DLH,DND,DNQ,DPO,DRO,DRS,DSA,DSM,DTM,DTW,DUB,DUD,DUS,DVN,DXB,EAT,EAU,EDI,EGE,EIN,ELM,ELP,EMA,EME,ENS,EPH,ERF,ESS,EUG,EVV,EWN,EXT,FAO,FAR,FAT,FKB,FLO,FLR,FMM,FNB,FNL,FNT,FPR,FRA,FRD,FWA,GAS,GBR,GCI,GDN,GDW,GEG,GEX,GGG,GHV,GJT,GLA,GLZ,GOA,GOJ,GOR,GOT,GPT,GPZ,GRQ,GRR,GRU,GRZ,GSO,GSP,GTI,GTP,GTR,GTW,GUF,GUL,GVX,HAD,HAJ,HAM,HDB,HEL,HLG,HLZ,HOH,HOU,HRA,HTS,HUY,HVN,HYR,IAD,IAS,IDA,IKT,ILM,ILZ,IND,INV,IQQ,ITA,IVC,JAN,JAX,JBQ,JCL,JER,JKG,JTC,JYV,KEL,KJK,KLR,KLS,KLU,KLV,KOI,KOK,KPS,KRK,KSC,KSD,KSF,KTN,KTW,KUF,KUN,KZG,KZN,LAA,LAS,LAX,LBA,LBB,LBC,LCH,LCJ,LCQ,LCY,LEH,LEJ,LEX,LEY,LFT,LGA,LGG,LGU,LIL,LIN,LIS,LIT,LJU,LKV,LLA,LMT,LNS,LNZ,LOI,LON,LOZ,LPI,LPL,LRF,LRH,LRT,LRU,LSE,LTN,LUG,LUX,LUZ,LWB,LWK,LWR,LYS,MAC,MAD,MAF,MAN,MBS,MCE,MCI,MCO,MDT,MEL,MEM,MFE,MFR,MGL,MGM,MHG,MIA,MIM,MKA,MKE,MLB,MLU,MME,MMH,MMV,MMX,MNN,MOT,MOW,MPL,MQL,MRO,MRY,MSN,MSP,MST,MSV,MSY,MTJ,MUC,MUE,MVH,MXP,NAP,NCE,NHZ,NIT,NOA,NOC,NOD,NPE,NPL,NQT,NQY,NSN,NTE,NTL,NTU,NUE,NUW,NWI,NYC,NYO,OAK,OBF,OBN,OCF,ODE,OGG,OKC,OLO,OMA,ONP,ONT,OOL,OPO,ORB,ORD,ORL,ORM,ORY,OSD,OSI,OSL,OSR,OTP,OUL,OXF,OXR,PAD,PAE,PAH,PAR,PDK,PDV,PDX,PED,PER,PFB,PGD,PGV,PHF,PHL,PHX,PIA,PIH,PIK,PIT,PKB,PLH,PLO,PLQ,PLR,PME,PMI,PMR,PNS,POA,POZ,PPM,PQQ,PRB,PRC,PRG,PRV,PSC,PSF,PSH,PSK,PSP,PUB,PUW,PVD,QAR,QDV,RAO,RBG,RDD,RDM,RDO,RDU,RDZ,RFD,RIC,RIX,RJK,RKD,RKS,RKV,RLG,RMO,RMU,RNB,RNN,RNO,ROA,ROC,ROK,ROT,ROV,RST,RSW,RTM,RUT,RYG,RZE,SAN,SAO,SAT,SBA,SBN,SBP,SBY,SCE,SCL,SCN,SDF,SDL,SDR,SEA,SFO,SGD,SGU,SIR,SJC,SJO,SJT,SJU,SJY,SKE,SLC,SLE,SMF,SMN,SNN,SOD,SOF,SPM,SQL,SQQ,SRQ,SSZ,STL,STN,STO,STR,STS,SVC,SVG,SVX,SWE,SWH,SXB,SYD,SYR,SZZ,TAT,TGD,TGN,TJM,TKU,TLH,TLL,TLS,TMP,TPA,TRD,TRF,TRG,TRI,TRN,TRO,TRS,TSR,TSV,TTD,TUF,TUL,TWB,TWF,TXK,TYR,TYS,UDE,UHE,UIP,UKK,UME,UTC,VAG,VAP,VBY,VCP,VIE,VIS,VJI,VLC,VLY,VNO,VOD,VOG,VPZ,VRZ,VST,VXO,WAW,WBG,WGA,WIC,WIE,WLG,WOL,WRE,WRO,WRT,WVN,WYA,XCM,XMS,XPH,XYZ,YBL,YCD,YEG,YGK,YHM,YHU,YHZ,YKA,YKF,YKM,YLK,YML,YOW,YPQ,YQA,YQB,YQF,YQL,YQQ,YQS,YQT,YQY,YRQ,YSE,YSJ,YTF,YTR,YUL,YVE,YVR,YWG,YWS,YXU,YXX,YYB,YYC,YYJ,YYY,YYZ,ZBE,ZBM,ZNO,ZPH}", 5, 9223372036854775807, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 3770, planning_ms: 10} - note: "measured: 2513 / 2513 B (custom / generic), idx ,idx_cmi_channel_site; 1.5x measured" - - id: cmi2.P11 - stmt: ListChannelMessagesByIATAsScoped - shape: "ch27 UK22 scope #fr lim50" - params: ["{BHX,BLK,BOH,BRS,CAX,CEG,DSA,EMA,EXT,HUY,LCY,LON,LPL,MAN,MME,NQT,NQY,NWI,ORM,PLH,PME,VLY}", 27, 175, 9223372036854775807, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 1500, planning_ms: 10} - note: "measured: 66 / 66 B (custom / generic), idx ,idx_cmi_channel_site_scope; measured budget <=1500" - - id: cmi2.P12 + note: "measured: 3 / 3 / 3 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.all.new stmt: ListAllChannelMessagesByIATAs - shape: "/messages?iatas=YUL lim50" - params: ["{YUL}", 9223372036854775807, 51] + shape: "/messages, the site the statistics have not seen" + shapes: [stale_region, page1] + tiers: [fixture] + params: [{r: cmi_new}, 9223372036854775807, 51] expect: driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["message_id <"]}] forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 600, planning_ms: 10} - note: "measured: 569 / 569 B (custom / generic), idx ,idx_cmi_site; measured budget <=600" - - id: cmi2.P13 + - id: cmi.all.list22 stmt: ListAllChannelMessagesByIATAs - shape: "/messages?iatas=UK22 lim50" - params: ["{BHX,BLK,BOH,BRS,CAX,CEG,DSA,EMA,EXT,HUY,LCY,LON,LPL,MAN,MME,NQT,NQY,NWI,ORM,PLH,PME,VLY}", 9223372036854775807, 51] + shape: "/messages, the 22 busiest recent sites, page 1" + shapes: [dense, page1] + params: [{r: cmi_list}, 9223372036854775807, 51] expect: driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["message_id <"]}] forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 1500, planning_ms: 10} - note: "measured: 652 / 652 B (custom / generic), idx ,idx_cmi_site; measured budget <=1500" - - id: cmi2.P14 - stmt: ListChannelMessagesPlain - shape: "plain ch27 lim50" - params: [27, 9223372036854775807, 51] - expect: - driver: [{relation: channel_messages, alias: cm, index: idx_channel_messages_channel_id, index_cond: ["channel_id =", "id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 1000, planning_ms: 10} - note: "measured: 413 / 422 B (custom / generic), idx ,idx_channel_messages_channel_id,idx_observations_packet; measured budget <=1000" - - id: cmi2.P15 - stmt: ListChannelMessagesPlain - shape: "plain ch27 mid cursor lim50" - params: [27, 16415687, 51] - expect: - driver: [{relation: channel_messages, alias: cm, index: idx_channel_messages_channel_id, index_cond: ["channel_id =", "id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 1000, planning_ms: 10} - note: "measured: 411 / 411 B (custom / generic), idx ,idx_channel_messages_channel_id,idx_observations_packet; measured budget <=1000" - - id: cmi2.P20 - stmt: ListAllChannelMessagesByIATAsSince - shape: "/messages since-10.2h + PNW13 lim200" - params: ["{BLI,CVO,KLS,LMT,MFR,MMV,ONP,PAE,PDX,RDM,SEA,SLE,TTD}", "2026-10-18 06:48+00", null, 9223372036854775807, 201] + budget: {buffers: 2721, planning_ms: 10} + note: "measured: 1814 / 1814 / 1814 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.all.list22.deep + stmt: ListAllChannelMessagesByIATAs + shape: "/messages, the 22 busiest recent sites, deep cursor" + shapes: [dense, deep] + params: [{r: cmi_list}, {r: cmi_site_deep}, 51] expect: driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["message_id <"]}] forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 42152, planning_ms: 10} - note: "measured: 28101 / 168613 B (custom / generic), idx ,idx_cmi_site; 1.5x measured" - - id: cmi2.P21 - stmt: ListAllChannelMessagesSince - shape: "/messages since-10.2h cursor lim200 (pathfinder)" - params: ["2026-10-18 06:48+00", null, 18200000, 201] - expect: - driver: [{relation: channel_messages, alias: cm, nodes: ["Index Scan", "Index Only Scan", "Bitmap Heap Scan"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 2573, planning_ms: 10} - note: "measured: 1715 / 3132 B (custom / generic), idx ,idx_observations_packet; 1.5x measured" - - id: cmi2.P22 - stmt: ListAllChannelMessagesSince - shape: "/messages since-10.2h past the end (last page)" - params: ["2026-10-18 06:48+00", null, 18100000, 201] - expect: - driver: [{relation: channel_messages, alias: cm, nodes: ["Index Scan", "Index Only Scan", "Bitmap Heap Scan"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 2549, planning_ms: 10} - note: "measured: 1699 / 2997 B (custom / generic), idx ,idx_observations_packet; 1.5x measured" - - id: cmi2.P23 - stmt: ListAllChannelMessagesPlain - shape: "/messages plain lim100" - params: [9223372036854775807, 101] - expect: - driver: [{relation: channel_messages, alias: cm, nodes: ["Index Scan", "Index Only Scan", "Bitmap Heap Scan"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 1000, planning_ms: 10} - note: "measured: 877 / 2174 B (custom / generic), idx ,idx_observations_packet; measured budget <=1000" - - id: cmi2.P24 - stmt: ListAllChannelMessagesPlainScoped - shape: "/messages scope #fr lim20" - params: [175, 9223372036854775807, 21] - expect: - driver: [{relation: channel_messages, alias: cm, nodes: ["Index Scan", "Index Only Scan", "Bitmap Heap Scan"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 83595, planning_ms: 10} - known_issue: "/messages?scope= has no bounded path until it reads channel_message_iatas by scope" - note: "measured: 55730 / 50294 B (custom / generic), idx ,cm_packet_hash_key,idx_observations_packet,idx_packets_scope; 1.5x measured" - - id: cmi2.P25 - stmt: ListAllChannelMessagesPlainScoped - shape: "/messages scope #rheinland (0 msgs)" - params: [5, 9223372036854775807, 51] - expect: - driver: [{relation: channel_messages, alias: cm, nodes: ["Index Scan", "Index Only Scan", "Bitmap Heap Scan"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 180, planning_ms: 10} - note: "measured: 120 / 120 B (custom / generic), idx ,cm_packet_hash_key,idx_observations_packet,idx_packets_scope; 1.5x measured" - - id: cmi2.P26 - stmt: ListChannelMessagesSinceWalk - shape: "SinceWalk ch5 YUL since-3d lim50" - params: [5, "2026-10-15 17:00+00", "{YUL}", null, 9223372036854775807, 51] - expect: - driver: [{relation: channel_messages, alias: cm, index: idx_channel_messages_channel_id, index_cond: ["channel_id =", "id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 63578, planning_ms: 10} - note: "measured: 42385 / 192982 B (custom / generic), idx ,idx_channel_messages_channel_id,idx_cmi_site,idx_observations_packet; 1.5x measured" - - id: cmi2.P27 - stmt: ListChannelMessagesSinceWalk - shape: "SinceWalk ch27 since-10.2h lim50" - params: [27, "2026-10-18 06:48+00", "{}", null, 9223372036854775807, 51] - expect: - driver: [{relation: channel_messages, alias: cm, index: idx_channel_messages_channel_id, index_cond: ["channel_id =", "id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 620, planning_ms: 10} - note: "measured: 413 / 572 B (custom / generic), idx ,idx_channel_messages_channel_id,idx_observations_packet; 1.5x measured" - - id: cmi2.P32 - stmt: ListAllChannelMessagesPlainScoped - shape: "/messages scope #nl lim50" - params: [50, 9223372036854775807, 51] - expect: - driver: [{relation: channel_messages, alias: cm, nodes: ["Index Scan", "Index Only Scan", "Bitmap Heap Scan"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 28782, planning_ms: 10} - known_issue: "/messages?scope= has no bounded path until it reads channel_message_iatas by scope" - note: "measured: 19188 / 97204 B (custom / generic), idx idx_observations_packet,idx_packets_scope; 1.5x measured" - - id: cmi2.P16_cmi - stmt: ListChannelMessagesPlainScoped - shape: "PlainScoped ch27 #fr lim50" - params: [27, 175, 9223372036854775807, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 1077, planning_ms: 10} - note: "measured: 718 / 718 B (custom / generic), idx channels_pkey,cm_pkey,idx_cmi_channel_scope,packets_pkey,transport_scopes_pkey; 1.5x measured" - - id: cmi2.P17_cmi - stmt: ListChannelMessagesPlainScoped - shape: "PlainScoped ch27 #bx (1 msg, deep)" - params: [27, 65, 9223372036854775807, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 50, planning_ms: 10} - note: "measured: 18 / 18 B (custom / generic), idx channels_pkey,cm_pkey,idx_cmi_channel_scope,packets_pkey,transport_scopes_pkey; 1.5x measured" - - id: cmi2.P18_cmi - stmt: ListChannelMessagesPlainScoped - shape: "PlainScoped ch27 #rheinland (0 msgs)" - params: [27, 5, 9223372036854775807, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 50, planning_ms: 10} - note: "measured: 3 / 3 B (custom / generic), idx channels_pkey,cm_pkey,idx_cmi_channel_scope,packets_pkey,transport_scopes_pkey; 1.5x measured" - - id: cmi2.P19_cmi - stmt: ListChannelMessagesPlainScoped - shape: "PlainScoped ch5 #rheinland (0 msgs)" - params: [5, 5, 9223372036854775807, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 50, planning_ms: 10} - note: "measured: 3 / 3 B (custom / generic), idx channels_pkey,cm_pkey,idx_cmi_channel_scope,packets_pkey,transport_scopes_pkey; 1.5x measured" - - id: cmi2.P28_cmi - stmt: ListChannelMessagesPlainScoped - shape: "PlainScoped ch23 #de (5 msgs)" - params: [23, 2, 9223372036854775807, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 111, planning_ms: 10} - note: "measured: 74 / 74 B (custom / generic), idx channels_pkey,cm_pkey,idx_cmi_channel_scope,packets_pkey,transport_scopes_pkey; 1.5x measured" - - id: cmi2.P29_cmi - stmt: ListChannelMessagesPlainScoped - shape: "PlainScoped ch5 #de lim50" - params: [5, 2, 9223372036854775807, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 1079, planning_ms: 10} - note: "measured: 719 / 719 B (custom / generic), idx channels_pkey,cm_pkey,idx_cmi_channel_scope,packets_pkey,transport_scopes_pkey; 1.5x measured" - - id: cmi2.P30_cmi - stmt: ListChannelMessagesPlainScoped - shape: "PlainScoped ch23 #nl (0 msgs)" - params: [23, 50, 9223372036854775807, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 50, planning_ms: 10} - note: "measured: 3 / 3 B (custom / generic), idx channels_pkey,cm_pkey,idx_cmi_channel_scope,packets_pkey,transport_scopes_pkey; 1.5x measured" - - id: cmi2.P31_cmi - stmt: ListChannelMessagesPlainScoped - shape: "PlainScoped ch27 #nl lim200" - params: [27, 50, 9223372036854775807, 201] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 2459, planning_ms: 10} - note: "measured: 1639 / 2821 B (custom / generic), idx channels_pkey,cm_pkey,idx_cmi_channel_scope,packets_pkey,transport_scopes_pkey; 1.5x measured" - - id: cmi2.P33_cmi - stmt: ListChannelMessagesPlainScoped - shape: "PlainScoped ch5 #bx (0 msgs)" - params: [5, 65, 9223372036854775807, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 50, planning_ms: 10} - note: "measured: 3 / 3 B (custom / generic), idx channels_pkey,cm_pkey,idx_cmi_channel_scope,packets_pkey,transport_scopes_pkey; 1.5x measured" - - id: cmi2.P34_cmi - stmt: ListChannelMessagesPlainScoped - shape: "PlainScoped ch5 #de deep cursor" - params: [5, 2, 14994622, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 1077, planning_ms: 10} - note: "measured: 718 / 718 B (custom / generic), idx channels_pkey,cm_pkey,idx_cmi_channel_scope,packets_pkey,transport_scopes_pkey; 1.5x measured" - - id: cmi2.v_ch27_yul_cursor_3e9 - stmt: ListChannelMessagesByIATAs - shape: "channel endpoint, cursor 3e9 (>= 2^31)" - params: ["{YUL}", 27, 3000000000, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 600, planning_ms: 10} - note: "no measured run; measured budget <=600" - - id: cmi2.v_all_yul_cursor_3e9 + budget: {buffers: 2744, planning_ms: 10} + note: "measured: 1829 / 1829 / 1829 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.all.codes stmt: ListAllChannelMessagesByIATAs - shape: "/messages?iatas=YUL, cursor 3e9 (>= 2^31; today: 500)" - params: ["{YUL}", 3000000000, 51] + shape: "/messages, every known site" + shapes: [giant_list, page1] + params: [{r: cmi_codes}, 9223372036854775807, 51] expect: driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["message_id <"]}] forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 600, planning_ms: 10} - note: "no measured run; measured budget <=600" - - id: cmi2.v_all_plain_cursor_3e9 - stmt: ListAllChannelMessagesPlain - shape: "/messages plain, cursor 3e9 (>= 2^31; today: 500)" - params: [3000000000, 101] - expect: - driver: [{relation: channel_messages, alias: cm, nodes: ["Index Scan", "Index Only Scan", "Bitmap Heap Scan"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 1000, planning_ms: 10} - note: "no measured run; measured budget <=1000" - - id: cmi2.v_all_since_cursor_3e9 - stmt: ListAllChannelMessagesSince - shape: "/messages since T0-10.2h, cursor 3e9" - params: ["2026-10-18 06:48+00", null, 3000000000, 201] - expect: - driver: [{relation: channel_messages, alias: cm, nodes: ["Index Scan", "Index Only Scan", "Bitmap Heap Scan"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 25000, planning_ms: 10} - note: "no measured run; class budget" - - id: cmi2.v_ch27_bogus5000 - stmt: ListChannelMessagesByIATAs - shape: "channel 27 + 5,000 bogus IATAs" - params: [{r: cmi_bogus5000}, 27, 9223372036854775807, 51] - expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] - forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 25000, planning_ms: 60} - note: "no measured run; measured budget <=25000" - - id: cmi2.v_all_bogus5000 + budget: {buffers: 39261, planning_ms: 10} + note: "measured: 26174 / 26174 / 26174 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.all.bogus5000 stmt: ListAllChannelMessagesByIATAs - shape: "/messages + 5,000 bogus IATAs" + shape: "/messages, 5,000 codes that are no site" + shapes: [giant_list, empty_region] params: [{r: cmi_bogus5000}, 9223372036854775807, 51] expect: driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["message_id <"]}] forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 25000, planning_ms: 60} - note: "no measured run; measured budget <=25000" - - id: cmi2.v_ch27_allcmi - stmt: ListChannelMessagesByIATAs - shape: "channel 27 + every site with a message" - params: [{r: cmi_all_sites}, 27, 9223372036854775807, 51] + budget: {buffers: 22500, planning_ms: 10} + note: "measured: 15000 / 15000 / 15000 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.plain.page1 + stmt: ListChannelMessagesPlain + shape: "the busiest channel, unfiltered, page 1" + shapes: [page1] + params: [{r: cmi_ch}, 9223372036854775807, 51] expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] + driver: [{relation: channel_messages, alias: cm, index: idx_channel_messages_channel_id, index_cond: ["channel_id =", "id <"]}] forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 25000, planning_ms: 10} - note: "no measured run; measured budget <=25000" - - id: cmi2.v_all_allcmi - stmt: ListAllChannelMessagesByIATAs - shape: "/messages + every site with a message" - params: [{r: cmi_all_sites}, 9223372036854775807, 51] + budget: {buffers: 671, planning_ms: 10} + note: "measured: 426 / 447 / 447 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.plain.limit201 + stmt: ListChannelMessagesPlain + shape: "the busiest channel, unfiltered, page 1, limit 200" + shapes: [page1] + params: [{r: cmi_ch}, 9223372036854775807, 201] expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_site, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["message_id <"]}] + driver: [{relation: channel_messages, alias: cm, index: idx_channel_messages_channel_id, index_cond: ["channel_id =", "id <"]}] forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] - budget: {buffers: 25000, planning_ms: 10} - note: "no measured run; measured budget <=25000" - - id: cmi2.v_ch27_new_zerohit_scoped + budget: {buffers: 2654, planning_ms: 10} + note: "measured: 1631 / 1769 / 1769 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.plain.deep + stmt: ListChannelMessagesPlain + shape: "the busiest channel, unfiltered, cursor amid its newest 5,000 messages" + shapes: [deep] + params: [{r: cmi_ch}, {r: cm_ch_deep}, 51] + expect: + driver: [{relation: channel_messages, alias: cm, index: idx_channel_messages_channel_id, index_cond: ["channel_id =", "id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 756, planning_ms: 10} + note: "measured: 432 / 504 / 504 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.plain.at50 + stmt: ListChannelMessagesPlain + shape: "the busiest channel, unfiltered, cursor at page 1's 50th id" + shapes: [tie] + params: [{r: cmi_ch}, {r: cm_ch_50}, 51] + expect: + driver: [{relation: channel_messages, alias: cm, index: idx_channel_messages_channel_id, index_cond: ["channel_id =", "id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 669, planning_ms: 10} + note: "measured: 422 / 446 / 446 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.plain.cursor_3e9 + stmt: ListChannelMessagesPlain + shape: "the busiest channel, unfiltered, cursor 3e9" + shapes: [deep] + params: [{r: cmi_ch}, 3000000000, 51] + expect: + driver: [{relation: channel_messages, alias: cm, index: idx_channel_messages_channel_id, index_cond: ["channel_id =", "id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 671, planning_ms: 10} + note: "measured: 426 / 447 / 447 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.allplain.page1 + stmt: ListAllChannelMessagesPlain + shape: "/messages unfiltered, page 1, limit 100" + shapes: [page1] + params: [9223372036854775807, 101] + expect: + driver: [{relation: channel_messages, alias: cm, index: channel_messages_pkey, index_cond: ["id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1316, planning_ms: 10} + note: "measured: 877 / 877 / 877 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.allplain.deep + stmt: ListAllChannelMessagesPlain + shape: "/messages unfiltered, cursor amid the newest 20,000 messages" + shapes: [deep] + params: [{r: cm_deep}, 51] + expect: + driver: [{relation: channel_messages, alias: cm, index: channel_messages_pkey, index_cond: ["id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 663, planning_ms: 10} + note: "measured: 442 / 442 / 442 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.allplain.at50 + stmt: ListAllChannelMessagesPlain + shape: "/messages unfiltered, cursor at page 1's 50th id" + shapes: [tie] + params: [{r: cm_50}, 51] + expect: + driver: [{relation: channel_messages, alias: cm, index: channel_messages_pkey, index_cond: ["id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 722, planning_ms: 10} + note: "measured: 481 / 481 / 481 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.allplain.cursor_3e9 + stmt: ListAllChannelMessagesPlain + shape: "/messages unfiltered, cursor 3e9" + shapes: [deep] + params: [3000000000, 51] + expect: + driver: [{relation: channel_messages, alias: cm, index: channel_messages_pkey, index_cond: ["id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 648, planning_ms: 10} + note: "measured: 432 / 432 / 432 B (custom / generic / auto) on the full local copy; budget 1.5x" + - id: cmi.chscope.list22 stmt: ListChannelMessagesByIATAsScoped - shape: "channel 27 + YUL + a scope with no messages there (#rheinland)" - params: ["{YUL}", 27, 5, 9223372036854775807, 51] + shape: "the busiest scoped channel, its 22 busiest sites, its busiest scope" + params: [{r: cmi_sc_list}, {r: cmi_sc_ch}, {r: cmi_sc}, 9223372036854775807, 51] expect: - driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "message_id <"]}] + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_site_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1787, planning_ms: 10} + note: "class C: its generic plan switches to idx_cmi_channel_scope when the visibility map is stale; measured: 1191 B (custom) on the full local copy; budget 1.5x" + - id: cmi.chscope.zerohit + stmt: ListChannelMessagesByIATAsScoped + shape: "the busiest channel's busiest site with a scope no message carries" + params: [{r: cmi_ch_site}, {r: cmi_ch}, {r: cmi_scope_absent}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, any_index: [idx_cmi_channel_site_scope, idx_cmi_scope], nodes: ["Index Only Scan", "Index Scan"], index_cond: ["scope_id =", "message_id <"]}] forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] - sort_exempt: [per_site_message_ranges] budget: {buffers: 10, planning_ms: 10} - note: "no measured run; measured budget <=10" - - id: cmi2.ingest.add_iata + note: "measured: 3 B (custom) on the full local copy; budget 1.5x" + - id: cmi.plainscope.busy + stmt: ListChannelMessagesPlainScoped + shape: "the busiest scoped channel and scope, page 1" + params: [{r: cmi_sc_ch}, {r: cmi_sc}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1521, planning_ms: 10} + note: "measured: 1014 B (custom) on the full local copy; budget 1.5x" + - id: cmi.plainscope.limit201 + stmt: ListChannelMessagesPlainScoped + shape: "the busiest scoped channel and scope, limit 200" + params: [{r: cmi_sc_ch}, {r: cmi_sc}, 9223372036854775807, 201] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 4142, planning_ms: 10} + note: "measured: 2761 B (custom) on the full local copy; budget 1.5x" + - id: cmi.plainscope.deep + stmt: ListChannelMessagesPlainScoped + shape: "the busiest scoped channel and scope, cursor amid its newest 5,000 messages" + params: [{r: cmi_sc_ch}, {r: cmi_sc}, {r: cmi_sc_deep}, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1523, planning_ms: 10} + note: "measured: 1015 B (custom) on the full local copy; budget 1.5x" + - id: cmi.plainscope.rare + stmt: ListChannelMessagesPlainScoped + shape: "the busiest scoped channel, its rarest recent scope" + params: [{r: cmi_sc_ch}, {r: cmi_sc_rare}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 120, planning_ms: 10} + note: "measured: 80 B (custom) on the full local copy; budget 1.5x" + - id: cmi.plainscope.absent + stmt: ListChannelMessagesPlainScoped + shape: "the busiest channel, a scope no message carries" + params: [{r: cmi_ch}, {r: cmi_scope_absent}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, any_index: [idx_cmi_channel_scope, idx_cmi_scope], nodes: ["Index Only Scan", "Index Scan"], index_cond: ["scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 10, planning_ms: 10} + note: "measured: 3 B (custom) on the full local copy; budget 1.5x" + - id: cmi.plainscope.cursor_3e9 + stmt: ListChannelMessagesPlainScoped + shape: "the busiest scoped channel and scope, cursor 3e9" + params: [{r: cmi_sc_ch}, {r: cmi_sc}, 3000000000, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_channel_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["channel_id =", "scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1521, planning_ms: 10} + note: "measured: 1014 B (custom) on the full local copy; budget 1.5x" + - id: cmi.allplainscope.limit20 + stmt: ListAllChannelMessagesPlainScoped + shape: "/messages, the busiest scope, limit 20" + params: [{r: cmi_scope}, 9223372036854775807, 21] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 630, planning_ms: 10} + note: "measured: 420 B (custom) on the full local copy; budget 1.5x" + - id: cmi.allplainscope.page1 + stmt: ListAllChannelMessagesPlainScoped + shape: "/messages, the busiest scope, page 1" + params: [{r: cmi_scope}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1515, planning_ms: 10} + note: "measured: 1010 B (custom) on the full local copy; budget 1.5x" + - id: cmi.allplainscope.limit201 + stmt: ListAllChannelMessagesPlainScoped + shape: "/messages, the busiest scope, limit 200" + params: [{r: cmi_scope}, 9223372036854775807, 201] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 4107, planning_ms: 10} + note: "measured: 2738 B (custom) on the full local copy; budget 1.5x" + - id: cmi.allplainscope.deep + stmt: ListAllChannelMessagesPlainScoped + shape: "/messages, the busiest scope, cursor amid its newest 5,000 messages" + params: [{r: cmi_scope}, {r: cmi_scope_deep}, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1601, planning_ms: 10} + note: "measured: 1067 B (custom) on the full local copy; budget 1.5x" + - id: cmi.allplainscope.at50 + stmt: ListAllChannelMessagesPlainScoped + shape: "/messages, the busiest scope, cursor at page 1's 50th id" + params: [{r: cmi_scope}, {r: cmi_scope_50}, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1493, planning_ms: 10} + note: "measured: 995 B (custom) on the full local copy; budget 1.5x" + - id: cmi.allplainscope.cursor_3e9 + stmt: ListAllChannelMessagesPlainScoped + shape: "/messages, the busiest scope, cursor 3e9" + params: [{r: cmi_scope}, 3000000000, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1515, planning_ms: 10} + note: "measured: 1010 B (custom) on the full local copy; budget 1.5x" + - id: cmi.allplainscope.rare + stmt: ListAllChannelMessagesPlainScoped + shape: "/messages, the rarest recent scope" + params: [{r: cmi_scope_rare}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 1154, planning_ms: 10} + note: "measured: 769 B (custom) on the full local copy; budget 1.5x" + - id: cmi.allplainscope.absent + stmt: ListAllChannelMessagesPlainScoped + shape: "/messages, a scope no message carries" + params: [{r: cmi_scope_absent}, 9223372036854775807, 51] + expect: + driver: [{scope: "CTE hits", relation: channel_message_iatas, alias: i, index: idx_cmi_scope, nodes: ["Index Only Scan", "Index Scan"], index_cond: ["scope_id =", "message_id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 10, planning_ms: 10} + note: "measured: 3 B (custom) on the full local copy; budget 1.5x" + - id: cmi.allsince.page1 + stmt: ListAllChannelMessagesSince + shape: "/messages since 10 hours before the newest message, limit 200" + params: [{r: cm_since10h}, null, 9223372036854775807, 201] + expect: + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 2540, planning_ms: 10} + note: "measured: 1693 B (custom) on the full local copy; budget 1.5x" + - id: cmi.allsince.cursor + stmt: ListAllChannelMessagesSince + shape: "/messages since 10 hours before the newest message, second page" + params: [{r: cm_since10h}, null, {r: cm_since_cursor}, 201] + expect: + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 2555, planning_ms: 10} + note: "measured: 1703 B (custom) on the full local copy; budget 1.5x" + - id: cmi.allsince.scoped + stmt: ListAllChannelMessagesSince + shape: "/messages since 10 hours before the newest message, the busiest scope" + params: [{r: cm_since10h}, {r: cmi_scope}, 9223372036854775807, 201] + expect: + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 38972, planning_ms: 10} + known_issue: "since with a scope and no sites (no client sends it): today's statement and this one read the scope's packets through idx_packets_scope, idx_channel_messages_sent_brin and idx_observations_packet, all due to be dropped, and sort them unbounded under the Limit; re-measure before dropping those indexes" + note: "measured: 25981 B (custom) on the full local copy; budget 1.5x" + - id: cmi.allsince.future + stmt: ListAllChannelMessagesSince + shape: "/messages since a time after every message (2100), limit 200" + params: [{raw: "'2100-01-01 00:00+00'::timestamptz"}, null, 9223372036854775807, 201] + expect: + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + note: "no worse than today's statement: both stop on the sent_at index; re-measure before the drop of idx_channel_messages_sent_brin" + - id: cmi.allsince.cursor_3e9 + stmt: ListAllChannelMessagesSince + shape: "/messages since 10 hours before the newest message, cursor 3e9" + params: [{r: cm_since10h}, null, 3000000000, 201] + expect: + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 2540, planning_ms: 10} + note: "measured: 1693 B (custom) on the full local copy; budget 1.5x" + - id: cmi.sincewalk.site3d + stmt: ListChannelMessagesSinceWalk + shape: "the busiest channel since 3 days before the newest message, its busiest site" + params: [{r: cmi_ch}, {r: cm_since3d}, {r: cmi_ch_site}, null, 9223372036854775807, 51] + expect: + driver: [{relation: channel_messages, alias: cm, index: idx_channel_messages_channel_id, index_cond: ["channel_id =", "id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 6891, planning_ms: 10} + note: "measured: 4594 B (custom) on the full local copy; budget 1.5x" + - id: cmi.sincewalk.future + stmt: ListChannelMessagesSinceWalk + shape: "the busiest channel since a time after every message (2100), its busiest site" + params: [{r: cmi_ch}, {raw: "'2100-01-01 00:00+00'::timestamptz"}, {r: cmi_ch_site}, null, 9223372036854775807, 51] + expect: + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + note: "no worse than today's statement: both stop on the channel's sent_at index; re-measure before the drop of idx_channel_messages_channel" + - id: cmi.sincewalk.plain10h + stmt: ListChannelMessagesSinceWalk + shape: "the busiest channel since 10 hours before the newest message, unfiltered" + params: [{r: cmi_ch}, {r: cm_since10h}, "{}", null, 9223372036854775807, 51] + expect: + driver: [{relation: channel_messages, alias: cm, index: idx_channel_messages_channel_id, index_cond: ["channel_id =", "id <"]}] + forbid: [{node: "Seq Scan", relations: [channel_messages, channel_message_iatas]}] + budget: {buffers: 639, planning_ms: 10} + note: "measured: 426 B (custom) on the full local copy; budget 1.5x" + - id: cmi.ingest.add stmt: AddChannelMessageIATA - shape: "AddChannelMessageIATA for the newest message hash (plain EXPLAIN; ingest pool, auto)" - params: [YUL, {r: cm_newest_hash}] + shape: "a later hearing's site for the newest message (ingest pool, auto)" + params: [{r: cm_newest_hash}, {r: cmi_site_s}] expect: driver: [{relation: channel_messages, alias: cm, index: channel_messages_packet_hash_key, index_cond: ["packet_hash ="]}] - - id: cmi2.maint.fill_by_messages + - id: cmi.ingest.insert + stmt: InsertChannelMessage + shape: "a message with its seed, for the newest observation's packet (ingest pool, auto)" + params: [1, {r: obs_newest_hash}, s, c, "2026-10-18 17:00+00", false] + - id: cmi.maint.fill_by_messages stmt: FillChannelMessageIATAsByMessages - shape: "backfill / reconcile message part over one 10K-message id range (plain EXPLAIN; maint)" - params: [17000000, 17010000] + shape: "backfill or reconcile message part: the newest 10,000 message ids" + tiers: [local, prod] + params: [{r: cm_fill_lo}, {r: cm_fill_hi}] expect: driver: [{relation: channel_messages, alias: cm, index: channel_messages_pkey, index_cond: ["id >"]}] + - id: cmi.maint.fill_by_observations + stmt: FillChannelMessageIATAsByObservations + shape: "reconcile observation part: the newest 340,000 observation ids" + tiers: [local, prod] + params: [{r: po_fill_lo}, {r: po_fill_hi}] + expect: + driver: [{relation: packet_observations, alias: po, index: packet_observations_pkey, index_cond: ["id >"]}] # ---- stats, adverts, traces and telemetry (legacy readers and pending rewrites) ---- - id: s7.tn.LIS_1d diff --git a/db/planguard/diff/channel_message_iatas.yaml b/db/planguard/diff/channel_message_iatas.yaml new file mode 100644 index 0000000..366648c --- /dev/null +++ b/db/planguard/diff/channel_message_iatas.yaml @@ -0,0 +1,2090 @@ +# Copyright 2026 Beacon Contributors +# SPDX-License-Identifier: AGPL-3.0-or-later + +# Channel message pages: today's two statements (old:) against the statement the server now runs for each request +# shape (new:), on the overlay overlay/channel_message_iatas.sql (schema t_s4a). Every pair must return identical +# rows: no result-change class applies. Cursor 0 (today's "no cursor") is the new statements' 9223372036854775807; +# every other cursor is passed as given. Limits are the server's limit + 1. Sites with a since or a scope across every +# channel run today's statement itself, so they have no pair here. +# +# Channels, sites and scopes are picked by role among the newest 20,000 channel_message_iatas rows; cursors come from +# each shape's own newest 5,000 ids (the median, the tenth percentile, the 50th). Since times count back from the newest message. +# psql "$DSN" -v ON_ERROR_STOP=1 -f db/planguard/overlay/channel_message_iatas.sql +# planguard diff --old-ref 119e23f --cases db/planguard/diff/channel_message_iatas.yaml --dsn ... +# then DROP SCHEMA t_s4a CASCADE. Cursor chains are walked by storediff/channel_message_iatas.yaml. +batches: + - name: channel_message_iatas + search_path: "t_s4a, public" + statements: + old: "old:ListChannelMessages" + oldall: "old:ListAllChannelMessages" + by: "new:ListChannelMessagesByIATAs" + bysc: "new:ListChannelMessagesByIATAsScoped" + plain: "new:ListChannelMessagesPlain" + plainsc: "new:ListChannelMessagesPlainScoped" + walk: "new:ListChannelMessagesSinceWalk" + aby: "new:ListAllChannelMessagesByIATAs" + aplain: "new:ListAllChannelMessagesPlain" + aplainsc: "new:ListAllChannelMessagesPlainScoped" + asince: "new:ListAllChannelMessagesSince" + pairs: + - id: ch.site.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {by: identical} + - id: ch.site.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {by: identical} + - id: ch.site.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {by: identical} + - id: ch.site.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {by: identical} + - id: ch.site.mid.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {by: identical} + - id: ch.site.mid.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {by: identical} + - id: ch.site.mid.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {by: identical} + - id: ch.site.mid.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {by: identical} + - id: ch.site.deep.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {by: identical} + - id: ch.site.deep.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {by: identical} + - id: ch.site.deep.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {by: identical} + - id: ch.site.deep.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {by: identical} + - id: ch.site.at50.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {by: identical} + - id: ch.site.at50.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {by: identical} + - id: ch.site.at50.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {by: identical} + - id: ch.site.at50.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {by: identical} + - id: ch.site.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 2]} + expect: {by: identical} + - id: ch.site.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 4]} + expect: {by: identical} + - id: ch.site.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 51]} + expect: {by: identical} + - id: ch.site.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 201]} + expect: {by: identical} + - id: ch.site_dup.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {by: identical} + - id: ch.site_dup.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {by: identical} + - id: ch.site_dup.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {by: identical} + - id: ch.site_dup.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {by: identical} + - id: ch.site_dup.mid.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {by: identical} + - id: ch.site_dup.mid.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {by: identical} + - id: ch.site_dup.mid.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {by: identical} + - id: ch.site_dup.mid.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {by: identical} + - id: ch.site_dup.deep.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {by: identical} + - id: ch.site_dup.deep.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {by: identical} + - id: ch.site_dup.deep.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {by: identical} + - id: ch.site_dup.deep.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {by: identical} + - id: ch.site_dup.at50.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {by: identical} + - id: ch.site_dup.at50.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {by: identical} + - id: ch.site_dup.at50.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {by: identical} + - id: ch.site_dup.at50.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {by: identical} + - id: ch.site_dup.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 2]} + expect: {by: identical} + - id: ch.site_dup.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 4]} + expect: {by: identical} + - id: ch.site_dup.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 51]} + expect: {by: identical} + - id: ch.site_dup.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1), (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 201]} + expect: {by: identical} + - id: ch.list22.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 0, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {by: identical} + - id: ch.list22.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 0, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {by: identical} + - id: ch.list22.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 0, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {by: identical} + - id: ch.list22.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 0, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {by: identical} + - id: ch.list22.mid.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {by: identical} + - id: ch.list22.mid.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {by: identical} + - id: ch.list22.mid.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {by: identical} + - id: ch.list22.mid.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {by: identical} + - id: ch.list22.deep.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {by: identical} + - id: ch.list22.deep.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {by: identical} + - id: ch.list22.deep.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {by: identical} + - id: ch.list22.deep.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {by: identical} + - id: ch.list22.at50.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {by: identical} + - id: ch.list22.at50.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {by: identical} + - id: ch.list22.at50.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {by: identical} + - id: ch.list22.at50.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND iata = ANY(((SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s))::bpchar[]) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {by: identical} + - id: ch.list22.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 3000000000, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 2]} + expect: {by: identical} + - id: ch.list22.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 3000000000, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 4]} + expect: {by: identical} + - id: ch.list22.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 3000000000, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 51]} + expect: {by: identical} + - id: ch.list22.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 3000000000, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 201]} + expect: {by: identical} + - id: ch.codes.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 0, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {by: identical} + - id: ch.codes.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 0, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {by: identical} + - id: ch.codes.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 0, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {by: identical} + - id: ch.codes.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 0, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {by: identical} + - id: ch.codes.mid.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {by: identical} + - id: ch.codes.mid.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {by: identical} + - id: ch.codes.mid.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {by: identical} + - id: ch.codes.mid.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {by: identical} + - id: ch.codes.deep.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {by: identical} + - id: ch.codes.deep.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {by: identical} + - id: ch.codes.deep.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {by: identical} + - id: ch.codes.deep.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {by: identical} + - id: ch.codes.at50.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {by: identical} + - id: ch.codes.at50.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {by: identical} + - id: ch.codes.at50.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {by: identical} + - id: ch.codes.at50.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {by: identical} + - id: ch.codes.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 3000000000, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 2]} + expect: {by: identical} + - id: ch.codes.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 3000000000, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 4]} + expect: {by: identical} + - id: ch.codes.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 3000000000, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 51]} + expect: {by: identical} + - id: ch.codes.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 3000000000, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 201]} + expect: {by: identical} + - id: ch.bogus5000.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 0, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {by: identical} + - id: ch.bogus5000.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 0, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {by: identical} + - id: ch.bogus5000.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 0, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {by: identical} + - id: ch.bogus5000.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 0, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {by: identical} + - id: ch.bogus5000.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 3000000000, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 2]} + expect: {by: identical} + - id: ch.bogus5000.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 3000000000, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 4]} + expect: {by: identical} + - id: ch.bogus5000.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 3000000000, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 51]} + expect: {by: identical} + - id: ch.bogus5000.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 3000000000, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 201]} + expect: {by: identical} + - id: ch.empty.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, "", 0, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {by: identical} + - id: ch.empty.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, "", 0, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {by: identical} + - id: ch.empty.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, "", 0, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {by: identical} + - id: ch.empty.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, "", 0, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {by: identical} + - id: ch.empty.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, "", 3000000000, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 2]} + expect: {by: identical} + - id: ch.empty.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, "", 3000000000, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 4]} + expect: {by: identical} + - id: ch.empty.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, "", 3000000000, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 51]} + expect: {by: identical} + - id: ch.empty.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, "", 3000000000, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT (SELECT ARRAY[ic.iata]::bpchar[] FROM iata_codes ic WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND i.iata = ic.iata) ORDER BY ic.iata LIMIT 1)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 201]} + expect: {by: identical} + - id: ch2.site.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {by: identical} + - id: ch2.site.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {by: identical} + - id: ch2.site.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {by: identical} + - id: ch2.site.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {by: identical} + - id: ch2.site.mid.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {by: identical} + - id: ch2.site.mid.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {by: identical} + - id: ch2.site.mid.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {by: identical} + - id: ch2.site.mid.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {by: identical} + - id: ch2.site.deep.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {by: identical} + - id: ch2.site.deep.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {by: identical} + - id: ch2.site.deep.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {by: identical} + - id: ch2.site.deep.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {by: identical} + - id: ch2.site.at50.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {by: identical} + - id: ch2.site.at50.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {by: identical} + - id: ch2.site.at50.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {by: identical} + - id: ch2.site.at50.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) AND iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {by: identical} + - id: ch2.site.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 2]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 2]} + expect: {by: identical} + - id: ch2.site.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 4]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 4]} + expect: {by: identical} + - id: ch2.site.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 51]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 51]} + expect: {by: identical} + - id: ch2.site.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 201]} + cands: + - {stmt: by, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 201]} + expect: {by: identical} + - id: ch.list22.scope_busy.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 2]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 4]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 51]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 201]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.mid.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.mid.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.mid.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.mid.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.deep.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.deep.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.deep.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.deep.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.at50.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.at50.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.at50.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.at50.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 2]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 2]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 4]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 4]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 51]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 51]} + expect: {bysc: identical} + - id: ch.list22.scope_busy.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 201]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 201]} + expect: {bysc: identical} + - id: ch.list22.scope_absent.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 0, 2]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 9223372036854775807, 2]} + expect: {bysc: identical} + - id: ch.list22.scope_absent.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 0, 4]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 9223372036854775807, 4]} + expect: {bysc: identical} + - id: ch.list22.scope_absent.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 0, 51]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 9223372036854775807, 51]} + expect: {bysc: identical} + - id: ch.list22.scope_absent.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 0, 201]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 9223372036854775807, 201]} + expect: {bysc: identical} + - id: ch.list22.scope_absent.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 3000000000, 2]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 3000000000, 2]} + expect: {bysc: identical} + - id: ch.list22.scope_absent.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 3000000000, 4]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 3000000000, 4]} + expect: {bysc: identical} + - id: ch.list22.scope_absent.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 3000000000, 51]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 3000000000, 51]} + expect: {bysc: identical} + - id: ch.list22.scope_absent.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 3000000000, 201]} + cands: + - {stmt: bysc, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, {sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 3000000000, 201]} + expect: {bysc: identical} + - id: ch.scope_busy.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {plainsc: identical} + - id: ch.scope_busy.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {plainsc: identical} + - id: ch.scope_busy.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {plainsc: identical} + - id: ch.scope_busy.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {plainsc: identical} + - id: ch.scope_busy.mid.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {plainsc: identical} + - id: ch.scope_busy.mid.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {plainsc: identical} + - id: ch.scope_busy.mid.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {plainsc: identical} + - id: ch.scope_busy.mid.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {plainsc: identical} + - id: ch.scope_busy.deep.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {plainsc: identical} + - id: ch.scope_busy.deep.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {plainsc: identical} + - id: ch.scope_busy.deep.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {plainsc: identical} + - id: ch.scope_busy.deep.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {plainsc: identical} + - id: ch.scope_busy.at50.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {plainsc: identical} + - id: ch.scope_busy.at50.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {plainsc: identical} + - id: ch.scope_busy.at50.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {plainsc: identical} + - id: ch.scope_busy.at50.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {plainsc: identical} + - id: ch.scope_busy.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 2]} + expect: {plainsc: identical} + - id: ch.scope_busy.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 4]} + expect: {plainsc: identical} + - id: ch.scope_busy.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 51]} + expect: {plainsc: identical} + - id: ch.scope_busy.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 201]} + expect: {plainsc: identical} + - id: ch.scope_second.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 0, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {plainsc: identical} + - id: ch.scope_second.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 0, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {plainsc: identical} + - id: ch.scope_second.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 0, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {plainsc: identical} + - id: ch.scope_second.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 0, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {plainsc: identical} + - id: ch.scope_second.mid.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {plainsc: identical} + - id: ch.scope_second.mid.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {plainsc: identical} + - id: ch.scope_second.mid.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {plainsc: identical} + - id: ch.scope_second.mid.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {plainsc: identical} + - id: ch.scope_second.deep.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {plainsc: identical} + - id: ch.scope_second.deep.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {plainsc: identical} + - id: ch.scope_second.deep.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {plainsc: identical} + - id: ch.scope_second.deep.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {plainsc: identical} + - id: ch.scope_second.at50.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {plainsc: identical} + - id: ch.scope_second.at50.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {plainsc: identical} + - id: ch.scope_second.at50.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {plainsc: identical} + - id: ch.scope_second.at50.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {plainsc: identical} + - id: ch.scope_second.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 3000000000, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 2]} + expect: {plainsc: identical} + - id: ch.scope_second.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 3000000000, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 4]} + expect: {plainsc: identical} + - id: ch.scope_second.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 3000000000, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 51]} + expect: {plainsc: identical} + - id: ch.scope_second.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 3000000000, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 201]} + expect: {plainsc: identical} + - id: ch.scope_rare.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1))"}, 0, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {plainsc: identical} + - id: ch.scope_rare.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1))"}, 0, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {plainsc: identical} + - id: ch.scope_rare.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1))"}, 0, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {plainsc: identical} + - id: ch.scope_rare.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1))"}, 0, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {plainsc: identical} + - id: ch.scope_rare.mid.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {plainsc: identical} + - id: ch.scope_rare.mid.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {plainsc: identical} + - id: ch.scope_rare.mid.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {plainsc: identical} + - id: ch.scope_rare.mid.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {plainsc: identical} + - id: ch.scope_rare.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1))"}, 3000000000, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1)"}, 3000000000, 2]} + expect: {plainsc: identical} + - id: ch.scope_rare.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1))"}, 3000000000, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1)"}, 3000000000, 4]} + expect: {plainsc: identical} + - id: ch.scope_rare.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1))"}, 3000000000, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1)"}, 3000000000, 51]} + expect: {plainsc: identical} + - id: ch.scope_rare.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1))"}, 3000000000, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*), 1 LIMIT 1)"}, 3000000000, 201]} + expect: {plainsc: identical} + - id: ch.scope_absent.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 0, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 9223372036854775807, 2]} + expect: {plainsc: identical} + - id: ch.scope_absent.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 0, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 9223372036854775807, 4]} + expect: {plainsc: identical} + - id: ch.scope_absent.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 0, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 9223372036854775807, 51]} + expect: {plainsc: identical} + - id: ch.scope_absent.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 0, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 9223372036854775807, 201]} + expect: {plainsc: identical} + - id: ch.scope_absent.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 3000000000, 2]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 3000000000, 2]} + expect: {plainsc: identical} + - id: ch.scope_absent.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 3000000000, 4]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 3000000000, 4]} + expect: {plainsc: identical} + - id: ch.scope_absent.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 3000000000, 51]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 3000000000, 51]} + expect: {plainsc: identical} + - id: ch.scope_absent.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 3000000000, 201]} + cands: + - {stmt: plainsc, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 3000000000, 201]} + expect: {plainsc: identical} + - id: ch.plain.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", 0, 2]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {plain: identical} + - id: ch.plain.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", 0, 4]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {plain: identical} + - id: ch.plain.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", 0, 51]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {plain: identical} + - id: ch.plain.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", 0, 201]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {plain: identical} + - id: ch.plain.mid.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + expect: {plain: identical} + - id: ch.plain.mid.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + expect: {plain: identical} + - id: ch.plain.mid.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + expect: {plain: identical} + - id: ch.plain.mid.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + expect: {plain: identical} + - id: ch.plain.deep.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + expect: {plain: identical} + - id: ch.plain.deep.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + expect: {plain: identical} + - id: ch.plain.deep.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + expect: {plain: identical} + - id: ch.plain.deep.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + expect: {plain: identical} + - id: ch.plain.at50.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {plain: identical} + - id: ch.plain.at50.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {plain: identical} + - id: ch.plain.at50.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {plain: identical} + - id: ch.plain.at50.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {plain: identical} + - id: ch.plain.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", 3000000000, 2]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 2]} + expect: {plain: identical} + - id: ch.plain.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", 3000000000, 4]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 4]} + expect: {plain: identical} + - id: ch.plain.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", 3000000000, 51]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 51]} + expect: {plain: identical} + - id: ch.plain.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, null, null, "", 3000000000, 201]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, 3000000000, 201]} + expect: {plain: identical} + - id: ch2.plain.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", 0, 2]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {plain: identical} + - id: ch2.plain.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", 0, 4]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {plain: identical} + - id: ch2.plain.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", 0, 51]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {plain: identical} + - id: ch2.plain.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", 0, 201]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {plain: identical} + - id: ch2.plain.mid.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + expect: {plain: identical} + - id: ch2.plain.mid.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + expect: {plain: identical} + - id: ch2.plain.mid.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + expect: {plain: identical} + - id: ch2.plain.mid.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + expect: {plain: identical} + - id: ch2.plain.deep.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + expect: {plain: identical} + - id: ch2.plain.deep.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + expect: {plain: identical} + - id: ch2.plain.deep.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + expect: {plain: identical} + - id: ch2.plain.deep.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + expect: {plain: identical} + - id: ch2.plain.at50.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {plain: identical} + - id: ch2.plain.at50.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {plain: identical} + - id: ch2.plain.at50.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {plain: identical} + - id: ch2.plain.at50.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {plain: identical} + - id: ch2.plain.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", 3000000000, 2]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 2]} + expect: {plain: identical} + - id: ch2.plain.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", 3000000000, 4]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 4]} + expect: {plain: identical} + - id: ch2.plain.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", 3000000000, 51]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 51]} + expect: {plain: identical} + - id: ch2.plain.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, null, null, "", 3000000000, 201]} + cands: + - {stmt: plain, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 201]} + expect: {plain: identical} + - id: ch.since3d.site.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 2]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, 9223372036854775807, 2]} + expect: {walk: identical} + - id: ch.since3d.site.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 4]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, 9223372036854775807, 4]} + expect: {walk: identical} + - id: ch.since3d.site.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 51]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, 9223372036854775807, 51]} + expect: {walk: identical} + - id: ch.since3d.site.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 201]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, 9223372036854775807, 201]} + expect: {walk: identical} + - id: ch.since3d.site.mid.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + expect: {walk: identical} + - id: ch.since3d.site.mid.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + expect: {walk: identical} + - id: ch.since3d.site.mid.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + expect: {walk: identical} + - id: ch.since3d.site.mid.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + expect: {walk: identical} + - id: ch.since3d.site.deep.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + expect: {walk: identical} + - id: ch.since3d.site.deep.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + expect: {walk: identical} + - id: ch.since3d.site.deep.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + expect: {walk: identical} + - id: ch.since3d.site.deep.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + expect: {walk: identical} + - id: ch.since3d.site.at50.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {walk: identical} + - id: ch.since3d.site.at50.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {walk: identical} + - id: ch.since3d.site.at50.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {walk: identical} + - id: ch.since3d.site.at50.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {walk: identical} + - id: ch.since3d.site.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 2]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, 3000000000, 2]} + expect: {walk: identical} + - id: ch.since3d.site.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 4]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, 3000000000, 4]} + expect: {walk: identical} + - id: ch.since3d.site.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 51]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, 3000000000, 51]} + expect: {walk: identical} + - id: ch.since3d.site.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 201]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '3 days' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, null, 3000000000, 201]} + expect: {walk: identical} + - id: ch.since10h.c0.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 0, 2]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, 9223372036854775807, 2]} + expect: {walk: identical} + - id: ch.since10h.c0.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 0, 4]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, 9223372036854775807, 4]} + expect: {walk: identical} + - id: ch.since10h.c0.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 0, 51]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, 9223372036854775807, 51]} + expect: {walk: identical} + - id: ch.since10h.c0.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 0, 201]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, 9223372036854775807, 201]} + expect: {walk: identical} + - id: ch.since10h.mid.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + expect: {walk: identical} + - id: ch.since10h.mid.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + expect: {walk: identical} + - id: ch.since10h.mid.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + expect: {walk: identical} + - id: ch.since10h.mid.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + expect: {walk: identical} + - id: ch.since10h.deep.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 2]} + expect: {walk: identical} + - id: ch.since10h.deep.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 4]} + expect: {walk: identical} + - id: ch.since10h.deep.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 51]} + expect: {walk: identical} + - id: ch.since10h.deep.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s)"}, 201]} + expect: {walk: identical} + - id: ch.since10h.at50.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {walk: identical} + - id: ch.since10h.at50.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {walk: identical} + - id: ch.since10h.at50.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {walk: identical} + - id: ch.since10h.at50.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages WHERE channel_id = (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1) ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {walk: identical} + - id: ch.since10h.c3e9.l2 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 3000000000, 2]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, 3000000000, 2]} + expect: {walk: identical} + - id: ch.since10h.c3e9.l4 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 3000000000, 4]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, 3000000000, 4]} + expect: {walk: identical} + - id: ch.since10h.c3e9.l51 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 3000000000, 51]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, 3000000000, 51]} + expect: {walk: identical} + - id: ch.since10h.c3e9.l201 + ref: {stmt: old, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 3000000000, 201]} + cands: + - {stmt: walk, params: [{sql: "SELECT (SELECT channel_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 1)"}, {sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, "{}", null, 3000000000, 201]} + expect: {walk: identical} + - id: all.site.c0.l2 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 2]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, 9223372036854775807, 2]} + expect: {aby: identical} + - id: all.site.c0.l4 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 4]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, 9223372036854775807, 4]} + expect: {aby: identical} + - id: all.site.c0.l51 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 51]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, 9223372036854775807, 51]} + expect: {aby: identical} + - id: all.site.c0.l201 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 0, 201]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, 9223372036854775807, 201]} + expect: {aby: identical} + - id: all.site.mid.l2 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {aby: identical} + - id: all.site.mid.l4 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {aby: identical} + - id: all.site.mid.l51 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {aby: identical} + - id: all.site.mid.l201 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {aby: identical} + - id: all.site.deep.l2 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {aby: identical} + - id: all.site.deep.l4 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {aby: identical} + - id: all.site.deep.l51 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {aby: identical} + - id: all.site.deep.l201 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {aby: identical} + - id: all.site.at50.l2 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {aby: identical} + - id: all.site.at50.l4 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {aby: identical} + - id: all.site.at50.l51 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {aby: identical} + - id: all.site.at50.l201 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE iata = (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {aby: identical} + - id: all.site.c3e9.l2 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 2]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, 3000000000, 2]} + expect: {aby: identical} + - id: all.site.c3e9.l4 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 4]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, 3000000000, 4]} + expect: {aby: identical} + - id: all.site.c3e9.l51 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 51]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, 3000000000, 51]} + expect: {aby: identical} + - id: all.site.c3e9.l201 + ref: {stmt: oldall, params: [null, {sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, "", 3000000000, 201]} + cands: + - {stmt: aby, params: [{sql: "SELECT ARRAY[(SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)]::bpchar[]"}, 3000000000, 201]} + expect: {aby: identical} + - id: all.list22.c0.l2 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 0, 2]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, 9223372036854775807, 2]} + expect: {aby: identical} + - id: all.list22.c0.l4 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 0, 4]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, 9223372036854775807, 4]} + expect: {aby: identical} + - id: all.list22.c0.l51 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 0, 51]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, 9223372036854775807, 51]} + expect: {aby: identical} + - id: all.list22.c0.l201 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 0, 201]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, 9223372036854775807, 201]} + expect: {aby: identical} + - id: all.list22.c3e9.l2 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 3000000000, 2]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, 3000000000, 2]} + expect: {aby: identical} + - id: all.list22.c3e9.l4 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 3000000000, 4]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, 3000000000, 4]} + expect: {aby: identical} + - id: all.list22.c3e9.l51 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 3000000000, 51]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, 3000000000, 51]} + expect: {aby: identical} + - id: all.list22.c3e9.l201 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, "", 3000000000, 201]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM (SELECT iata FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 0 LIMIT 22) s)"}, 3000000000, 201]} + expect: {aby: identical} + - id: all.codes.c0.l2 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 0, 2]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, 9223372036854775807, 2]} + expect: {aby: identical} + - id: all.codes.c0.l4 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 0, 4]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, 9223372036854775807, 4]} + expect: {aby: identical} + - id: all.codes.c0.l51 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 0, 51]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, 9223372036854775807, 51]} + expect: {aby: identical} + - id: all.codes.c0.l201 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 0, 201]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, 9223372036854775807, 201]} + expect: {aby: identical} + - id: all.codes.c3e9.l2 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 3000000000, 2]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, 3000000000, 2]} + expect: {aby: identical} + - id: all.codes.c3e9.l4 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 3000000000, 4]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, 3000000000, 4]} + expect: {aby: identical} + - id: all.codes.c3e9.l51 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 3000000000, 51]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, 3000000000, 51]} + expect: {aby: identical} + - id: all.codes.c3e9.l201 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, "", 3000000000, 201]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(iata ORDER BY iata)::bpchar[] FROM iata_codes)"}, 3000000000, 201]} + expect: {aby: identical} + - id: all.bogus5000.c0.l2 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 0, 2]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, 9223372036854775807, 2]} + expect: {aby: identical} + - id: all.bogus5000.c0.l4 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 0, 4]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, 9223372036854775807, 4]} + expect: {aby: identical} + - id: all.bogus5000.c0.l51 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 0, 51]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, 9223372036854775807, 51]} + expect: {aby: identical} + - id: all.bogus5000.c0.l201 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 0, 201]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, 9223372036854775807, 201]} + expect: {aby: identical} + - id: all.bogus5000.c3e9.l2 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 3000000000, 2]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, 3000000000, 2]} + expect: {aby: identical} + - id: all.bogus5000.c3e9.l4 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 3000000000, 4]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, 3000000000, 4]} + expect: {aby: identical} + - id: all.bogus5000.c3e9.l51 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 3000000000, 51]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, 3000000000, 51]} + expect: {aby: identical} + - id: all.bogus5000.c3e9.l201 + ref: {stmt: oldall, params: [null, {sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, "", 3000000000, 201]} + cands: + - {stmt: aby, params: [{sql: "SELECT (SELECT array_agg(c ORDER BY c)::bpchar[] FROM (SELECT c FROM (SELECT chr(65 + a) || chr(65 + b) || chr(65 + d) c FROM generate_series(0, 25) a, generate_series(0, 25) b, generate_series(0, 25) d) g WHERE c NOT IN (SELECT iata FROM iata_codes) ORDER BY c LIMIT 5000) s)"}, 3000000000, 201]} + expect: {aby: identical} + - id: all.scope_busy.c0.l2 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 2]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {aplainsc: identical} + - id: all.scope_busy.c0.l4 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 4]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {aplainsc: identical} + - id: all.scope_busy.c0.l51 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 51]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {aplainsc: identical} + - id: all.scope_busy.c0.l201 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 201]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {aplainsc: identical} + - id: all.scope_busy.mid.l2 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {aplainsc: identical} + - id: all.scope_busy.mid.l4 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {aplainsc: identical} + - id: all.scope_busy.mid.l51 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {aplainsc: identical} + - id: all.scope_busy.mid.l201 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {aplainsc: identical} + - id: all.scope_busy.deep.l2 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {aplainsc: identical} + - id: all.scope_busy.deep.l4 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {aplainsc: identical} + - id: all.scope_busy.deep.l51 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {aplainsc: identical} + - id: all.scope_busy.deep.l201 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {aplainsc: identical} + - id: all.scope_busy.at50.l2 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {aplainsc: identical} + - id: all.scope_busy.at50.l4 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {aplainsc: identical} + - id: all.scope_busy.at50.l51 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {aplainsc: identical} + - id: all.scope_busy.at50.l201 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {aplainsc: identical} + - id: all.scope_busy.c3e9.l2 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 2]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 2]} + expect: {aplainsc: identical} + - id: all.scope_busy.c3e9.l4 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 4]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 4]} + expect: {aplainsc: identical} + - id: all.scope_busy.c3e9.l51 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 51]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 51]} + expect: {aplainsc: identical} + - id: all.scope_busy.c3e9.l201 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 201]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 201]} + expect: {aplainsc: identical} + - id: all.scope_second.c0.l2 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 0, 2]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {aplainsc: identical} + - id: all.scope_second.c0.l4 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 0, 4]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {aplainsc: identical} + - id: all.scope_second.c0.l51 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 0, 51]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {aplainsc: identical} + - id: all.scope_second.c0.l201 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 0, 201]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {aplainsc: identical} + - id: all.scope_second.mid.l2 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {aplainsc: identical} + - id: all.scope_second.mid.l4 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {aplainsc: identical} + - id: all.scope_second.mid.l51 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {aplainsc: identical} + - id: all.scope_second.mid.l201 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {aplainsc: identical} + - id: all.scope_second.deep.l2 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 2]} + expect: {aplainsc: identical} + - id: all.scope_second.deep.l4 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 4]} + expect: {aplainsc: identical} + - id: all.scope_second.deep.l51 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 51]} + expect: {aplainsc: identical} + - id: all.scope_second.deep.l201 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY message_id) FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s)"}, 201]} + expect: {aplainsc: identical} + - id: all.scope_second.at50.l2 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {aplainsc: identical} + - id: all.scope_second.at50.l4 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {aplainsc: identical} + - id: all.scope_second.at50.l51 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {aplainsc: identical} + - id: all.scope_second.at50.l201 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, {sql: "SELECT (SELECT message_id FROM (SELECT message_id FROM channel_message_iatas WHERE scope_id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1) ORDER BY message_id DESC LIMIT 5000) s ORDER BY message_id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {aplainsc: identical} + - id: all.scope_second.c3e9.l2 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 3000000000, 2]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 2]} + expect: {aplainsc: identical} + - id: all.scope_second.c3e9.l4 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 3000000000, 4]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 4]} + expect: {aplainsc: identical} + - id: all.scope_second.c3e9.l51 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 3000000000, 51]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 51]} + expect: {aplainsc: identical} + - id: all.scope_second.c3e9.l201 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1))"}, 3000000000, 201]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 OFFSET 1 LIMIT 1)"}, 3000000000, 201]} + expect: {aplainsc: identical} + - id: all.scope_absent.c0.l2 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 0, 2]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 9223372036854775807, 2]} + expect: {aplainsc: identical} + - id: all.scope_absent.c0.l4 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 0, 4]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 9223372036854775807, 4]} + expect: {aplainsc: identical} + - id: all.scope_absent.c0.l51 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 0, 51]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 9223372036854775807, 51]} + expect: {aplainsc: identical} + - id: all.scope_absent.c0.l201 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 0, 201]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 9223372036854775807, 201]} + expect: {aplainsc: identical} + - id: all.scope_absent.c3e9.l2 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 3000000000, 2]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 3000000000, 2]} + expect: {aplainsc: identical} + - id: all.scope_absent.c3e9.l4 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 3000000000, 4]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 3000000000, 4]} + expect: {aplainsc: identical} + - id: all.scope_absent.c3e9.l51 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 3000000000, 51]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 3000000000, 51]} + expect: {aplainsc: identical} + - id: all.scope_absent.c3e9.l201 + ref: {stmt: oldall, params: [null, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1))"}, 3000000000, 201]} + cands: + - {stmt: aplainsc, params: [{sql: "SELECT (SELECT ts.id FROM transport_scopes ts WHERE NOT EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.scope_id = ts.id) ORDER BY ts.id LIMIT 1)"}, 3000000000, 201]} + expect: {aplainsc: identical} + - id: all.plain.c0.l2 + ref: {stmt: oldall, params: [null, null, "", 0, 2]} + cands: + - {stmt: aplain, params: [9223372036854775807, 2]} + expect: {aplain: identical} + - id: all.plain.c0.l4 + ref: {stmt: oldall, params: [null, null, "", 0, 4]} + cands: + - {stmt: aplain, params: [9223372036854775807, 4]} + expect: {aplain: identical} + - id: all.plain.c0.l51 + ref: {stmt: oldall, params: [null, null, "", 0, 51]} + cands: + - {stmt: aplain, params: [9223372036854775807, 51]} + expect: {aplain: identical} + - id: all.plain.c0.l201 + ref: {stmt: oldall, params: [null, null, "", 0, 201]} + cands: + - {stmt: aplain, params: [9223372036854775807, 201]} + expect: {aplain: identical} + - id: all.plain.mid.l2 + ref: {stmt: oldall, params: [null, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: aplain, params: [{sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 2]} + expect: {aplain: identical} + - id: all.plain.mid.l4 + ref: {stmt: oldall, params: [null, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: aplain, params: [{sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 4]} + expect: {aplain: identical} + - id: all.plain.mid.l51 + ref: {stmt: oldall, params: [null, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: aplain, params: [{sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 51]} + expect: {aplain: identical} + - id: all.plain.mid.l201 + ref: {stmt: oldall, params: [null, null, "", {sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: aplain, params: [{sql: "SELECT (SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 201]} + expect: {aplain: identical} + - id: all.plain.deep.l2 + ref: {stmt: oldall, params: [null, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 2]} + cands: + - {stmt: aplain, params: [{sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 2]} + expect: {aplain: identical} + - id: all.plain.deep.l4 + ref: {stmt: oldall, params: [null, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 4]} + cands: + - {stmt: aplain, params: [{sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 4]} + expect: {aplain: identical} + - id: all.plain.deep.l51 + ref: {stmt: oldall, params: [null, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 51]} + cands: + - {stmt: aplain, params: [{sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 51]} + expect: {aplain: identical} + - id: all.plain.deep.l201 + ref: {stmt: oldall, params: [null, null, "", {sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 201]} + cands: + - {stmt: aplain, params: [{sql: "SELECT (SELECT percentile_disc(0.1) WITHIN GROUP (ORDER BY id) FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s)"}, 201]} + expect: {aplain: identical} + - id: all.plain.at50.l2 + ref: {stmt: oldall, params: [null, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 2]} + cands: + - {stmt: aplain, params: [{sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 2]} + expect: {aplain: identical} + - id: all.plain.at50.l4 + ref: {stmt: oldall, params: [null, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 4]} + cands: + - {stmt: aplain, params: [{sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 4]} + expect: {aplain: identical} + - id: all.plain.at50.l51 + ref: {stmt: oldall, params: [null, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 51]} + cands: + - {stmt: aplain, params: [{sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 51]} + expect: {aplain: identical} + - id: all.plain.at50.l201 + ref: {stmt: oldall, params: [null, null, "", {sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 201]} + cands: + - {stmt: aplain, params: [{sql: "SELECT (SELECT id FROM (SELECT id FROM channel_messages ORDER BY id DESC LIMIT 5000) s ORDER BY id DESC OFFSET 49 LIMIT 1)"}, 201]} + expect: {aplain: identical} + - id: all.plain.c3e9.l2 + ref: {stmt: oldall, params: [null, null, "", 3000000000, 2]} + cands: + - {stmt: aplain, params: [3000000000, 2]} + expect: {aplain: identical} + - id: all.plain.c3e9.l4 + ref: {stmt: oldall, params: [null, null, "", 3000000000, 4]} + cands: + - {stmt: aplain, params: [3000000000, 4]} + expect: {aplain: identical} + - id: all.plain.c3e9.l51 + ref: {stmt: oldall, params: [null, null, "", 3000000000, 51]} + cands: + - {stmt: aplain, params: [3000000000, 51]} + expect: {aplain: identical} + - id: all.plain.c3e9.l201 + ref: {stmt: oldall, params: [null, null, "", 3000000000, 201]} + cands: + - {stmt: aplain, params: [3000000000, 201]} + expect: {aplain: identical} + - id: all.since10h.c0.l2 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 0, 2]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, 9223372036854775807, 2]} + expect: {asince: identical} + - id: all.since10h.c0.l4 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 0, 4]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, 9223372036854775807, 4]} + expect: {asince: identical} + - id: all.since10h.c0.l51 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 0, 51]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, 9223372036854775807, 51]} + expect: {asince: identical} + - id: all.since10h.c0.l201 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 0, 201]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, 9223372036854775807, 201]} + expect: {asince: identical} + - id: all.since10h.c3e9.l2 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 3000000000, 2]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, 3000000000, 2]} + expect: {asince: identical} + - id: all.since10h.c3e9.l4 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 3000000000, 4]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, 3000000000, 4]} + expect: {asince: identical} + - id: all.since10h.c3e9.l51 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 3000000000, 51]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, 3000000000, 51]} + expect: {asince: identical} + - id: all.since10h.c3e9.l201 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, "", 3000000000, 201]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, 3000000000, 201]} + expect: {asince: identical} + - id: all.since10h.scope.c0.l2 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 2]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 2]} + expect: {asince: identical} + - id: all.since10h.scope.c0.l4 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 4]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 4]} + expect: {asince: identical} + - id: all.since10h.scope.c0.l51 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 51]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 51]} + expect: {asince: identical} + - id: all.since10h.scope.c0.l201 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 0, 201]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 9223372036854775807, 201]} + expect: {asince: identical} + - id: all.since10h.scope.c3e9.l2 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 2]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 2]} + expect: {asince: identical} + - id: all.since10h.scope.c3e9.l4 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 4]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 4]} + expect: {asince: identical} + - id: all.since10h.scope.c3e9.l51 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 51]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 51]} + expect: {asince: identical} + - id: all.since10h.scope.c3e9.l201 + ref: {stmt: oldall, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, null, {sql: "SELECT (SELECT name FROM transport_scopes WHERE id = (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1))"}, 3000000000, 201]} + cands: + - {stmt: asince, params: [{sql: "SELECT (SELECT sent_at - interval '10 hours' FROM channel_messages ORDER BY id DESC LIMIT 1)"}, {sql: "SELECT (SELECT scope_id FROM channel_message_iatas WHERE message_id > (SELECT coalesce((SELECT message_id FROM channel_message_iatas ORDER BY message_id DESC OFFSET 20000 LIMIT 1), 0)) AND scope_id IS NOT NULL GROUP BY 1 ORDER BY count(*) DESC, 1 LIMIT 1)"}, 3000000000, 201]} + expect: {asince: identical} diff --git a/db/planguard/fixture/65_channel_message_iatas.sql b/db/planguard/fixture/65_channel_message_iatas.sql new file mode 100644 index 0000000..6f197be --- /dev/null +++ b/db/planguard/fixture/65_channel_message_iatas.sql @@ -0,0 +1,10 @@ +-- Copyright 2026 Beacon Contributors +-- SPDX-License-Identifier: AGPL-3.0-or-later + +-- Fixture step 65: channel_message_iatas, as the backfill fills it: one row per message and site that heard it. +INSERT INTO channel_message_iatas (message_id, iata, channel_id, scope_id) +SELECT DISTINCT cm.id, po.iata, cm.channel_id, p.scope_id +FROM channel_messages cm +JOIN packets p ON p.packet_hash = cm.packet_hash +JOIN packet_observations po ON po.packet_hash = cm.packet_hash +ORDER BY cm.id, po.iata; diff --git a/db/planguard/fixture/90_stale_region.sql b/db/planguard/fixture/90_stale_region.sql index 9fd301d..90b87e7 100644 --- a/db/planguard/fixture/90_stale_region.sql +++ b/db/planguard/fixture/90_stale_region.sql @@ -32,3 +32,13 @@ FROM planguard_src.new0 n JOIN planguard_src.new_paths p ON p.rid = n.rid ORDER BY decode(md5('new-route' || n.rid), 'hex'); SELECT setval('known_routes_new_id_seq', (SELECT max(id) FROM known_routes)); DROP TABLE planguard_src.new0, planguard_src.new_paths; + +-- The stale site for channel messages: NEW heard every 20th of the newest 4,000 messages after the last ANALYZE, +-- so channel_message_iatas' statistics still estimate it at one row. +ALTER TABLE channel_message_iatas SET (autovacuum_enabled = false); +INSERT INTO channel_message_iatas (message_id, iata, channel_id, scope_id) +SELECT cm.id, 'NEW', cm.channel_id, p.scope_id +FROM (SELECT id, channel_id, packet_hash, row_number() OVER (ORDER BY id DESC) rn FROM channel_messages ORDER BY id DESC LIMIT 4000) cm +JOIN packets p ON p.packet_hash = cm.packet_hash +WHERE cm.rn % 20 = 0 +ORDER BY cm.id; diff --git a/db/planguard/overlay/channel_message_iatas.sql b/db/planguard/overlay/channel_message_iatas.sql new file mode 100644 index 0000000..85eedfb --- /dev/null +++ b/db/planguard/overlay/channel_message_iatas.sql @@ -0,0 +1,73 @@ +-- Copyright 2026 Beacon Contributors +-- SPDX-License-Identifier: AGPL-3.0-or-later + +-- Overlay for the local-copy tier of the channel_message_iatas group, diff/channel_message_iatas.yaml and +-- storediff/channel_message_iatas.yaml: it builds t_s4a; it never writes public. It holds +-- t_s4a.channel_messages a copy of public's in its physical order, with every index public has plus +-- idx_channel_messages_channel_id, checked equal to public both ways; +-- t_s4a.channel_message_iatas the migrations' table and indexes, foreign key to the copy, filled as the +-- backfill fills it; +-- t_s4a.background_state only the cmi state, complete and verified, so a read-only server trusts the copy. +-- Statements run with search_path "t_s4a, public", so these three resolve here and every other table to public. +-- VACUUM ANALYZE runs twice: a snapshot still open during the first leaves the visibility map unset. +-- +-- The group's resolvers read channel_message_iatas too, and resolvers run on the run's base search_path, so run its +-- local tier with that path: +-- planguard run --tier local --only '^cmi[.]' --search-path 't_s4a, public' --dsn ... +-- +-- Local copy only. Remove it with +-- DROP SCHEMA t_s4a CASCADE; +-- Run: psql "$DSN" -v ON_ERROR_STOP=1 -f db/planguard/overlay/channel_message_iatas.sql +\set ON_ERROR_STOP 1 +\timing on +SET maintenance_work_mem = '1GB'; +SET jit = off; +CREATE SCHEMA IF NOT EXISTS t_s4a; +DROP TABLE IF EXISTS t_s4a.channel_message_iatas, t_s4a.channel_messages, t_s4a.background_state; + +CREATE TABLE t_s4a.channel_messages (LIKE public.channel_messages INCLUDING DEFAULTS); +INSERT INTO t_s4a.channel_messages SELECT * FROM public.channel_messages; +ALTER TABLE t_s4a.channel_messages ADD CONSTRAINT channel_messages_pkey PRIMARY KEY (id); +ALTER TABLE t_s4a.channel_messages ADD CONSTRAINT channel_messages_packet_hash_key UNIQUE (packet_hash); +CREATE INDEX idx_channel_messages_channel ON t_s4a.channel_messages USING btree (channel_id, sent_at DESC); +CREATE INDEX idx_channel_messages_sent_brin ON t_s4a.channel_messages USING brin (sent_at); +CREATE INDEX idx_channel_messages_channel_id ON t_s4a.channel_messages USING btree (channel_id, id DESC); +DO $$ +BEGIN + IF EXISTS (SELECT * FROM t_s4a.channel_messages EXCEPT ALL SELECT * FROM public.channel_messages) + OR EXISTS (SELECT * FROM public.channel_messages EXCEPT ALL SELECT * FROM t_s4a.channel_messages) THEN + RAISE EXCEPTION 't_s4a.channel_messages differs from public.channel_messages'; + END IF; +END $$; + +CREATE TABLE t_s4a.channel_message_iatas ( + message_id bigint NOT NULL REFERENCES t_s4a.channel_messages(id) ON DELETE CASCADE, + iata character(3) NOT NULL, + channel_id integer NOT NULL, + scope_id integer, + PRIMARY KEY (message_id, iata) +); +INSERT INTO t_s4a.channel_message_iatas (message_id, iata, channel_id, scope_id) +SELECT DISTINCT cm.id, po.iata, cm.channel_id, p.scope_id +FROM t_s4a.channel_messages cm +JOIN public.packets p ON p.packet_hash = cm.packet_hash +JOIN public.packet_observations po ON po.packet_hash = cm.packet_hash; +CREATE INDEX idx_cmi_channel_site ON t_s4a.channel_message_iatas USING btree (channel_id, iata, message_id DESC); +CREATE INDEX idx_cmi_site ON t_s4a.channel_message_iatas USING btree (iata, message_id DESC); +CREATE INDEX idx_cmi_channel_site_scope ON t_s4a.channel_message_iatas USING btree (channel_id, iata, scope_id, message_id DESC) WHERE (scope_id IS NOT NULL); +CREATE INDEX idx_cmi_channel_scope ON t_s4a.channel_message_iatas USING btree (channel_id, scope_id, message_id DESC) WHERE (scope_id IS NOT NULL); +CREATE INDEX idx_cmi_scope ON t_s4a.channel_message_iatas USING btree (scope_id, message_id DESC) WHERE (scope_id IS NOT NULL); + +CREATE TABLE t_s4a.background_state (key text PRIMARY KEY, value jsonb NOT NULL, updated_at timestamptz NOT NULL DEFAULT now()); +INSERT INTO t_s4a.background_state (key, value) +SELECT 'cmi', jsonb_build_object('backfill_max_id', m.hi, 'backfilled_to_id', m.hi, 'complete', true, + 'obs_prev_hi', o.hi, 'obs_hi', o.hi, 'msg_prev_hi', m.hi, 'msg_hi', m.hi, + 'first_verified_at', to_char(now() AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS"Z"')) +FROM (SELECT coalesce(max(id), 0) hi FROM t_s4a.channel_messages) m, (SELECT coalesce(max(id), 0) hi FROM public.packet_observations) o; + +VACUUM ANALYZE t_s4a.channel_messages; +VACUUM ANALYZE t_s4a.channel_message_iatas; +VACUUM ANALYZE t_s4a.channel_messages; +VACUUM ANALYZE t_s4a.channel_message_iatas; +SELECT c.relname, pg_size_pretty(pg_total_relation_size(c.oid)) FROM pg_class c +WHERE c.relnamespace = 't_s4a'::regnamespace AND c.relkind = 'r' ORDER BY 1; diff --git a/db/planguard/sql/pending/AddChannelMessageIATA.sql b/db/planguard/sql/pending/AddChannelMessageIATA.sql deleted file mode 100644 index e30fe3b..0000000 --- a/db/planguard/sql/pending/AddChannelMessageIATA.sql +++ /dev/null @@ -1,9 +0,0 @@ --- Copyright 2026 Beacon Contributors --- SPDX-License-Identifier: AGPL-3.0-or-later - --- name: AddChannelMessageIATA :exec -INSERT INTO channel_message_iatas (message_id, iata, channel_id, scope_id) -SELECT cm.id, $1::bpchar, cm.channel_id, p.scope_id -FROM channel_messages cm JOIN packets p ON p.packet_hash = cm.packet_hash -WHERE cm.packet_hash = $2::bytea -ON CONFLICT (message_id, iata) DO NOTHING diff --git a/db/planguard/sql/pending/FillChannelMessageIATAsByMessages.sql b/db/planguard/sql/pending/FillChannelMessageIATAsByMessages.sql deleted file mode 100644 index 21911ae..0000000 --- a/db/planguard/sql/pending/FillChannelMessageIATAsByMessages.sql +++ /dev/null @@ -1,11 +0,0 @@ --- Copyright 2026 Beacon Contributors --- SPDX-License-Identifier: AGPL-3.0-or-later - --- name: FillChannelMessageIATAsByMessages :execrows -INSERT INTO channel_message_iatas (message_id, iata, channel_id, scope_id) -SELECT DISTINCT cm.id, po.iata, cm.channel_id, p.scope_id -FROM channel_messages cm -JOIN packets p USING (packet_hash) -JOIN packet_observations po USING (packet_hash) -WHERE cm.id > $1::bigint AND cm.id <= $2::bigint -ON CONFLICT DO NOTHING diff --git a/db/planguard/sql/pending/ListAllChannelMessagesByIATAs.sql b/db/planguard/sql/pending/ListAllChannelMessagesByIATAs.sql deleted file mode 100644 index 67f195c..0000000 --- a/db/planguard/sql/pending/ListAllChannelMessagesByIATAs.sql +++ /dev/null @@ -1,24 +0,0 @@ --- Copyright 2026 Beacon Contributors --- SPDX-License-Identifier: AGPL-3.0-or-later - --- name: ListAllChannelMessagesByIATAs :many -WITH hits AS MATERIALIZED ( - SELECT m.message_id - FROM unnest($1::bpchar[]) AS req(iata) - CROSS JOIN LATERAL ( - SELECT i.message_id FROM channel_message_iatas i - WHERE i.iata = req.iata - AND i.message_id < $2::bigint - ORDER BY i.message_id DESC - LIMIT $3) m - GROUP BY m.message_id - ORDER BY m.message_id DESC - LIMIT $3) -SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, - p.transport_codes_present, p.observation_count AS observation_count -FROM hits h -JOIN channel_messages cm ON cm.id = h.message_id -JOIN channels c ON c.id = cm.channel_id -JOIN packets p ON p.packet_hash = cm.packet_hash -LEFT JOIN transport_scopes ts ON ts.id = p.scope_id -ORDER BY cm.id DESC diff --git a/db/planguard/sql/pending/ListAllChannelMessagesByIATAsScoped.sql b/db/planguard/sql/pending/ListAllChannelMessagesByIATAsScoped.sql deleted file mode 100644 index 7d33c25..0000000 --- a/db/planguard/sql/pending/ListAllChannelMessagesByIATAsScoped.sql +++ /dev/null @@ -1,24 +0,0 @@ --- Copyright 2026 Beacon Contributors --- SPDX-License-Identifier: AGPL-3.0-or-later - --- name: ListAllChannelMessagesByIATAsScoped :many -WITH hits AS MATERIALIZED ( - SELECT m.message_id - FROM unnest($1::bpchar[]) AS req(iata) - CROSS JOIN LATERAL ( - SELECT i.message_id FROM channel_message_iatas i - WHERE i.iata = req.iata AND i.scope_id = $2::int - AND i.message_id < $3::bigint - ORDER BY i.message_id DESC - LIMIT $4) m - GROUP BY m.message_id - ORDER BY m.message_id DESC - LIMIT $4) -SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, - p.transport_codes_present, p.observation_count AS observation_count -FROM hits h -JOIN channel_messages cm ON cm.id = h.message_id -JOIN channels c ON c.id = cm.channel_id -JOIN packets p ON p.packet_hash = cm.packet_hash -LEFT JOIN transport_scopes ts ON ts.id = p.scope_id -ORDER BY cm.id DESC diff --git a/db/planguard/sql/pending/ListAllChannelMessagesByIATAsSince.sql b/db/planguard/sql/pending/ListAllChannelMessagesByIATAsSince.sql deleted file mode 100644 index 1828053..0000000 --- a/db/planguard/sql/pending/ListAllChannelMessagesByIATAsSince.sql +++ /dev/null @@ -1,27 +0,0 @@ --- Copyright 2026 Beacon Contributors --- SPDX-License-Identifier: AGPL-3.0-or-later - --- name: ListAllChannelMessagesByIATAsSince :many -WITH hits AS MATERIALIZED ( - SELECT m.message_id - FROM unnest($1::bpchar[]) AS req(iata) - CROSS JOIN LATERAL ( - SELECT i.message_id FROM channel_message_iatas i - JOIN channel_messages cm ON cm.id = i.message_id - WHERE i.iata = req.iata - AND i.message_id < $4::bigint - AND cm.sent_at >= $2::timestamptz - AND ($3::int IS NULL OR i.scope_id = $3::int) - ORDER BY i.message_id DESC - LIMIT $5) m - GROUP BY m.message_id - ORDER BY m.message_id DESC - LIMIT $5) -SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, - p.transport_codes_present, p.observation_count AS observation_count -FROM hits h -JOIN channel_messages cm ON cm.id = h.message_id -JOIN channels c ON c.id = cm.channel_id -JOIN packets p ON p.packet_hash = cm.packet_hash -LEFT JOIN transport_scopes ts ON ts.id = p.scope_id -ORDER BY cm.id DESC diff --git a/db/planguard/sql/pending/ListAllChannelMessagesPlain.sql b/db/planguard/sql/pending/ListAllChannelMessagesPlain.sql deleted file mode 100644 index e506a24..0000000 --- a/db/planguard/sql/pending/ListAllChannelMessagesPlain.sql +++ /dev/null @@ -1,14 +0,0 @@ --- Copyright 2026 Beacon Contributors --- SPDX-License-Identifier: AGPL-3.0-or-later - --- name: ListAllChannelMessagesPlain :many -SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, - p.transport_codes_present, p.observation_count AS observation_count -FROM channel_messages cm -JOIN channels c ON c.id = cm.channel_id -JOIN packets p ON p.packet_hash = cm.packet_hash -LEFT JOIN transport_scopes ts ON ts.id = p.scope_id -WHERE cm.id < $1::bigint - AND EXISTS (SELECT 1 FROM packet_observations po WHERE po.packet_hash = cm.packet_hash) -ORDER BY cm.id DESC -LIMIT $2 diff --git a/db/planguard/sql/pending/ListAllChannelMessagesPlainScoped.sql b/db/planguard/sql/pending/ListAllChannelMessagesPlainScoped.sql deleted file mode 100644 index 59b31ea..0000000 --- a/db/planguard/sql/pending/ListAllChannelMessagesPlainScoped.sql +++ /dev/null @@ -1,14 +0,0 @@ --- Copyright 2026 Beacon Contributors --- SPDX-License-Identifier: AGPL-3.0-or-later - --- name: ListAllChannelMessagesPlainScoped :many -SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, - p.transport_codes_present, p.observation_count AS observation_count -FROM channel_messages cm -JOIN channels c ON c.id = cm.channel_id -JOIN packets p ON p.packet_hash = cm.packet_hash -LEFT JOIN transport_scopes ts ON ts.id = p.scope_id -WHERE p.scope_id = $1::int AND cm.id < $2::bigint - AND EXISTS (SELECT 1 FROM packet_observations po WHERE po.packet_hash = cm.packet_hash) -ORDER BY cm.id DESC -LIMIT $3 diff --git a/db/planguard/sql/pending/ListAllChannelMessagesSince.sql b/db/planguard/sql/pending/ListAllChannelMessagesSince.sql deleted file mode 100644 index 36b18fe..0000000 --- a/db/planguard/sql/pending/ListAllChannelMessagesSince.sql +++ /dev/null @@ -1,16 +0,0 @@ --- Copyright 2026 Beacon Contributors --- SPDX-License-Identifier: AGPL-3.0-or-later - --- name: ListAllChannelMessagesSince :many -SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, - p.transport_codes_present, p.observation_count AS observation_count -FROM channel_messages cm -JOIN channels c ON c.id = cm.channel_id -JOIN packets p ON p.packet_hash = cm.packet_hash -LEFT JOIN transport_scopes ts ON ts.id = p.scope_id -WHERE cm.id < $3::bigint - AND cm.sent_at >= $1::timestamptz - AND ($2::int IS NULL OR p.scope_id = $2::int) - AND EXISTS (SELECT 1 FROM packet_observations po WHERE po.packet_hash = cm.packet_hash) -ORDER BY cm.id DESC -LIMIT $4 diff --git a/db/planguard/sql/pending/ListChannelMessagesByIATAs.sql b/db/planguard/sql/pending/ListChannelMessagesByIATAs.sql deleted file mode 100644 index a09437a..0000000 --- a/db/planguard/sql/pending/ListChannelMessagesByIATAs.sql +++ /dev/null @@ -1,24 +0,0 @@ --- Copyright 2026 Beacon Contributors --- SPDX-License-Identifier: AGPL-3.0-or-later - --- name: ListChannelMessagesByIATAs :many -WITH hits AS MATERIALIZED ( - SELECT m.message_id - FROM unnest($1::bpchar[]) AS req(iata) - CROSS JOIN LATERAL ( - SELECT i.message_id FROM channel_message_iatas i - WHERE i.channel_id = $2::int AND i.iata = req.iata - AND i.message_id < $3::bigint - ORDER BY i.message_id DESC - LIMIT $4) m - GROUP BY m.message_id - ORDER BY m.message_id DESC - LIMIT $4) -SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, - p.transport_codes_present, p.observation_count AS observation_count -FROM hits h -JOIN channel_messages cm ON cm.id = h.message_id -JOIN channels c ON c.id = cm.channel_id -JOIN packets p ON p.packet_hash = cm.packet_hash -LEFT JOIN transport_scopes ts ON ts.id = p.scope_id -ORDER BY cm.id DESC diff --git a/db/planguard/sql/pending/ListChannelMessagesByIATAsScoped.sql b/db/planguard/sql/pending/ListChannelMessagesByIATAsScoped.sql deleted file mode 100644 index 6d8fb9d..0000000 --- a/db/planguard/sql/pending/ListChannelMessagesByIATAsScoped.sql +++ /dev/null @@ -1,24 +0,0 @@ --- Copyright 2026 Beacon Contributors --- SPDX-License-Identifier: AGPL-3.0-or-later - --- name: ListChannelMessagesByIATAsScoped :many -WITH hits AS MATERIALIZED ( - SELECT m.message_id - FROM unnest($1::bpchar[]) AS req(iata) - CROSS JOIN LATERAL ( - SELECT i.message_id FROM channel_message_iatas i - WHERE i.channel_id = $2::int AND i.iata = req.iata AND i.scope_id = $3::int - AND i.message_id < $4::bigint - ORDER BY i.message_id DESC - LIMIT $5) m - GROUP BY m.message_id - ORDER BY m.message_id DESC - LIMIT $5) -SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, - p.transport_codes_present, p.observation_count AS observation_count -FROM hits h -JOIN channel_messages cm ON cm.id = h.message_id -JOIN channels c ON c.id = cm.channel_id -JOIN packets p ON p.packet_hash = cm.packet_hash -LEFT JOIN transport_scopes ts ON ts.id = p.scope_id -ORDER BY cm.id DESC diff --git a/db/planguard/sql/pending/ListChannelMessagesPlain.sql b/db/planguard/sql/pending/ListChannelMessagesPlain.sql deleted file mode 100644 index 58b0346..0000000 --- a/db/planguard/sql/pending/ListChannelMessagesPlain.sql +++ /dev/null @@ -1,14 +0,0 @@ --- Copyright 2026 Beacon Contributors --- SPDX-License-Identifier: AGPL-3.0-or-later - --- name: ListChannelMessagesPlain :many -SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, - p.transport_codes_present, p.observation_count AS observation_count -FROM channel_messages cm -JOIN channels c ON c.id = cm.channel_id -JOIN packets p ON p.packet_hash = cm.packet_hash -LEFT JOIN transport_scopes ts ON ts.id = p.scope_id -WHERE cm.channel_id = $1::int AND cm.id < $2::bigint - AND EXISTS (SELECT 1 FROM packet_observations po WHERE po.packet_hash = cm.packet_hash) -ORDER BY cm.id DESC -LIMIT $3 diff --git a/db/planguard/sql/pending/ListChannelMessagesPlainScoped.sql b/db/planguard/sql/pending/ListChannelMessagesPlainScoped.sql deleted file mode 100644 index d696441..0000000 --- a/db/planguard/sql/pending/ListChannelMessagesPlainScoped.sql +++ /dev/null @@ -1,18 +0,0 @@ --- Copyright 2026 Beacon Contributors --- SPDX-License-Identifier: AGPL-3.0-or-later - --- name: ListChannelMessagesPlainScoped :many -WITH hits AS MATERIALIZED ( - SELECT DISTINCT i.message_id - FROM channel_message_iatas i - WHERE i.channel_id = $1::int AND i.scope_id = $2::int AND i.message_id < $3::bigint - ORDER BY i.message_id DESC - LIMIT $4) -SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, - p.transport_codes_present, p.observation_count AS observation_count -FROM hits h -JOIN channel_messages cm ON cm.id = h.message_id -JOIN channels c ON c.id = cm.channel_id -JOIN packets p ON p.packet_hash = cm.packet_hash -LEFT JOIN transport_scopes ts ON ts.id = p.scope_id -ORDER BY cm.id DESC diff --git a/db/planguard/sql/pending/ListChannelMessagesSinceWalk.sql b/db/planguard/sql/pending/ListChannelMessagesSinceWalk.sql deleted file mode 100644 index 30f02b0..0000000 --- a/db/planguard/sql/pending/ListChannelMessagesSinceWalk.sql +++ /dev/null @@ -1,18 +0,0 @@ --- Copyright 2026 Beacon Contributors --- SPDX-License-Identifier: AGPL-3.0-or-later - --- name: ListChannelMessagesSinceWalk :many -SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, - p.transport_codes_present, p.observation_count AS observation_count -FROM channel_messages cm -JOIN channels c ON c.id = cm.channel_id -JOIN packets p ON p.packet_hash = cm.packet_hash -LEFT JOIN transport_scopes ts ON ts.id = p.scope_id -WHERE cm.channel_id = $1::int AND cm.id < $5::bigint - AND cm.sent_at >= $2::timestamptz - AND EXISTS (SELECT 1 FROM packet_observations po WHERE po.packet_hash = cm.packet_hash) - AND (COALESCE(cardinality($3::bpchar[]), 0) = 0 - OR EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.message_id = cm.id AND i.iata = ANY($3::bpchar[]))) - AND ($4::int IS NULL OR p.scope_id = $4::int) -ORDER BY cm.id DESC -LIMIT $6 diff --git a/db/planguard/storediff/channel_message_iatas.yaml b/db/planguard/storediff/channel_message_iatas.yaml new file mode 100644 index 0000000..ff0e514 --- /dev/null +++ b/db/planguard/storediff/channel_message_iatas.yaml @@ -0,0 +1,125 @@ +# Copyright 2026 Beacon Contributors +# SPDX-License-Identifier: AGPL-3.0-or-later + +# Channel message pages: two read-only servers on one database, walked page by page with the cursor a client +# follows and compared as whole JSON. Old is the build before the read model; new is this build, which trusts the +# overlay's table on a read-only server (its state is complete, verified and fresh, and the newest messages check +# clean). Both run with search_path "t_s4a, public" on the overlay overlay/channel_message_iatas.sql: +# +# planguard storediff --old http://127.0.0.1:8481 --new http://127.0.0.1:8482 \ +# --cases db/planguard/storediff/channel_message_iatas.yaml --walk 1,2,3,web +# +# No class is allowed: every page must be identical. Everything is read from the data: channels are the most recently +# heard one and the 50th (/api/v1/channels), sites are those of the most and the 50th most recently seen observer +# (/api/v1/observers), since is 10.2 hours before the newest message's sentAt. ZZZ is a code no site uses. Scope +# shapes are compared statement by statement in diff/channel_message_iatas.yaml, where scopes are picked by role. +cases: + - id: ch_first + path: /api/v1/channels/{ch}/messages + vars: + ch: {path: /api/v1/channels, from: first.id} + follow: &cursor + - {param: cursor, from: nextCursor} + - id: ch_first_site_a + path: /api/v1/channels/{ch}/messages + query: {iatas: "{a}"} + vars: + ch: {path: /api/v1/channels, from: first.id} + a: {path: /api/v1/observers, from: first.iata} + follow: *cursor + - id: ch_first_site_b + path: /api/v1/channels/{ch}/messages + query: {iatas: "{b}"} + vars: + ch: {path: /api/v1/channels, from: first.id} + b: {path: /api/v1/observers, from: last.iata} + follow: *cursor + - id: ch_first_sites_ab + path: /api/v1/channels/{ch}/messages + query: {iatas: "{a},{b}"} + vars: + ch: {path: /api/v1/channels, from: first.id} + a: {path: /api/v1/observers, from: first.iata} + b: {path: /api/v1/observers, from: last.iata} + follow: *cursor + - id: ch_first_zzz + path: /api/v1/channels/{ch}/messages + query: {iatas: "ZZZ"} + vars: + ch: {path: /api/v1/channels, from: first.id} + follow: *cursor + - id: ch_last + path: /api/v1/channels/{ch}/messages + vars: + ch: {path: /api/v1/channels, from: last.id} + follow: *cursor + - id: ch_last_site_a + path: /api/v1/channels/{ch}/messages + query: {iatas: "{a}"} + vars: + ch: {path: /api/v1/channels, from: last.id} + a: {path: /api/v1/observers, from: first.iata} + follow: *cursor + - id: ch_last_site_b + path: /api/v1/channels/{ch}/messages + query: {iatas: "{b}"} + vars: + ch: {path: /api/v1/channels, from: last.id} + b: {path: /api/v1/observers, from: last.iata} + follow: *cursor + - id: ch_last_sites_ab + path: /api/v1/channels/{ch}/messages + query: {iatas: "{a},{b}"} + vars: + ch: {path: /api/v1/channels, from: last.id} + a: {path: /api/v1/observers, from: first.iata} + b: {path: /api/v1/observers, from: last.iata} + follow: *cursor + - id: ch_last_zzz + path: /api/v1/channels/{ch}/messages + query: {iatas: "ZZZ"} + vars: + ch: {path: /api/v1/channels, from: last.id} + follow: *cursor + - id: messages_all + path: /api/v1/messages + follow: *cursor + - id: messages_site_a + path: /api/v1/messages + query: {iatas: "{a}"} + vars: + a: {path: /api/v1/observers, from: first.iata} + follow: *cursor + - id: messages_site_b + path: /api/v1/messages + query: {iatas: "{b}"} + vars: + b: {path: /api/v1/observers, from: last.iata} + follow: *cursor + - id: messages_sites_ab + path: /api/v1/messages + query: {iatas: "{a},{b}"} + vars: + a: {path: /api/v1/observers, from: first.iata} + b: {path: /api/v1/observers, from: last.iata} + follow: *cursor + - id: messages_zzz + path: /api/v1/messages + query: {iatas: "ZZZ"} + follow: *cursor + - id: messages_since + path: /api/v1/messages + query: {since: "{t}"} + web_limit: 200 + vars: + t: {path: /api/v1/messages, from: first.sentAt, add: -36720000} + follow: *cursor + - id: messages_since_sites + path: /api/v1/messages + query: {since: "{t}", iatas: "{a},{b}"} + web_limit: 200 + vars: + a: {path: /api/v1/observers, from: first.iata} + b: {path: /api/v1/observers, from: last.iata} + t: {path: /api/v1/messages, from: first.sentAt, add: -36720000} + follow: *cursor diff --git a/db/planpolicy/cached_gen.go b/db/planpolicy/cached_gen.go index 938bc66..93e2b61 100644 --- a/db/planpolicy/cached_gen.go +++ b/db/planpolicy/cached_gen.go @@ -7,11 +7,15 @@ package planpolicy // Cached lists class G statements: those admitted to the generic-plan class. var Cached = map[string]bool{ - "GetNodeByID": true, - "GetObserverTelemetrySince": true, - "ListKnownRoutesByIATA": true, - "ListKnownRoutesGlobal": true, - "ListObserverAdverts": true, - "ListPacketsByTypes": true, - "ListPacketsPage": true, + "GetNodeByID": true, + "GetObserverTelemetrySince": true, + "ListAllChannelMessagesByIATAs": true, + "ListAllChannelMessagesPlain": true, + "ListChannelMessagesByIATAs": true, + "ListChannelMessagesPlain": true, + "ListKnownRoutesByIATA": true, + "ListKnownRoutesGlobal": true, + "ListObserverAdverts": true, + "ListPacketsByTypes": true, + "ListPacketsPage": true, } diff --git a/db/planpolicy/planpolicy_test.go b/db/planpolicy/planpolicy_test.go index 1d3924f..9d8bb54 100644 --- a/db/planpolicy/planpolicy_test.go +++ b/db/planpolicy/planpolicy_test.go @@ -63,3 +63,26 @@ func TestParseLayout(t *testing.T) { } } } + +// The channel message statements: the four whose plan is stable under every layout are generic-safe; the scoped, +// since and scope-only ones are planned with their values; today's two statements stay on the legacy pool. +func TestCmiPlanClasses(t *testing.T) { + for name, want := range map[string]planpolicy.Class{ + "ListChannelMessagesByIATAs": planpolicy.ClassG, + "ListChannelMessagesPlain": planpolicy.ClassG, + "ListAllChannelMessagesByIATAs": planpolicy.ClassG, + "ListAllChannelMessagesPlain": planpolicy.ClassG, + "ListChannelMessagesByIATAsScoped": planpolicy.ClassC, + "ListChannelMessagesPlainScoped": planpolicy.ClassC, + "ListChannelMessagesSinceWalk": planpolicy.ClassC, + "ListAllChannelMessagesPlainScoped": planpolicy.ClassC, + "ListAllChannelMessagesSince": planpolicy.ClassC, + "GetTransportScopeByName": planpolicy.ClassC, + "ListChannelMessages": planpolicy.ClassLegacy, + "ListAllChannelMessages": planpolicy.ClassLegacy, + } { + if got := planpolicy.ClassOf(name); got != want { + t.Errorf("ClassOf(%s) = %v, want %v", name, got, want) + } + } +} diff --git a/db/planrouter.go b/db/planrouter.go index 932ea99..132ae95 100644 --- a/db/planrouter.go +++ b/db/planrouter.go @@ -220,8 +220,8 @@ func (r *routerRows) Scan(dest ...any) error { // NewAPIStore builds the store the API reads through: every statement goes through a PlanRouter // over p's API pools, gated by gate. It has no dedicated pool, so rollups, sweeps and statement // statistics refuse to run on it; they belong on the maintenance store. -func NewAPIStore(p *Pools, layout planpolicy.Layout, gate guards.Gate, clockDriftThreshold, staleThreshold time.Duration) *Store { - return New(NewPlanRouter(p, layout, gate), nil, clockDriftThreshold, staleThreshold, WithPayloadTypeGate()) +func NewAPIStore(p *Pools, layout planpolicy.Layout, gate guards.Gate, clockDriftThreshold, staleThreshold time.Duration, opts ...Option) *Store { + return New(NewPlanRouter(p, layout, gate), nil, clockDriftThreshold, staleThreshold, append([]Option{WithPayloadTypeGate()}, opts...)...) } // routerRow scans the first row like pgx's own Row: no row is pgx.ErrNoRows, and the rows diff --git a/db/queries/channel_message_iatas.sql b/db/queries/channel_message_iatas.sql new file mode 100644 index 0000000..7079f7b --- /dev/null +++ b/db/queries/channel_message_iatas.sql @@ -0,0 +1,257 @@ +-- Copyright 2026 Beacon Contributors +-- SPDX-License-Identifier: AGPL-3.0-or-later + +-- name: AddChannelMessageIATA :one +-- A stored observation's site for a message another statement created. A no-op when the packet has no message; +-- found says whether the packet has a committed message (then the site is recorded, now or before). +WITH m AS ( + SELECT cm.id, cm.channel_id, p.scope_id + FROM channel_messages cm + JOIN packets p ON p.packet_hash = cm.packet_hash + WHERE cm.packet_hash = @packet_hash::bytea +), added AS ( + INSERT INTO channel_message_iatas (message_id, iata, channel_id, scope_id) + SELECT m.id, @iata::bpchar, m.channel_id, m.scope_id FROM m + ON CONFLICT (message_id, iata) DO NOTHING +) +SELECT EXISTS (SELECT 1 FROM m) AS found; + +-- name: FillChannelMessageIATAsByMessages :execrows +-- Every site of every message in (after_id, through_id]: the backfill and the reconcile's message part. +INSERT INTO channel_message_iatas (message_id, iata, channel_id, scope_id) +SELECT DISTINCT cm.id, po.iata, cm.channel_id, p.scope_id +FROM channel_messages cm +JOIN packets p ON p.packet_hash = cm.packet_hash +JOIN packet_observations po ON po.packet_hash = cm.packet_hash +WHERE cm.id > @after_id::bigint AND cm.id <= @through_id::bigint +ON CONFLICT (message_id, iata) DO NOTHING; + +-- name: FillChannelMessageIATAsByObservations :execrows +-- The site of every group-text observation in (after_id, through_id] whose packet has a message. +-- An untyped observation is checked too: older rows may have no payload type. +INSERT INTO channel_message_iatas (message_id, iata, channel_id, scope_id) +SELECT DISTINCT cm.id, po.iata, cm.channel_id, p.scope_id +FROM packet_observations po +JOIN channel_messages cm ON cm.packet_hash = po.packet_hash +JOIN packets p ON p.packet_hash = po.packet_hash +WHERE po.id > @after_id::bigint AND po.id <= @through_id::bigint AND COALESCE(po.payload_type, 5) = 5 +ON CONFLICT (message_id, iata) DO NOTHING; + +-- name: MaxObservationID :one +SELECT COALESCE(max(id), 0)::bigint AS id FROM packet_observations; + +-- name: MaxChannelMessageID :one +SELECT COALESCE(max(id), 0)::bigint AS id FROM channel_messages; + +-- name: NextChannelMessageID :one +-- The first message id above after_id, or 0 when there is none. +SELECT COALESCE(min(id), 0)::bigint AS id FROM channel_messages WHERE id > @after_id::bigint; + +-- name: CheckChannelMessageIATAs :one +-- Exact check of messages in (after_id, through_id]: pairs the definition has and the table lacks (counting +-- observations up to obs_through only), and table pairs no stored observation backs. +WITH def AS ( + SELECT DISTINCT cm.id AS message_id, po.iata, cm.channel_id, p.scope_id, po.id <= @obs_through::bigint AS settled + FROM channel_messages cm + JOIN packets p ON p.packet_hash = cm.packet_hash + JOIN packet_observations po ON po.packet_hash = cm.packet_hash + WHERE cm.id > @after_id::bigint AND cm.id <= @through_id::bigint +), have AS ( + SELECT i.message_id, i.iata, i.channel_id, i.scope_id + FROM channel_message_iatas i + WHERE i.message_id > @after_id::bigint AND i.message_id <= @through_id::bigint +) +SELECT + (SELECT count(*) FROM (SELECT message_id, iata, channel_id, scope_id FROM def WHERE settled + EXCEPT SELECT message_id, iata, channel_id, scope_id FROM have) m)::bigint AS missing, + (SELECT count(*) FROM (SELECT message_id, iata, channel_id, scope_id FROM have + EXCEPT SELECT message_id, iata, channel_id, scope_id FROM def) x)::bigint AS extra; + +-- name: ListChannelMessagesByIATAs :many +-- One channel filtered by sites: each site's newest message ids from the read model, merged. +WITH hits AS MATERIALIZED ( + SELECT m.message_id + FROM unnest(@iatas::bpchar[]) AS req(iata) + CROSS JOIN LATERAL ( + SELECT i.message_id FROM channel_message_iatas i + WHERE i.channel_id = @channel_id::int AND i.iata = req.iata + AND i.message_id < @cursor_id::bigint + ORDER BY i.message_id DESC + LIMIT @page_limit) m + GROUP BY m.message_id + ORDER BY m.message_id DESC + LIMIT @page_limit) +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM hits h +JOIN channel_messages cm ON cm.id = h.message_id +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +ORDER BY cm.id DESC; + +-- name: ListChannelMessagesByIATAsScoped :many +-- One channel filtered by sites and scope. +WITH hits AS MATERIALIZED ( + SELECT m.message_id + FROM unnest(@iatas::bpchar[]) AS req(iata) + CROSS JOIN LATERAL ( + SELECT i.message_id FROM channel_message_iatas i + WHERE i.channel_id = @channel_id::int AND i.iata = req.iata AND i.scope_id = @scope_id::int + AND i.message_id < @cursor_id::bigint + ORDER BY i.message_id DESC + LIMIT @page_limit) m + GROUP BY m.message_id + ORDER BY m.message_id DESC + LIMIT @page_limit) +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM hits h +JOIN channel_messages cm ON cm.id = h.message_id +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +ORDER BY cm.id DESC; + +-- name: ListChannelMessagesPlainScoped :many +-- One channel and scope: the read model has a row exactly when the message has a stored observation. +WITH hits AS MATERIALIZED ( + SELECT DISTINCT i.message_id + FROM channel_message_iatas i + WHERE i.channel_id = @channel_id::int AND i.scope_id = @scope_id::int AND i.message_id < @cursor_id::bigint + ORDER BY i.message_id DESC + LIMIT @page_limit) +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM hits h +JOIN channel_messages cm ON cm.id = h.message_id +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +ORDER BY cm.id DESC; + +-- name: ListChannelMessagesPlain :many +-- One channel, unfiltered: a walk of the channel by id; a message counts once it has a stored observation. +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM channel_messages cm +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +WHERE cm.channel_id = @channel_id::int AND cm.id < @cursor_id::bigint + AND EXISTS (SELECT 1 FROM packet_observations po WHERE po.packet_hash = cm.packet_hash) +ORDER BY cm.id DESC +LIMIT @page_limit; + +-- name: ListChannelMessagesSinceWalk :many +-- One channel with since (no client sends it): a channel walk; sites filter through the read model. +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM channel_messages cm +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +WHERE cm.channel_id = @channel_id::int + AND cm.sent_at >= @since::timestamptz + AND EXISTS (SELECT 1 FROM packet_observations po WHERE po.packet_hash = cm.packet_hash) + AND (COALESCE(cardinality(@iatas::bpchar[]), 0) = 0 + OR EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.message_id = cm.id AND i.iata = ANY(@iatas::bpchar[]))) + AND (sqlc.narg('scope_id')::int IS NULL OR p.scope_id = sqlc.narg('scope_id')::int) + AND cm.id < @cursor_id::bigint +ORDER BY cm.id DESC +LIMIT @page_limit; + +-- name: ListAllChannelMessagesByIATAs :many +-- Every channel filtered by sites: each site's newest message ids from the read model, merged. +WITH hits AS MATERIALIZED ( + SELECT m.message_id + FROM unnest(@iatas::bpchar[]) AS req(iata) + CROSS JOIN LATERAL ( + SELECT i.message_id FROM channel_message_iatas i + WHERE i.iata = req.iata AND i.message_id < @cursor_id::bigint + ORDER BY i.message_id DESC + LIMIT @page_limit) m + GROUP BY m.message_id + ORDER BY m.message_id DESC + LIMIT @page_limit) +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM hits h +JOIN channel_messages cm ON cm.id = h.message_id +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +ORDER BY cm.id DESC; + +-- name: ListAllChannelMessagesPlainScoped :many +-- Every channel filtered by scope alone: the scope's newest message ids from the read model. +WITH hits AS MATERIALIZED ( + SELECT DISTINCT i.message_id + FROM channel_message_iatas i + WHERE i.scope_id = @scope_id::int AND i.message_id < @cursor_id::bigint + ORDER BY i.message_id DESC + LIMIT @page_limit) +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM hits h +JOIN channel_messages cm ON cm.id = h.message_id +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +ORDER BY cm.id DESC; + +-- name: ListAllChannelMessagesPlain :many +-- Every channel, unfiltered: a walk by id; a message counts once it has a stored observation. +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM channel_messages cm +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +WHERE cm.id < @cursor_id::bigint + AND EXISTS (SELECT 1 FROM packet_observations po WHERE po.packet_hash = cm.packet_hash) +ORDER BY cm.id DESC +LIMIT @page_limit; + +-- name: ListAllChannelMessagesSince :many +-- Every channel with since, optionally by scope (no sites): a walk by id. +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM channel_messages cm +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +WHERE cm.sent_at >= @since::timestamptz + AND (sqlc.narg('scope_id')::int IS NULL OR p.scope_id = sqlc.narg('scope_id')::int) + AND cm.id < @cursor_id::bigint + AND EXISTS (SELECT 1 FROM packet_observations po WHERE po.packet_hash = cm.packet_hash) +ORDER BY cm.id DESC +LIMIT @page_limit; + +-- name: ListChannelMessageIATASamples :many +-- The busiest (channel, site) pairs among recent messages; the first-time verification compares their pages. +SELECT i.channel_id, i.iata, count(*)::bigint AS n +FROM channel_message_iatas i +WHERE i.message_id > @after_id::bigint +GROUP BY i.channel_id, i.iata +ORDER BY n DESC, i.channel_id, i.iata +LIMIT @row_limit; + +-- name: ListChannelMessageScopeSamples :many +-- The busiest (channel, scope) pairs among recent messages, with the scope name today's statement filters on. +SELECT i.channel_id, i.scope_id, ts.name, count(*)::bigint AS n +FROM channel_message_iatas i +JOIN transport_scopes ts ON ts.id = i.scope_id +WHERE i.message_id > @after_id::bigint AND i.scope_id IS NOT NULL +GROUP BY i.channel_id, i.scope_id, ts.name +ORDER BY n DESC, i.channel_id, i.scope_id +LIMIT @row_limit; diff --git a/db/queries/queries.sql b/db/queries/queries.sql index 0b23aca..71428bc 100644 --- a/db/queries/queries.sql +++ b/db/queries/queries.sql @@ -1215,6 +1215,10 @@ SELECT (SELECT count(*) FROM cand) AS candidates, -- name: GetBackgroundState :one SELECT value FROM background_state WHERE key = @key; +-- name: GetBackgroundStateAge :one +-- A state with its age on the database clock: how long since its writer last saved it. +SELECT value, extract(epoch FROM statement_timestamp() - updated_at)::float8 AS age_seconds FROM background_state WHERE key = @key; + -- name: UpsertBackgroundState :exec INSERT INTO background_state (key, value, updated_at) VALUES (@key, @value, now()) ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now(); @@ -1543,6 +1547,37 @@ SELECT * FROM channels WHERE id = $1; -- A later reception's transport code must not give live and historical messages different tags. -- message_count is a lifetime count, bumped only for a new message. A historical (backfilled) -- message queues its observation hours for a re-roll in the same statement, so the two can't diverge. +WITH inserted AS ( + INSERT INTO channel_messages (channel_id, packet_hash, sender_name, content, sent_at) + VALUES ($1, $2, $3, $4, $5) + ON CONFLICT (packet_hash) DO NOTHING + RETURNING id, packet_hash, channel_id +), bump AS ( + UPDATE channels c SET message_count = c.message_count + 1 + FROM inserted WHERE c.id = inserted.channel_id +), dirty AS ( + INSERT INTO analytics_dirty_hours (hour) + SELECT DISTINCT date_trunc('hour', po.heard_at, 'UTC') + FROM packet_observations po JOIN inserted i ON i.packet_hash = po.packet_hash + WHERE $6::boolean + ON CONFLICT (hour) DO UPDATE SET enqueued_at = now() +), seed AS ( + -- Every stored observation's site, in the same statement; a later observation adds its own site. + INSERT INTO channel_message_iatas (message_id, iata, channel_id, scope_id) + SELECT DISTINCT i.id, po.iata, i.channel_id, p.scope_id + FROM inserted i + JOIN packets p ON p.packet_hash = i.packet_hash + JOIN packet_observations po ON po.packet_hash = i.packet_hash + ON CONFLICT (message_id, iata) DO NOTHING +) +SELECT inserted.id, ts.name AS scope_name, p.transport_codes_present +FROM inserted +JOIN packets p ON p.packet_hash = inserted.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id; + +-- name: InsertChannelMessageUnseeded :one +-- The seeded insert's fallback: the same statement without the site seed. The read-model +-- reconcile adds the message's sites within one interval. WITH inserted AS ( INSERT INTO channel_messages (channel_id, packet_hash, sender_name, content, sent_at) VALUES ($1, $2, $3, $4, $5) diff --git a/db/readmodel.go b/db/readmodel.go new file mode 100644 index 0000000..e834ab0 --- /dev/null +++ b/db/readmodel.go @@ -0,0 +1,225 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package db + +import ( + "context" + "errors" + "fmt" + "log/slog" + "sync" + "sync/atomic" + "time" + + "github.com/MeshCore-Beacon/beacon-server/internal/metrics" + "github.com/jackc/pgx/v5/pgxpool" +) + +const ( + // Advisory lock classes, taken as pg_try_advisory_lock(class, hashtext(current_schema())), so instances sharing a + // schema serialise and schemas (tests) do not. Distinct from the migration key and the rollup lock (25189, 1). + cmiReconcileLockKey int32 = 0x636d69 // "cmi" + // Reserved for the packet_sites read model. + packetSitesReconcileLockKey int32 = 0x7073 // "ps" +) + +// ErrPreBootWriters means a transaction that began before boot still holds an xid: rows it writes may bypass the +// read models, so the boot repair waits for it. +var ErrPreBootWriters = errors.New("transactions from before boot still hold an xid") + +// DatabaseNow returns statement_timestamp() from the database, so the boot cut-off and xact_start share one clock. +func DatabaseNow(ctx context.Context, pool *pgxpool.Pool) (time.Time, error) { + var now time.Time + err := pool.QueryRow(ctx, "SELECT statement_timestamp()").Scan(&now) + return now, err +} + +// WaitForPreBootWriters polls every 500 ms until no other session of this database that started its transaction +// before bootTS holds an xid; after maxWait it returns ErrPreBootWriters (wrapped with the count and pids). +// A session of another role is visible only to a privileged role; such a writer is not waited for, and the +// periodic reconcile repairs what it wrote. +func WaitForPreBootWriters(ctx context.Context, pool *pgxpool.Pool, bootTS time.Time, maxWait time.Duration) error { + deadline := time.Now().Add(maxWait) + for { + var n int + var pids []int32 + if err := pool.QueryRow(ctx, `SELECT count(*), coalesce(array_agg(pid ORDER BY pid), '{}') FROM pg_stat_activity +WHERE datname = current_database() AND backend_xid IS NOT NULL AND xact_start < $1 AND pid <> pg_backend_pid()`, bootTS).Scan(&n, &pids); err != nil { + return err + } + if n == 0 { + return nil + } + if !time.Now().Before(deadline) { + return fmt.Errorf("%w: %d session(s), pids %v", ErrPreBootWriters, n, pids) + } + select { + case <-ctx.Done(): + return ctx.Err() + case <-time.After(min(500*time.Millisecond, time.Until(deadline))): + } + } +} + +// TrustPolicy says how many repairing runs in a row drop a read model's trust and how many clean runs restore it. +type TrustPolicy struct{ DropAfterDirty, RestoreAfterClean int } + +// CmiTrustPolicy: an in-flight Add can make one run repair a pair, so one run never flips trust. +var CmiTrustPolicy = TrustPolicy{DropAfterDirty: 3, RestoreAfterClean: 2} + +// Trust says whether this process may serve pages from a read model. It is false until Earn, false whenever the +// operator disabled the model, false after DropAfterDirty repairing runs in a row until RestoreAfterClean clean +// runs, and false from a writer's Invalidate until a reconcile that began after it has finished. Every change sets +// beacon_readmodel_trusted{model}. +type Trust struct { + model string + enabled bool + policy TrustPolicy + + mu sync.Mutex + earned, dropped bool + dirty, clean int + gen uint64 // writer invalidations so far + repairedGen uint64 // gen covered by the last finished reconcile + trusted atomic.Bool + expiry atomic.Int64 // unix ns after which trust ends without another call; 0 = none +} + +// NewTrust returns an untrusted model; enabled=false keeps it untrusted for the life of the process. +func NewTrust(model string, enabled bool, p TrustPolicy) *Trust { + t := &Trust{model: model, enabled: enabled, policy: p} + t.mu.Lock() + t.update() + t.mu.Unlock() + return t +} + +// Trusted reports whether pages may be served from the model. A nil *Trust is untrusted. +func (t *Trust) Trusted() bool { + if t == nil || !t.trusted.Load() { + return false + } + if e := t.expiry.Load(); e != 0 && time.Now().UnixNano() >= e { + t.mu.Lock() + t.update() + t.mu.Unlock() + return false + } + return true +} + +// SetExpiry makes trust end at at, read by read, until a later SetExpiry; the zero time removes the expiry. A +// read-only server sets it to the instant its writer's saved state turns too old. +func (t *Trust) SetExpiry(at time.Time) { + t.mu.Lock() + defer t.mu.Unlock() + if at.IsZero() { + t.expiry.Store(0) + } else { + t.expiry.Store(at.UnixNano()) + } + t.update() +} + +// Expiry returns the instant trust ends without another call, or the zero time. +func (t *Trust) Expiry() time.Time { + if e := t.expiry.Load(); e != 0 { + return time.Unix(0, e) + } + return time.Time{} +} + +// Model returns the model's metric label. +func (t *Trust) Model() string { return t.model } + +// Earn records that the boot repair, the backfill and the verification are done. +func (t *Trust) Earn() { + t.mu.Lock() + defer t.mu.Unlock() + t.earned = true + t.update() +} + +// ObserveRun applies the drop and restore policy to one periodic reconcile that repaired that many rows. Runs before +// Earn do not count. +func (t *Trust) ObserveRun(repaired int64) { + t.mu.Lock() + defer t.mu.Unlock() + if !t.earned { + return + } + if repaired > 0 { + t.dirty, t.clean = t.dirty+1, 0 + if t.dirty >= t.policy.DropAfterDirty { + t.dropped = true + } + } else { + t.dirty, t.clean = 0, t.clean+1 + if t.dropped && t.clean >= t.policy.RestoreAfterClean { + t.dropped = false + } + } + t.update() +} + +// Invalidate drops trust at once: a writer left a pair the model is missing (a failed Add, a message stored without +// its sites). A reconcile that begins after this call repairs it. Nil-safe. +func (t *Trust) Invalidate(reason string) { + if t == nil { + return + } + t.mu.Lock() + defer t.mu.Unlock() + t.gen++ + if t.trusted.Load() { + slog.Warn("read model untrusted until the next reconcile", "component", "readmodel", "model", t.model, "reason", reason) + } + t.update() +} + +// Generation returns the invalidation count; a reconcile reads it before it starts and passes it to Repaired. +func (t *Trust) Generation() uint64 { + t.mu.Lock() + defer t.mu.Unlock() + return t.gen +} + +// Repaired records a finished reconcile that began at generation gen: it covers every invalidation up to gen. +func (t *Trust) Repaired(gen uint64) { + t.mu.Lock() + defer t.mu.Unlock() + t.repairedGen = max(t.repairedGen, gen) + t.update() +} + +// update recomputes trusted and the gauge; t.mu is held. +func (t *Trust) update() { + e := t.expiry.Load() + on := t.enabled && t.earned && !t.dropped && t.repairedGen >= t.gen && (e == 0 || time.Now().UnixNano() < e) + t.trusted.Store(on) + v := 0.0 + if on { + v = 1 + } + metrics.ReadModelTrusted.WithLabelValues(t.model).Set(v) +} + +// ReadModels holds this process's trust in each read model. The ingest, maintenance and API stores share one, so a +// writer's failure is seen by the readers at once. +type ReadModels struct{ Cmi, PacketSites *Trust } + +// WithReadModels sets the read models a store reads from and reports writer failures to. +func WithReadModels(rm *ReadModels) Option { + return func(s *Store) { s.readModels = rm } +} + +// cmiTrusted is nil-safe: a nil *ReadModels is untrusted. +func (rm *ReadModels) cmiTrusted() bool { return rm != nil && rm.Cmi.Trusted() } + +// invalidateCmi is nil-safe. +func (rm *ReadModels) invalidateCmi(reason string) { + if rm != nil { + rm.Cmi.Invalidate(reason) + } +} diff --git a/db/readmodel_integration_test.go b/db/readmodel_integration_test.go new file mode 100644 index 0000000..5002451 --- /dev/null +++ b/db/readmodel_integration_test.go @@ -0,0 +1,106 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package db + +import ( + "context" + "errors" + "os" + "strings" + "testing" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" +) + +// waitDatabase creates a database of its own, so other packages' open transactions never count. +func waitDatabase(t *testing.T) (context.Context, *pgxpool.Pool) { + t.Helper() + dsn := os.Getenv("BEACON_TEST_POSTGRES_DSN") + if dsn == "" { + t.Skip("set BEACON_TEST_POSTGRES_DSN for PostgreSQL regression") + } + ctx, cancel := context.WithTimeout(context.Background(), time.Minute) + t.Cleanup(cancel) + admin, err := pgx.Connect(ctx, dsn) + if err != nil { + t.Fatal(err) + } + name := "cmi_wait_" + strings.ReplaceAll(uuid.NewString(), "-", "") + if _, err := admin.Exec(ctx, "CREATE DATABASE "+name); err != nil { + t.Fatal(err) + } + cfg, err := pgxpool.ParseConfig(dsn) + if err != nil { + t.Fatal(err) + } + cfg.ConnConfig.Database = name + cfg.MaxConns = 4 + pool, err := pgxpool.NewWithConfig(ctx, cfg) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { + pool.Close() + if _, err := admin.Exec(context.Background(), "DROP DATABASE "+name+" WITH (FORCE)"); err != nil { + t.Error(err) + } + admin.Close(context.Background()) + }) + if _, err := pool.Exec(ctx, "CREATE TABLE w (x int)"); err != nil { + t.Fatal(err) + } + return ctx, pool +} + +func TestWaitForPreBootWritersPostgres(t *testing.T) { + ctx, pool := waitDatabase(t) + conn := func() *pgxpool.Conn { + c, err := pool.Acquire(ctx) + if err != nil { + t.Fatal(err) + } + t.Cleanup(c.Release) + return c + } + begin := func(c *pgxpool.Conn, write bool) pgx.Tx { + tx, err := c.Begin(ctx) + if err != nil { + t.Fatal(err) + } + sql := "SELECT 1" + if write { + sql = "INSERT INTO w VALUES (1)" + } + if _, err := tx.Exec(ctx, sql); err != nil { + t.Fatal(err) + } + return tx + } + + reader := begin(conn(), false) // read-only, from before boot: holds no xid + defer reader.Rollback(context.Background()) //nolint:errcheck + writer := begin(conn(), true) + time.Sleep(10 * time.Millisecond) + bootTS, err := DatabaseNow(ctx, pool) + if err != nil { + t.Fatal(err) + } + start := time.Now() + err = WaitForPreBootWriters(ctx, pool, bootTS, time.Second) + if !errors.Is(err, ErrPreBootWriters) || time.Since(start) < time.Second { + t.Fatalf("wait = %v after %s, want ErrPreBootWriters after at least 1 s", err, time.Since(start)) + } + if err := writer.Commit(ctx); err != nil { + t.Fatal(err) + } + later := begin(conn(), true) // a writer that began after boot + defer later.Rollback(context.Background()) //nolint:errcheck + start = time.Now() + if err := WaitForPreBootWriters(ctx, pool, bootTS, time.Second); err != nil || time.Since(start) > time.Second { + t.Fatalf("wait = %v after %s, want nil at once", err, time.Since(start)) + } +} diff --git a/db/readmodel_test.go b/db/readmodel_test.go new file mode 100644 index 0000000..38e14b2 --- /dev/null +++ b/db/readmodel_test.go @@ -0,0 +1,176 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package db + +import ( + "context" + "errors" + "testing" + "time" + + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" + mockdb "github.com/MeshCore-Beacon/beacon-server/db/sqlc/mock" + "github.com/MeshCore-Beacon/beacon-server/internal/ingest" + "github.com/MeshCore-Beacon/beacon-server/internal/metrics" + "github.com/jackc/pgx/v5" + "github.com/prometheus/client_golang/prometheus/testutil" + "go.uber.org/mock/gomock" +) + +func TestTrustPolicy(t *testing.T) { + tr := NewTrust("cmi_policy_test", true, CmiTrustPolicy) + gauge := func() float64 { return testutil.ToFloat64(metrics.ReadModelTrusted.WithLabelValues("cmi_policy_test")) } + step := func(label string, want bool) { + t.Helper() + if tr.Trusted() != want { + t.Fatalf("%s: trusted %v, want %v", label, tr.Trusted(), want) + } + if g := gauge(); (g == 1) != want { + t.Fatalf("%s: gauge %v, want trusted %v", label, g, want) + } + } + step("new", false) + tr.ObserveRun(5) + step("a repairing run before earn", false) + tr.Earn() + step("earned", true) + tr.ObserveRun(1) + tr.ObserveRun(1) + step("two repairing runs", true) + tr.ObserveRun(1) + step("three repairing runs", false) + tr.ObserveRun(0) + step("one clean run", false) + tr.ObserveRun(0) + step("two clean runs", true) + tr.ObserveRun(1) + tr.ObserveRun(0) + tr.ObserveRun(1) + tr.ObserveRun(1) + step("dirty, clean, dirty, dirty", true) + + disabled := NewTrust("cmi_policy_test_disabled", false, CmiTrustPolicy) + disabled.Earn() + if disabled.Trusted() || disabled.Model() != "cmi_policy_test_disabled" { + t.Fatal("a disabled model earned trust") + } + if (*Trust)(nil).Trusted() { + t.Fatal("a nil Trust is trusted") + } + (*Trust)(nil).Invalidate("nil-safe") + if (*ReadModels)(nil).cmiTrusted() { + t.Fatal("nil ReadModels trusted") + } +} + +// A writer failure drops trust at once; only a reconcile run that began after the last failure restores it. +func TestTrustInvalidate(t *testing.T) { + tr := NewTrust("cmi_invalidate_test", true, CmiTrustPolicy) + before := tr.Generation() + tr.Invalidate("failed add") + tr.Earn() + tr.Repaired(before) // the boot run began before the failure + if tr.Trusted() { + t.Fatal("a run that began before the failure restored trust") + } + gen := tr.Generation() + tr.Repaired(gen) + if !tr.Trusted() { + t.Fatal("a run that began after the failure did not restore trust") + } + gen = tr.Generation() + tr.Invalidate("unseeded message") + if tr.Trusted() { + t.Fatal("an invalidation left trust on") + } + tr.Repaired(gen) // began before this failure + if tr.Trusted() { + t.Fatal("restored by an older run") + } + tr.Repaired(tr.Generation()) + if !tr.Trusted() { + t.Fatal("not restored") + } +} + +// The writers drop cmi trust when they leave a pair missing: a failed Add, or a message stored without its seed. +func TestCmiWriterFailuresDropTrust(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + tr := NewTrust("cmi_writer_test", true, CmiTrustPolicy) + tr.Earn() + s := &Store{q: mock} + WithReadModels(&ReadModels{Cmi: tr})(s) + + mock.EXPECT().AddChannelMessageIATA(gomock.Any(), gomock.Any()).Return(false, errors.New("add failed")) + if _, err := s.AddChannelMessageIATA(context.Background(), []byte{1}, "YUL"); err == nil { + t.Fatal("Add error not returned") + } + if tr.Trusted() { + t.Fatal("a failed Add left cmi trusted") + } + tr.Repaired(tr.Generation()) + + mock.EXPECT().InsertChannelMessage(gomock.Any(), gomock.Any()).Return(sqlc.InsertChannelMessageRow{}, errors.New("seed failed")) + mock.EXPECT().InsertChannelMessageUnseeded(gomock.Any(), gomock.Any()).DoAndReturn(func(context.Context, sqlc.InsertChannelMessageUnseededParams) (sqlc.InsertChannelMessageUnseededRow, error) { + if tr.Trusted() { + t.Error("the unseeded insert ran while cmi was still trusted: a page could miss the message") + } + return sqlc.InsertChannelMessageUnseededRow{ID: 9}, nil + }) + if m, err := s.InsertChannelMessage(context.Background(), ingest.InsertChannelMessageParams{ChannelID: 1, PacketHash: []byte{2}}); err != nil || m == nil || m.ID != 9 { + t.Fatalf("fallback = %+v, %v", m, err) + } + if tr.Trusted() { + t.Fatal("a message stored without its seed left cmi trusted") + } + tr.Repaired(tr.Generation()) + + // Both statements failing: the message is not stored here, but another lane's message may be in flight, and the + // Add after a failed insert can find none. Trust drops until the next reconcile. + mock.EXPECT().InsertChannelMessage(gomock.Any(), gomock.Any()).Return(sqlc.InsertChannelMessageRow{}, errors.New("seed failed")) + mock.EXPECT().InsertChannelMessageUnseeded(gomock.Any(), gomock.Any()).Return(sqlc.InsertChannelMessageUnseededRow{}, errors.New("insert failed")) + if _, err := s.InsertChannelMessage(context.Background(), ingest.InsertChannelMessageParams{ChannelID: 1, PacketHash: []byte{2}}); err == nil { + t.Fatal("error not returned") + } + if tr.Trusted() { + t.Fatal("a failed insert left cmi trusted") + } + tr.Repaired(tr.Generation()) + + // A plain duplicate stores nothing and changes nothing. + mock.EXPECT().InsertChannelMessage(gomock.Any(), gomock.Any()).Return(sqlc.InsertChannelMessageRow{}, pgx.ErrNoRows) + if m, err := s.InsertChannelMessage(context.Background(), ingest.InsertChannelMessageParams{ChannelID: 1, PacketHash: []byte{2}}); err != nil || m != nil { + t.Fatalf("duplicate = %+v, %v", m, err) + } + if !tr.Trusted() { + t.Fatal("a duplicate dropped trust") + } +} + +// A trust with an expiry is untrusted from that instant on, read by read, and the gauge follows; earning again +// with a later expiry restores it. +func TestTrustExpiry(t *testing.T) { + tr := NewTrust("cmi_expiry_test", true, CmiTrustPolicy) + tr.Earn() + tr.SetExpiry(time.Now().Add(30 * time.Millisecond)) + if !tr.Trusted() { + t.Fatal("not trusted before the expiry") + } + time.Sleep(40 * time.Millisecond) + if tr.Trusted() { + t.Fatal("trusted after the expiry") + } + if g := testutil.ToFloat64(metrics.ReadModelTrusted.WithLabelValues("cmi_expiry_test")); g != 0 { + t.Fatalf("gauge %v after the expiry", g) + } + tr.SetExpiry(time.Now().Add(time.Minute)) + if !tr.Trusted() || testutil.ToFloat64(metrics.ReadModelTrusted.WithLabelValues("cmi_expiry_test")) != 1 { + t.Fatal("a later expiry did not restore trust") + } + tr.SetExpiry(time.Time{}) + if !tr.Trusted() { + t.Fatal("no expiry: untrusted") + } +} diff --git a/db/sqlc/channel_message_iatas.sql.go b/db/sqlc/channel_message_iatas.sql.go new file mode 100644 index 0000000..b6c0d77 --- /dev/null +++ b/db/sqlc/channel_message_iatas.sql.go @@ -0,0 +1,954 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: channel_message_iatas.sql + +package db + +import ( + "context" + + "github.com/jackc/pgx/v5/pgtype" +) + +const addChannelMessageIATA = `-- name: AddChannelMessageIATA :one + +WITH m AS ( + SELECT cm.id, cm.channel_id, p.scope_id + FROM channel_messages cm + JOIN packets p ON p.packet_hash = cm.packet_hash + WHERE cm.packet_hash = $1::bytea +), added AS ( + INSERT INTO channel_message_iatas (message_id, iata, channel_id, scope_id) + SELECT m.id, $2::bpchar, m.channel_id, m.scope_id FROM m + ON CONFLICT (message_id, iata) DO NOTHING +) +SELECT EXISTS (SELECT 1 FROM m) AS found +` + +type AddChannelMessageIATAParams struct { + PacketHash []byte `json:"packet_hash"` + Iata string `json:"iata"` +} + +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later +// A stored observation's site for a message another statement created. A no-op when the packet has no message; +// found says whether the packet has a committed message (then the site is recorded, now or before). +func (q *Queries) AddChannelMessageIATA(ctx context.Context, arg AddChannelMessageIATAParams) (bool, error) { + row := q.db.QueryRow(ctx, addChannelMessageIATA, arg.PacketHash, arg.Iata) + var found bool + err := row.Scan(&found) + return found, err +} + +const checkChannelMessageIATAs = `-- name: CheckChannelMessageIATAs :one +WITH def AS ( + SELECT DISTINCT cm.id AS message_id, po.iata, cm.channel_id, p.scope_id, po.id <= $1::bigint AS settled + FROM channel_messages cm + JOIN packets p ON p.packet_hash = cm.packet_hash + JOIN packet_observations po ON po.packet_hash = cm.packet_hash + WHERE cm.id > $2::bigint AND cm.id <= $3::bigint +), have AS ( + SELECT i.message_id, i.iata, i.channel_id, i.scope_id + FROM channel_message_iatas i + WHERE i.message_id > $2::bigint AND i.message_id <= $3::bigint +) +SELECT + (SELECT count(*) FROM (SELECT message_id, iata, channel_id, scope_id FROM def WHERE settled + EXCEPT SELECT message_id, iata, channel_id, scope_id FROM have) m)::bigint AS missing, + (SELECT count(*) FROM (SELECT message_id, iata, channel_id, scope_id FROM have + EXCEPT SELECT message_id, iata, channel_id, scope_id FROM def) x)::bigint AS extra +` + +type CheckChannelMessageIATAsParams struct { + ObsThrough int64 `json:"obs_through"` + AfterID int64 `json:"after_id"` + ThroughID int64 `json:"through_id"` +} + +type CheckChannelMessageIATAsRow struct { + Missing int64 `json:"missing"` + Extra int64 `json:"extra"` +} + +// Exact check of messages in (after_id, through_id]: pairs the definition has and the table lacks (counting +// observations up to obs_through only), and table pairs no stored observation backs. +func (q *Queries) CheckChannelMessageIATAs(ctx context.Context, arg CheckChannelMessageIATAsParams) (CheckChannelMessageIATAsRow, error) { + row := q.db.QueryRow(ctx, checkChannelMessageIATAs, arg.ObsThrough, arg.AfterID, arg.ThroughID) + var i CheckChannelMessageIATAsRow + err := row.Scan(&i.Missing, &i.Extra) + return i, err +} + +const fillChannelMessageIATAsByMessages = `-- name: FillChannelMessageIATAsByMessages :execrows +INSERT INTO channel_message_iatas (message_id, iata, channel_id, scope_id) +SELECT DISTINCT cm.id, po.iata, cm.channel_id, p.scope_id +FROM channel_messages cm +JOIN packets p ON p.packet_hash = cm.packet_hash +JOIN packet_observations po ON po.packet_hash = cm.packet_hash +WHERE cm.id > $1::bigint AND cm.id <= $2::bigint +ON CONFLICT (message_id, iata) DO NOTHING +` + +type FillChannelMessageIATAsByMessagesParams struct { + AfterID int64 `json:"after_id"` + ThroughID int64 `json:"through_id"` +} + +// Every site of every message in (after_id, through_id]: the backfill and the reconcile's message part. +func (q *Queries) FillChannelMessageIATAsByMessages(ctx context.Context, arg FillChannelMessageIATAsByMessagesParams) (int64, error) { + result, err := q.db.Exec(ctx, fillChannelMessageIATAsByMessages, arg.AfterID, arg.ThroughID) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const fillChannelMessageIATAsByObservations = `-- name: FillChannelMessageIATAsByObservations :execrows +INSERT INTO channel_message_iatas (message_id, iata, channel_id, scope_id) +SELECT DISTINCT cm.id, po.iata, cm.channel_id, p.scope_id +FROM packet_observations po +JOIN channel_messages cm ON cm.packet_hash = po.packet_hash +JOIN packets p ON p.packet_hash = po.packet_hash +WHERE po.id > $1::bigint AND po.id <= $2::bigint AND COALESCE(po.payload_type, 5) = 5 +ON CONFLICT (message_id, iata) DO NOTHING +` + +type FillChannelMessageIATAsByObservationsParams struct { + AfterID int64 `json:"after_id"` + ThroughID int64 `json:"through_id"` +} + +// The site of every group-text observation in (after_id, through_id] whose packet has a message. +// An untyped observation is checked too: older rows may have no payload type. +func (q *Queries) FillChannelMessageIATAsByObservations(ctx context.Context, arg FillChannelMessageIATAsByObservationsParams) (int64, error) { + result, err := q.db.Exec(ctx, fillChannelMessageIATAsByObservations, arg.AfterID, arg.ThroughID) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const listAllChannelMessagesByIATAs = `-- name: ListAllChannelMessagesByIATAs :many +WITH hits AS MATERIALIZED ( + SELECT m.message_id + FROM unnest($1::bpchar[]) AS req(iata) + CROSS JOIN LATERAL ( + SELECT i.message_id FROM channel_message_iatas i + WHERE i.iata = req.iata AND i.message_id < $2::bigint + ORDER BY i.message_id DESC + LIMIT $3) m + GROUP BY m.message_id + ORDER BY m.message_id DESC + LIMIT $3) +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM hits h +JOIN channel_messages cm ON cm.id = h.message_id +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +ORDER BY cm.id DESC +` + +type ListAllChannelMessagesByIATAsParams struct { + Iatas []string `json:"iatas"` + CursorID int64 `json:"cursor_id"` + PageLimit int32 `json:"page_limit"` +} + +type ListAllChannelMessagesByIATAsRow struct { + ID int64 `json:"id"` + ChannelID int32 `json:"channel_id"` + PacketHash []byte `json:"packet_hash"` + SenderName *string `json:"sender_name"` + SenderPubkey []byte `json:"sender_pubkey"` + Content *string `json:"content"` + SentAt pgtype.Timestamptz `json:"sent_at"` + PacketHashHex string `json:"packet_hash_hex"` + ChannelHash []byte `json:"channel_hash"` + ScopeName *string `json:"scope_name"` + TransportCodesPresent *bool `json:"transport_codes_present"` + ObservationCount int64 `json:"observation_count"` +} + +// Every channel filtered by sites: each site's newest message ids from the read model, merged. +func (q *Queries) ListAllChannelMessagesByIATAs(ctx context.Context, arg ListAllChannelMessagesByIATAsParams) ([]ListAllChannelMessagesByIATAsRow, error) { + rows, err := q.db.Query(ctx, listAllChannelMessagesByIATAs, arg.Iatas, arg.CursorID, arg.PageLimit) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListAllChannelMessagesByIATAsRow{} + for rows.Next() { + var i ListAllChannelMessagesByIATAsRow + if err := rows.Scan( + &i.ID, + &i.ChannelID, + &i.PacketHash, + &i.SenderName, + &i.SenderPubkey, + &i.Content, + &i.SentAt, + &i.PacketHashHex, + &i.ChannelHash, + &i.ScopeName, + &i.TransportCodesPresent, + &i.ObservationCount, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listAllChannelMessagesPlain = `-- name: ListAllChannelMessagesPlain :many +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM channel_messages cm +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +WHERE cm.id < $1::bigint + AND EXISTS (SELECT 1 FROM packet_observations po WHERE po.packet_hash = cm.packet_hash) +ORDER BY cm.id DESC +LIMIT $2 +` + +type ListAllChannelMessagesPlainParams struct { + CursorID int64 `json:"cursor_id"` + PageLimit int32 `json:"page_limit"` +} + +type ListAllChannelMessagesPlainRow struct { + ID int64 `json:"id"` + ChannelID int32 `json:"channel_id"` + PacketHash []byte `json:"packet_hash"` + SenderName *string `json:"sender_name"` + SenderPubkey []byte `json:"sender_pubkey"` + Content *string `json:"content"` + SentAt pgtype.Timestamptz `json:"sent_at"` + PacketHashHex string `json:"packet_hash_hex"` + ChannelHash []byte `json:"channel_hash"` + ScopeName *string `json:"scope_name"` + TransportCodesPresent *bool `json:"transport_codes_present"` + ObservationCount int64 `json:"observation_count"` +} + +// Every channel, unfiltered: a walk by id; a message counts once it has a stored observation. +func (q *Queries) ListAllChannelMessagesPlain(ctx context.Context, arg ListAllChannelMessagesPlainParams) ([]ListAllChannelMessagesPlainRow, error) { + rows, err := q.db.Query(ctx, listAllChannelMessagesPlain, arg.CursorID, arg.PageLimit) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListAllChannelMessagesPlainRow{} + for rows.Next() { + var i ListAllChannelMessagesPlainRow + if err := rows.Scan( + &i.ID, + &i.ChannelID, + &i.PacketHash, + &i.SenderName, + &i.SenderPubkey, + &i.Content, + &i.SentAt, + &i.PacketHashHex, + &i.ChannelHash, + &i.ScopeName, + &i.TransportCodesPresent, + &i.ObservationCount, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listAllChannelMessagesPlainScoped = `-- name: ListAllChannelMessagesPlainScoped :many +WITH hits AS MATERIALIZED ( + SELECT DISTINCT i.message_id + FROM channel_message_iatas i + WHERE i.scope_id = $1::int AND i.message_id < $2::bigint + ORDER BY i.message_id DESC + LIMIT $3) +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM hits h +JOIN channel_messages cm ON cm.id = h.message_id +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +ORDER BY cm.id DESC +` + +type ListAllChannelMessagesPlainScopedParams struct { + ScopeID int32 `json:"scope_id"` + CursorID int64 `json:"cursor_id"` + PageLimit int32 `json:"page_limit"` +} + +type ListAllChannelMessagesPlainScopedRow struct { + ID int64 `json:"id"` + ChannelID int32 `json:"channel_id"` + PacketHash []byte `json:"packet_hash"` + SenderName *string `json:"sender_name"` + SenderPubkey []byte `json:"sender_pubkey"` + Content *string `json:"content"` + SentAt pgtype.Timestamptz `json:"sent_at"` + PacketHashHex string `json:"packet_hash_hex"` + ChannelHash []byte `json:"channel_hash"` + ScopeName *string `json:"scope_name"` + TransportCodesPresent *bool `json:"transport_codes_present"` + ObservationCount int64 `json:"observation_count"` +} + +// Every channel filtered by scope alone: the scope's newest message ids from the read model. +func (q *Queries) ListAllChannelMessagesPlainScoped(ctx context.Context, arg ListAllChannelMessagesPlainScopedParams) ([]ListAllChannelMessagesPlainScopedRow, error) { + rows, err := q.db.Query(ctx, listAllChannelMessagesPlainScoped, arg.ScopeID, arg.CursorID, arg.PageLimit) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListAllChannelMessagesPlainScopedRow{} + for rows.Next() { + var i ListAllChannelMessagesPlainScopedRow + if err := rows.Scan( + &i.ID, + &i.ChannelID, + &i.PacketHash, + &i.SenderName, + &i.SenderPubkey, + &i.Content, + &i.SentAt, + &i.PacketHashHex, + &i.ChannelHash, + &i.ScopeName, + &i.TransportCodesPresent, + &i.ObservationCount, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listAllChannelMessagesSince = `-- name: ListAllChannelMessagesSince :many +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM channel_messages cm +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +WHERE cm.sent_at >= $1::timestamptz + AND ($2::int IS NULL OR p.scope_id = $2::int) + AND cm.id < $3::bigint + AND EXISTS (SELECT 1 FROM packet_observations po WHERE po.packet_hash = cm.packet_hash) +ORDER BY cm.id DESC +LIMIT $4 +` + +type ListAllChannelMessagesSinceParams struct { + Since pgtype.Timestamptz `json:"since"` + ScopeID *int32 `json:"scope_id"` + CursorID int64 `json:"cursor_id"` + PageLimit int32 `json:"page_limit"` +} + +type ListAllChannelMessagesSinceRow struct { + ID int64 `json:"id"` + ChannelID int32 `json:"channel_id"` + PacketHash []byte `json:"packet_hash"` + SenderName *string `json:"sender_name"` + SenderPubkey []byte `json:"sender_pubkey"` + Content *string `json:"content"` + SentAt pgtype.Timestamptz `json:"sent_at"` + PacketHashHex string `json:"packet_hash_hex"` + ChannelHash []byte `json:"channel_hash"` + ScopeName *string `json:"scope_name"` + TransportCodesPresent *bool `json:"transport_codes_present"` + ObservationCount int64 `json:"observation_count"` +} + +// Every channel with since, optionally by scope (no sites): a walk by id. +func (q *Queries) ListAllChannelMessagesSince(ctx context.Context, arg ListAllChannelMessagesSinceParams) ([]ListAllChannelMessagesSinceRow, error) { + rows, err := q.db.Query(ctx, listAllChannelMessagesSince, + arg.Since, + arg.ScopeID, + arg.CursorID, + arg.PageLimit, + ) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListAllChannelMessagesSinceRow{} + for rows.Next() { + var i ListAllChannelMessagesSinceRow + if err := rows.Scan( + &i.ID, + &i.ChannelID, + &i.PacketHash, + &i.SenderName, + &i.SenderPubkey, + &i.Content, + &i.SentAt, + &i.PacketHashHex, + &i.ChannelHash, + &i.ScopeName, + &i.TransportCodesPresent, + &i.ObservationCount, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listChannelMessageIATASamples = `-- name: ListChannelMessageIATASamples :many +SELECT i.channel_id, i.iata, count(*)::bigint AS n +FROM channel_message_iatas i +WHERE i.message_id > $1::bigint +GROUP BY i.channel_id, i.iata +ORDER BY n DESC, i.channel_id, i.iata +LIMIT $2 +` + +type ListChannelMessageIATASamplesParams struct { + AfterID int64 `json:"after_id"` + RowLimit int32 `json:"row_limit"` +} + +type ListChannelMessageIATASamplesRow struct { + ChannelID int32 `json:"channel_id"` + Iata string `json:"iata"` + N int64 `json:"n"` +} + +// The busiest (channel, site) pairs among recent messages; the first-time verification compares their pages. +func (q *Queries) ListChannelMessageIATASamples(ctx context.Context, arg ListChannelMessageIATASamplesParams) ([]ListChannelMessageIATASamplesRow, error) { + rows, err := q.db.Query(ctx, listChannelMessageIATASamples, arg.AfterID, arg.RowLimit) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListChannelMessageIATASamplesRow{} + for rows.Next() { + var i ListChannelMessageIATASamplesRow + if err := rows.Scan(&i.ChannelID, &i.Iata, &i.N); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listChannelMessageScopeSamples = `-- name: ListChannelMessageScopeSamples :many +SELECT i.channel_id, i.scope_id, ts.name, count(*)::bigint AS n +FROM channel_message_iatas i +JOIN transport_scopes ts ON ts.id = i.scope_id +WHERE i.message_id > $1::bigint AND i.scope_id IS NOT NULL +GROUP BY i.channel_id, i.scope_id, ts.name +ORDER BY n DESC, i.channel_id, i.scope_id +LIMIT $2 +` + +type ListChannelMessageScopeSamplesParams struct { + AfterID int64 `json:"after_id"` + RowLimit int32 `json:"row_limit"` +} + +type ListChannelMessageScopeSamplesRow struct { + ChannelID int32 `json:"channel_id"` + ScopeID *int32 `json:"scope_id"` + Name string `json:"name"` + N int64 `json:"n"` +} + +// The busiest (channel, scope) pairs among recent messages, with the scope name today's statement filters on. +func (q *Queries) ListChannelMessageScopeSamples(ctx context.Context, arg ListChannelMessageScopeSamplesParams) ([]ListChannelMessageScopeSamplesRow, error) { + rows, err := q.db.Query(ctx, listChannelMessageScopeSamples, arg.AfterID, arg.RowLimit) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListChannelMessageScopeSamplesRow{} + for rows.Next() { + var i ListChannelMessageScopeSamplesRow + if err := rows.Scan( + &i.ChannelID, + &i.ScopeID, + &i.Name, + &i.N, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listChannelMessagesByIATAs = `-- name: ListChannelMessagesByIATAs :many +WITH hits AS MATERIALIZED ( + SELECT m.message_id + FROM unnest($1::bpchar[]) AS req(iata) + CROSS JOIN LATERAL ( + SELECT i.message_id FROM channel_message_iatas i + WHERE i.channel_id = $2::int AND i.iata = req.iata + AND i.message_id < $3::bigint + ORDER BY i.message_id DESC + LIMIT $4) m + GROUP BY m.message_id + ORDER BY m.message_id DESC + LIMIT $4) +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM hits h +JOIN channel_messages cm ON cm.id = h.message_id +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +ORDER BY cm.id DESC +` + +type ListChannelMessagesByIATAsParams struct { + Iatas []string `json:"iatas"` + ChannelID int32 `json:"channel_id"` + CursorID int64 `json:"cursor_id"` + PageLimit int32 `json:"page_limit"` +} + +type ListChannelMessagesByIATAsRow struct { + ID int64 `json:"id"` + ChannelID int32 `json:"channel_id"` + PacketHash []byte `json:"packet_hash"` + SenderName *string `json:"sender_name"` + SenderPubkey []byte `json:"sender_pubkey"` + Content *string `json:"content"` + SentAt pgtype.Timestamptz `json:"sent_at"` + PacketHashHex string `json:"packet_hash_hex"` + ChannelHash []byte `json:"channel_hash"` + ScopeName *string `json:"scope_name"` + TransportCodesPresent *bool `json:"transport_codes_present"` + ObservationCount int64 `json:"observation_count"` +} + +// One channel filtered by sites: each site's newest message ids from the read model, merged. +func (q *Queries) ListChannelMessagesByIATAs(ctx context.Context, arg ListChannelMessagesByIATAsParams) ([]ListChannelMessagesByIATAsRow, error) { + rows, err := q.db.Query(ctx, listChannelMessagesByIATAs, + arg.Iatas, + arg.ChannelID, + arg.CursorID, + arg.PageLimit, + ) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListChannelMessagesByIATAsRow{} + for rows.Next() { + var i ListChannelMessagesByIATAsRow + if err := rows.Scan( + &i.ID, + &i.ChannelID, + &i.PacketHash, + &i.SenderName, + &i.SenderPubkey, + &i.Content, + &i.SentAt, + &i.PacketHashHex, + &i.ChannelHash, + &i.ScopeName, + &i.TransportCodesPresent, + &i.ObservationCount, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listChannelMessagesByIATAsScoped = `-- name: ListChannelMessagesByIATAsScoped :many +WITH hits AS MATERIALIZED ( + SELECT m.message_id + FROM unnest($1::bpchar[]) AS req(iata) + CROSS JOIN LATERAL ( + SELECT i.message_id FROM channel_message_iatas i + WHERE i.channel_id = $2::int AND i.iata = req.iata AND i.scope_id = $3::int + AND i.message_id < $4::bigint + ORDER BY i.message_id DESC + LIMIT $5) m + GROUP BY m.message_id + ORDER BY m.message_id DESC + LIMIT $5) +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM hits h +JOIN channel_messages cm ON cm.id = h.message_id +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +ORDER BY cm.id DESC +` + +type ListChannelMessagesByIATAsScopedParams struct { + Iatas []string `json:"iatas"` + ChannelID int32 `json:"channel_id"` + ScopeID int32 `json:"scope_id"` + CursorID int64 `json:"cursor_id"` + PageLimit int32 `json:"page_limit"` +} + +type ListChannelMessagesByIATAsScopedRow struct { + ID int64 `json:"id"` + ChannelID int32 `json:"channel_id"` + PacketHash []byte `json:"packet_hash"` + SenderName *string `json:"sender_name"` + SenderPubkey []byte `json:"sender_pubkey"` + Content *string `json:"content"` + SentAt pgtype.Timestamptz `json:"sent_at"` + PacketHashHex string `json:"packet_hash_hex"` + ChannelHash []byte `json:"channel_hash"` + ScopeName *string `json:"scope_name"` + TransportCodesPresent *bool `json:"transport_codes_present"` + ObservationCount int64 `json:"observation_count"` +} + +// One channel filtered by sites and scope. +func (q *Queries) ListChannelMessagesByIATAsScoped(ctx context.Context, arg ListChannelMessagesByIATAsScopedParams) ([]ListChannelMessagesByIATAsScopedRow, error) { + rows, err := q.db.Query(ctx, listChannelMessagesByIATAsScoped, + arg.Iatas, + arg.ChannelID, + arg.ScopeID, + arg.CursorID, + arg.PageLimit, + ) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListChannelMessagesByIATAsScopedRow{} + for rows.Next() { + var i ListChannelMessagesByIATAsScopedRow + if err := rows.Scan( + &i.ID, + &i.ChannelID, + &i.PacketHash, + &i.SenderName, + &i.SenderPubkey, + &i.Content, + &i.SentAt, + &i.PacketHashHex, + &i.ChannelHash, + &i.ScopeName, + &i.TransportCodesPresent, + &i.ObservationCount, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listChannelMessagesPlain = `-- name: ListChannelMessagesPlain :many +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM channel_messages cm +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +WHERE cm.channel_id = $1::int AND cm.id < $2::bigint + AND EXISTS (SELECT 1 FROM packet_observations po WHERE po.packet_hash = cm.packet_hash) +ORDER BY cm.id DESC +LIMIT $3 +` + +type ListChannelMessagesPlainParams struct { + ChannelID int32 `json:"channel_id"` + CursorID int64 `json:"cursor_id"` + PageLimit int32 `json:"page_limit"` +} + +type ListChannelMessagesPlainRow struct { + ID int64 `json:"id"` + ChannelID int32 `json:"channel_id"` + PacketHash []byte `json:"packet_hash"` + SenderName *string `json:"sender_name"` + SenderPubkey []byte `json:"sender_pubkey"` + Content *string `json:"content"` + SentAt pgtype.Timestamptz `json:"sent_at"` + PacketHashHex string `json:"packet_hash_hex"` + ChannelHash []byte `json:"channel_hash"` + ScopeName *string `json:"scope_name"` + TransportCodesPresent *bool `json:"transport_codes_present"` + ObservationCount int64 `json:"observation_count"` +} + +// One channel, unfiltered: a walk of the channel by id; a message counts once it has a stored observation. +func (q *Queries) ListChannelMessagesPlain(ctx context.Context, arg ListChannelMessagesPlainParams) ([]ListChannelMessagesPlainRow, error) { + rows, err := q.db.Query(ctx, listChannelMessagesPlain, arg.ChannelID, arg.CursorID, arg.PageLimit) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListChannelMessagesPlainRow{} + for rows.Next() { + var i ListChannelMessagesPlainRow + if err := rows.Scan( + &i.ID, + &i.ChannelID, + &i.PacketHash, + &i.SenderName, + &i.SenderPubkey, + &i.Content, + &i.SentAt, + &i.PacketHashHex, + &i.ChannelHash, + &i.ScopeName, + &i.TransportCodesPresent, + &i.ObservationCount, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listChannelMessagesPlainScoped = `-- name: ListChannelMessagesPlainScoped :many +WITH hits AS MATERIALIZED ( + SELECT DISTINCT i.message_id + FROM channel_message_iatas i + WHERE i.channel_id = $1::int AND i.scope_id = $2::int AND i.message_id < $3::bigint + ORDER BY i.message_id DESC + LIMIT $4) +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM hits h +JOIN channel_messages cm ON cm.id = h.message_id +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +ORDER BY cm.id DESC +` + +type ListChannelMessagesPlainScopedParams struct { + ChannelID int32 `json:"channel_id"` + ScopeID int32 `json:"scope_id"` + CursorID int64 `json:"cursor_id"` + PageLimit int32 `json:"page_limit"` +} + +type ListChannelMessagesPlainScopedRow struct { + ID int64 `json:"id"` + ChannelID int32 `json:"channel_id"` + PacketHash []byte `json:"packet_hash"` + SenderName *string `json:"sender_name"` + SenderPubkey []byte `json:"sender_pubkey"` + Content *string `json:"content"` + SentAt pgtype.Timestamptz `json:"sent_at"` + PacketHashHex string `json:"packet_hash_hex"` + ChannelHash []byte `json:"channel_hash"` + ScopeName *string `json:"scope_name"` + TransportCodesPresent *bool `json:"transport_codes_present"` + ObservationCount int64 `json:"observation_count"` +} + +// One channel and scope: the read model has a row exactly when the message has a stored observation. +func (q *Queries) ListChannelMessagesPlainScoped(ctx context.Context, arg ListChannelMessagesPlainScopedParams) ([]ListChannelMessagesPlainScopedRow, error) { + rows, err := q.db.Query(ctx, listChannelMessagesPlainScoped, + arg.ChannelID, + arg.ScopeID, + arg.CursorID, + arg.PageLimit, + ) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListChannelMessagesPlainScopedRow{} + for rows.Next() { + var i ListChannelMessagesPlainScopedRow + if err := rows.Scan( + &i.ID, + &i.ChannelID, + &i.PacketHash, + &i.SenderName, + &i.SenderPubkey, + &i.Content, + &i.SentAt, + &i.PacketHashHex, + &i.ChannelHash, + &i.ScopeName, + &i.TransportCodesPresent, + &i.ObservationCount, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listChannelMessagesSinceWalk = `-- name: ListChannelMessagesSinceWalk :many +SELECT cm.id, cm.channel_id, cm.packet_hash, cm.sender_name, cm.sender_pubkey, cm.content, cm.sent_at, + encode(cm.packet_hash, 'hex') AS packet_hash_hex, c.channel_hash, ts.name AS scope_name, + p.transport_codes_present, p.observation_count AS observation_count +FROM channel_messages cm +JOIN channels c ON c.id = cm.channel_id +JOIN packets p ON p.packet_hash = cm.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +WHERE cm.channel_id = $1::int + AND cm.sent_at >= $2::timestamptz + AND EXISTS (SELECT 1 FROM packet_observations po WHERE po.packet_hash = cm.packet_hash) + AND (COALESCE(cardinality($3::bpchar[]), 0) = 0 + OR EXISTS (SELECT 1 FROM channel_message_iatas i WHERE i.message_id = cm.id AND i.iata = ANY($3::bpchar[]))) + AND ($4::int IS NULL OR p.scope_id = $4::int) + AND cm.id < $5::bigint +ORDER BY cm.id DESC +LIMIT $6 +` + +type ListChannelMessagesSinceWalkParams struct { + ChannelID int32 `json:"channel_id"` + Since pgtype.Timestamptz `json:"since"` + Iatas []string `json:"iatas"` + ScopeID *int32 `json:"scope_id"` + CursorID int64 `json:"cursor_id"` + PageLimit int32 `json:"page_limit"` +} + +type ListChannelMessagesSinceWalkRow struct { + ID int64 `json:"id"` + ChannelID int32 `json:"channel_id"` + PacketHash []byte `json:"packet_hash"` + SenderName *string `json:"sender_name"` + SenderPubkey []byte `json:"sender_pubkey"` + Content *string `json:"content"` + SentAt pgtype.Timestamptz `json:"sent_at"` + PacketHashHex string `json:"packet_hash_hex"` + ChannelHash []byte `json:"channel_hash"` + ScopeName *string `json:"scope_name"` + TransportCodesPresent *bool `json:"transport_codes_present"` + ObservationCount int64 `json:"observation_count"` +} + +// One channel with since (no client sends it): a channel walk; sites filter through the read model. +func (q *Queries) ListChannelMessagesSinceWalk(ctx context.Context, arg ListChannelMessagesSinceWalkParams) ([]ListChannelMessagesSinceWalkRow, error) { + rows, err := q.db.Query(ctx, listChannelMessagesSinceWalk, + arg.ChannelID, + arg.Since, + arg.Iatas, + arg.ScopeID, + arg.CursorID, + arg.PageLimit, + ) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListChannelMessagesSinceWalkRow{} + for rows.Next() { + var i ListChannelMessagesSinceWalkRow + if err := rows.Scan( + &i.ID, + &i.ChannelID, + &i.PacketHash, + &i.SenderName, + &i.SenderPubkey, + &i.Content, + &i.SentAt, + &i.PacketHashHex, + &i.ChannelHash, + &i.ScopeName, + &i.TransportCodesPresent, + &i.ObservationCount, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const maxChannelMessageID = `-- name: MaxChannelMessageID :one +SELECT COALESCE(max(id), 0)::bigint AS id FROM channel_messages +` + +func (q *Queries) MaxChannelMessageID(ctx context.Context) (int64, error) { + row := q.db.QueryRow(ctx, maxChannelMessageID) + var id int64 + err := row.Scan(&id) + return id, err +} + +const maxObservationID = `-- name: MaxObservationID :one +SELECT COALESCE(max(id), 0)::bigint AS id FROM packet_observations +` + +func (q *Queries) MaxObservationID(ctx context.Context) (int64, error) { + row := q.db.QueryRow(ctx, maxObservationID) + var id int64 + err := row.Scan(&id) + return id, err +} + +const nextChannelMessageID = `-- name: NextChannelMessageID :one +SELECT COALESCE(min(id), 0)::bigint AS id FROM channel_messages WHERE id > $1::bigint +` + +// The first message id above after_id, or 0 when there is none. +func (q *Queries) NextChannelMessageID(ctx context.Context, afterID int64) (int64, error) { + row := q.db.QueryRow(ctx, nextChannelMessageID, afterID) + var id int64 + err := row.Scan(&id) + return id, err +} diff --git a/db/sqlc/mock/querier.go b/db/sqlc/mock/querier.go index 22607b7..62177eb 100644 --- a/db/sqlc/mock/querier.go +++ b/db/sqlc/mock/querier.go @@ -72,6 +72,21 @@ func (mr *MockQuerierMockRecorder) AddChannelMembers(ctx, arg any) *gomock.Call return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChannelMembers", reflect.TypeOf((*MockQuerier)(nil).AddChannelMembers), ctx, arg) } +// AddChannelMessageIATA mocks base method. +func (m *MockQuerier) AddChannelMessageIATA(ctx context.Context, arg db.AddChannelMessageIATAParams) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddChannelMessageIATA", ctx, arg) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddChannelMessageIATA indicates an expected call of AddChannelMessageIATA. +func (mr *MockQuerierMockRecorder) AddChannelMessageIATA(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChannelMessageIATA", reflect.TypeOf((*MockQuerier)(nil).AddChannelMessageIATA), ctx, arg) +} + // AddIATAs mocks base method. func (m *MockQuerier) AddIATAs(ctx context.Context, iatas []string) error { m.ctrl.T.Helper() @@ -115,6 +130,21 @@ func (mr *MockQuerierMockRecorder) BackfillObservationPayloadTypes(ctx, arg any) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackfillObservationPayloadTypes", reflect.TypeOf((*MockQuerier)(nil).BackfillObservationPayloadTypes), ctx, arg) } +// CheckChannelMessageIATAs mocks base method. +func (m *MockQuerier) CheckChannelMessageIATAs(ctx context.Context, arg db.CheckChannelMessageIATAsParams) (db.CheckChannelMessageIATAsRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CheckChannelMessageIATAs", ctx, arg) + ret0, _ := ret[0].(db.CheckChannelMessageIATAsRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckChannelMessageIATAs indicates an expected call of CheckChannelMessageIATAs. +func (mr *MockQuerierMockRecorder) CheckChannelMessageIATAs(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckChannelMessageIATAs", reflect.TypeOf((*MockQuerier)(nil).CheckChannelMessageIATAs), ctx, arg) +} + // ClearRepeaters mocks base method. func (m *MockQuerier) ClearRepeaters(ctx context.Context) (int64, error) { m.ctrl.T.Helper() @@ -402,6 +432,36 @@ func (mr *MockQuerierMockRecorder) DeleteStaleDirtyHours(ctx any) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStaleDirtyHours", reflect.TypeOf((*MockQuerier)(nil).DeleteStaleDirtyHours), ctx) } +// FillChannelMessageIATAsByMessages mocks base method. +func (m *MockQuerier) FillChannelMessageIATAsByMessages(ctx context.Context, arg db.FillChannelMessageIATAsByMessagesParams) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FillChannelMessageIATAsByMessages", ctx, arg) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FillChannelMessageIATAsByMessages indicates an expected call of FillChannelMessageIATAsByMessages. +func (mr *MockQuerierMockRecorder) FillChannelMessageIATAsByMessages(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FillChannelMessageIATAsByMessages", reflect.TypeOf((*MockQuerier)(nil).FillChannelMessageIATAsByMessages), ctx, arg) +} + +// FillChannelMessageIATAsByObservations mocks base method. +func (m *MockQuerier) FillChannelMessageIATAsByObservations(ctx context.Context, arg db.FillChannelMessageIATAsByObservationsParams) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FillChannelMessageIATAsByObservations", ctx, arg) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FillChannelMessageIATAsByObservations indicates an expected call of FillChannelMessageIATAsByObservations. +func (mr *MockQuerierMockRecorder) FillChannelMessageIATAsByObservations(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FillChannelMessageIATAsByObservations", reflect.TypeOf((*MockQuerier)(nil).FillChannelMessageIATAsByObservations), ctx, arg) +} + // FillReconfirmAmb mocks base method. func (m *MockQuerier) FillReconfirmAmb(ctx context.Context) error { m.ctrl.T.Helper() @@ -490,6 +550,21 @@ func (mr *MockQuerierMockRecorder) GetBackgroundState(ctx, key any) *gomock.Call return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBackgroundState", reflect.TypeOf((*MockQuerier)(nil).GetBackgroundState), ctx, key) } +// GetBackgroundStateAge mocks base method. +func (m *MockQuerier) GetBackgroundStateAge(ctx context.Context, key string) (db.GetBackgroundStateAgeRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBackgroundStateAge", ctx, key) + ret0, _ := ret[0].(db.GetBackgroundStateAgeRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBackgroundStateAge indicates an expected call of GetBackgroundStateAge. +func (mr *MockQuerierMockRecorder) GetBackgroundStateAge(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBackgroundStateAge", reflect.TypeOf((*MockQuerier)(nil).GetBackgroundStateAge), ctx, key) +} + // GetChannelByID mocks base method. func (m *MockQuerier) GetChannelByID(ctx context.Context, id int32) (db.Channel, error) { m.ctrl.T.Helper() @@ -1360,6 +1435,21 @@ func (mr *MockQuerierMockRecorder) InsertChannelMessage(ctx, arg any) *gomock.Ca return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertChannelMessage", reflect.TypeOf((*MockQuerier)(nil).InsertChannelMessage), ctx, arg) } +// InsertChannelMessageUnseeded mocks base method. +func (m *MockQuerier) InsertChannelMessageUnseeded(ctx context.Context, arg db.InsertChannelMessageUnseededParams) (db.InsertChannelMessageUnseededRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InsertChannelMessageUnseeded", ctx, arg) + ret0, _ := ret[0].(db.InsertChannelMessageUnseededRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// InsertChannelMessageUnseeded indicates an expected call of InsertChannelMessageUnseeded. +func (mr *MockQuerierMockRecorder) InsertChannelMessageUnseeded(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertChannelMessageUnseeded", reflect.TypeOf((*MockQuerier)(nil).InsertChannelMessageUnseeded), ctx, arg) +} + // InsertObservation mocks base method. func (m *MockQuerier) InsertObservation(ctx context.Context, arg db.InsertObservationParams) (db.InsertObservationRow, error) { m.ctrl.T.Helper() @@ -1419,6 +1509,66 @@ func (mr *MockQuerierMockRecorder) ListAllChannelMessages(ctx, arg any) *gomock. return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllChannelMessages", reflect.TypeOf((*MockQuerier)(nil).ListAllChannelMessages), ctx, arg) } +// ListAllChannelMessagesByIATAs mocks base method. +func (m *MockQuerier) ListAllChannelMessagesByIATAs(ctx context.Context, arg db.ListAllChannelMessagesByIATAsParams) ([]db.ListAllChannelMessagesByIATAsRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAllChannelMessagesByIATAs", ctx, arg) + ret0, _ := ret[0].([]db.ListAllChannelMessagesByIATAsRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAllChannelMessagesByIATAs indicates an expected call of ListAllChannelMessagesByIATAs. +func (mr *MockQuerierMockRecorder) ListAllChannelMessagesByIATAs(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllChannelMessagesByIATAs", reflect.TypeOf((*MockQuerier)(nil).ListAllChannelMessagesByIATAs), ctx, arg) +} + +// ListAllChannelMessagesPlain mocks base method. +func (m *MockQuerier) ListAllChannelMessagesPlain(ctx context.Context, arg db.ListAllChannelMessagesPlainParams) ([]db.ListAllChannelMessagesPlainRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAllChannelMessagesPlain", ctx, arg) + ret0, _ := ret[0].([]db.ListAllChannelMessagesPlainRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAllChannelMessagesPlain indicates an expected call of ListAllChannelMessagesPlain. +func (mr *MockQuerierMockRecorder) ListAllChannelMessagesPlain(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllChannelMessagesPlain", reflect.TypeOf((*MockQuerier)(nil).ListAllChannelMessagesPlain), ctx, arg) +} + +// ListAllChannelMessagesPlainScoped mocks base method. +func (m *MockQuerier) ListAllChannelMessagesPlainScoped(ctx context.Context, arg db.ListAllChannelMessagesPlainScopedParams) ([]db.ListAllChannelMessagesPlainScopedRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAllChannelMessagesPlainScoped", ctx, arg) + ret0, _ := ret[0].([]db.ListAllChannelMessagesPlainScopedRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAllChannelMessagesPlainScoped indicates an expected call of ListAllChannelMessagesPlainScoped. +func (mr *MockQuerierMockRecorder) ListAllChannelMessagesPlainScoped(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllChannelMessagesPlainScoped", reflect.TypeOf((*MockQuerier)(nil).ListAllChannelMessagesPlainScoped), ctx, arg) +} + +// ListAllChannelMessagesSince mocks base method. +func (m *MockQuerier) ListAllChannelMessagesSince(ctx context.Context, arg db.ListAllChannelMessagesSinceParams) ([]db.ListAllChannelMessagesSinceRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAllChannelMessagesSince", ctx, arg) + ret0, _ := ret[0].([]db.ListAllChannelMessagesSinceRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAllChannelMessagesSince indicates an expected call of ListAllChannelMessagesSince. +func (mr *MockQuerierMockRecorder) ListAllChannelMessagesSince(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllChannelMessagesSince", reflect.TypeOf((*MockQuerier)(nil).ListAllChannelMessagesSince), ctx, arg) +} + // ListChannelCatalogues mocks base method. func (m *MockQuerier) ListChannelCatalogues(ctx context.Context) ([]db.MeshmapperChannelCatalogue, error) { m.ctrl.T.Helper() @@ -1449,6 +1599,36 @@ func (mr *MockQuerierMockRecorder) ListChannelIDs(ctx any) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelIDs", reflect.TypeOf((*MockQuerier)(nil).ListChannelIDs), ctx) } +// ListChannelMessageIATASamples mocks base method. +func (m *MockQuerier) ListChannelMessageIATASamples(ctx context.Context, arg db.ListChannelMessageIATASamplesParams) ([]db.ListChannelMessageIATASamplesRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListChannelMessageIATASamples", ctx, arg) + ret0, _ := ret[0].([]db.ListChannelMessageIATASamplesRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListChannelMessageIATASamples indicates an expected call of ListChannelMessageIATASamples. +func (mr *MockQuerierMockRecorder) ListChannelMessageIATASamples(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelMessageIATASamples", reflect.TypeOf((*MockQuerier)(nil).ListChannelMessageIATASamples), ctx, arg) +} + +// ListChannelMessageScopeSamples mocks base method. +func (m *MockQuerier) ListChannelMessageScopeSamples(ctx context.Context, arg db.ListChannelMessageScopeSamplesParams) ([]db.ListChannelMessageScopeSamplesRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListChannelMessageScopeSamples", ctx, arg) + ret0, _ := ret[0].([]db.ListChannelMessageScopeSamplesRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListChannelMessageScopeSamples indicates an expected call of ListChannelMessageScopeSamples. +func (mr *MockQuerierMockRecorder) ListChannelMessageScopeSamples(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelMessageScopeSamples", reflect.TypeOf((*MockQuerier)(nil).ListChannelMessageScopeSamples), ctx, arg) +} + // ListChannelMessages mocks base method. func (m *MockQuerier) ListChannelMessages(ctx context.Context, arg db.ListChannelMessagesParams) ([]db.ListChannelMessagesRow, error) { m.ctrl.T.Helper() @@ -1479,6 +1659,81 @@ func (mr *MockQuerierMockRecorder) ListChannelMessagesByHash(ctx, arg any) *gomo return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelMessagesByHash", reflect.TypeOf((*MockQuerier)(nil).ListChannelMessagesByHash), ctx, arg) } +// ListChannelMessagesByIATAs mocks base method. +func (m *MockQuerier) ListChannelMessagesByIATAs(ctx context.Context, arg db.ListChannelMessagesByIATAsParams) ([]db.ListChannelMessagesByIATAsRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListChannelMessagesByIATAs", ctx, arg) + ret0, _ := ret[0].([]db.ListChannelMessagesByIATAsRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListChannelMessagesByIATAs indicates an expected call of ListChannelMessagesByIATAs. +func (mr *MockQuerierMockRecorder) ListChannelMessagesByIATAs(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelMessagesByIATAs", reflect.TypeOf((*MockQuerier)(nil).ListChannelMessagesByIATAs), ctx, arg) +} + +// ListChannelMessagesByIATAsScoped mocks base method. +func (m *MockQuerier) ListChannelMessagesByIATAsScoped(ctx context.Context, arg db.ListChannelMessagesByIATAsScopedParams) ([]db.ListChannelMessagesByIATAsScopedRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListChannelMessagesByIATAsScoped", ctx, arg) + ret0, _ := ret[0].([]db.ListChannelMessagesByIATAsScopedRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListChannelMessagesByIATAsScoped indicates an expected call of ListChannelMessagesByIATAsScoped. +func (mr *MockQuerierMockRecorder) ListChannelMessagesByIATAsScoped(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelMessagesByIATAsScoped", reflect.TypeOf((*MockQuerier)(nil).ListChannelMessagesByIATAsScoped), ctx, arg) +} + +// ListChannelMessagesPlain mocks base method. +func (m *MockQuerier) ListChannelMessagesPlain(ctx context.Context, arg db.ListChannelMessagesPlainParams) ([]db.ListChannelMessagesPlainRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListChannelMessagesPlain", ctx, arg) + ret0, _ := ret[0].([]db.ListChannelMessagesPlainRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListChannelMessagesPlain indicates an expected call of ListChannelMessagesPlain. +func (mr *MockQuerierMockRecorder) ListChannelMessagesPlain(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelMessagesPlain", reflect.TypeOf((*MockQuerier)(nil).ListChannelMessagesPlain), ctx, arg) +} + +// ListChannelMessagesPlainScoped mocks base method. +func (m *MockQuerier) ListChannelMessagesPlainScoped(ctx context.Context, arg db.ListChannelMessagesPlainScopedParams) ([]db.ListChannelMessagesPlainScopedRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListChannelMessagesPlainScoped", ctx, arg) + ret0, _ := ret[0].([]db.ListChannelMessagesPlainScopedRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListChannelMessagesPlainScoped indicates an expected call of ListChannelMessagesPlainScoped. +func (mr *MockQuerierMockRecorder) ListChannelMessagesPlainScoped(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelMessagesPlainScoped", reflect.TypeOf((*MockQuerier)(nil).ListChannelMessagesPlainScoped), ctx, arg) +} + +// ListChannelMessagesSinceWalk mocks base method. +func (m *MockQuerier) ListChannelMessagesSinceWalk(ctx context.Context, arg db.ListChannelMessagesSinceWalkParams) ([]db.ListChannelMessagesSinceWalkRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListChannelMessagesSinceWalk", ctx, arg) + ret0, _ := ret[0].([]db.ListChannelMessagesSinceWalkRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListChannelMessagesSinceWalk indicates an expected call of ListChannelMessagesSinceWalk. +func (mr *MockQuerierMockRecorder) ListChannelMessagesSinceWalk(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelMessagesSinceWalk", reflect.TypeOf((*MockQuerier)(nil).ListChannelMessagesSinceWalk), ctx, arg) +} + // ListChannels mocks base method. func (m *MockQuerier) ListChannels(ctx context.Context, arg db.ListChannelsParams) ([]db.Channel, error) { m.ctrl.T.Helper() @@ -2048,6 +2303,51 @@ func (mr *MockQuerierMockRecorder) MarkPartialRollupHours(ctx any) *gomock.Call return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkPartialRollupHours", reflect.TypeOf((*MockQuerier)(nil).MarkPartialRollupHours), ctx) } +// MaxChannelMessageID mocks base method. +func (m *MockQuerier) MaxChannelMessageID(ctx context.Context) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MaxChannelMessageID", ctx) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// MaxChannelMessageID indicates an expected call of MaxChannelMessageID. +func (mr *MockQuerierMockRecorder) MaxChannelMessageID(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaxChannelMessageID", reflect.TypeOf((*MockQuerier)(nil).MaxChannelMessageID), ctx) +} + +// MaxObservationID mocks base method. +func (m *MockQuerier) MaxObservationID(ctx context.Context) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MaxObservationID", ctx) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// MaxObservationID indicates an expected call of MaxObservationID. +func (mr *MockQuerierMockRecorder) MaxObservationID(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaxObservationID", reflect.TypeOf((*MockQuerier)(nil).MaxObservationID), ctx) +} + +// NextChannelMessageID mocks base method. +func (m *MockQuerier) NextChannelMessageID(ctx context.Context, afterID int64) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NextChannelMessageID", ctx, afterID) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// NextChannelMessageID indicates an expected call of NextChannelMessageID. +func (mr *MockQuerierMockRecorder) NextChannelMessageID(ctx, afterID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NextChannelMessageID", reflect.TypeOf((*MockQuerier)(nil).NextChannelMessageID), ctx, afterID) +} + // OldestMissingRollupHour mocks base method. func (m *MockQuerier) OldestMissingRollupHour(ctx context.Context) (pgtype.Timestamptz, error) { m.ctrl.T.Helper() diff --git a/db/sqlc/models.go b/db/sqlc/models.go index 5b525c1..cf97956 100644 --- a/db/sqlc/models.go +++ b/db/sqlc/models.go @@ -202,6 +202,13 @@ type ChannelMessage struct { SentAt pgtype.Timestamptz `json:"sent_at"` } +type ChannelMessageIata struct { + MessageID int64 `json:"message_id"` + Iata string `json:"iata"` + ChannelID int32 `json:"channel_id"` + ScopeID *int32 `json:"scope_id"` +} + type IataCode struct { Iata string `json:"iata"` DisplayName *string `json:"display_name"` diff --git a/db/sqlc/querier.go b/db/sqlc/querier.go index 3644d6b..b121bc9 100644 --- a/db/sqlc/querier.go +++ b/db/sqlc/querier.go @@ -16,12 +16,20 @@ type Querier interface { // An empty region places the channel Beacon-wide. AddChannelConfigScopes(ctx context.Context, arg AddChannelConfigScopesParams) error AddChannelMembers(ctx context.Context, arg AddChannelMembersParams) error + // Copyright 2026 Beacon Contributors + // SPDX-License-Identifier: AGPL-3.0-or-later + // A stored observation's site for a message another statement created. A no-op when the packet has no message; + // found says whether the packet has a committed message (then the site is recorded, now or before). + AddChannelMessageIATA(ctx context.Context, arg AddChannelMessageIATAParams) (bool, error) AddIATAs(ctx context.Context, iatas []string) error AddRegionIATAs(ctx context.Context, arg AddRegionIATAsParams) error // Copies the packet's payload type onto the first @max_rows observations in [@from_id, @to_id), // in id order, that lack one. Rows that already carry a type are never touched. Returns how many // untyped rows it picked, how many it typed, and the last picked id (0 when it picked none). BackfillObservationPayloadTypes(ctx context.Context, arg BackfillObservationPayloadTypesParams) (BackfillObservationPayloadTypesRow, error) + // Exact check of messages in (after_id, through_id]: pairs the definition has and the table lacks (counting + // observations up to obs_through only), and table pairs no stored observation backs. + CheckChannelMessageIATAs(ctx context.Context, arg CheckChannelMessageIATAsParams) (CheckChannelMessageIATAsRow, error) // Keeps fetch timing so re-enabling still respects backoff; the ETag goes with the rows. ClearRepeaters(ctx context.Context) (int64, error) CreateAccount(ctx context.Context, name string) (Account, error) @@ -68,6 +76,11 @@ type Querier interface { DeleteRollupHour(ctx context.Context, hour pgtype.Timestamptz) error // Dirty hours that can no longer be re-rolled. DeleteStaleDirtyHours(ctx context.Context) error + // Every site of every message in (after_id, through_id]: the backfill and the reconcile's message part. + FillChannelMessageIATAsByMessages(ctx context.Context, arg FillChannelMessageIATAsByMessagesParams) (int64, error) + // The site of every group-text observation in (after_id, through_id] whose packet has a message. + // An untyped observation is checked too: older rows may have no payload type. + FillChannelMessageIATAsByObservations(ctx context.Context, arg FillChannelMessageIATAsByObservationsParams) (int64, error) // Hop prefixes that match >1 node in an IATA, per width, into the sweep's temp table. FillReconfirmAmb(ctx context.Context) error FillRollupObs(ctx context.Context, dollar_1 pgtype.Timestamptz) error @@ -77,6 +90,8 @@ type Querier interface { // Both counters only grow, so their sum changes whenever rolled content or coverage does. GetAnalyticsRevision(ctx context.Context) (int64, error) GetBackgroundState(ctx context.Context, key string) (json.RawMessage, error) + // A state with its age on the database clock: how long since its writer last saved it. + GetBackgroundStateAge(ctx context.Context, key string) (GetBackgroundStateAgeRow, error) GetChannelByID(ctx context.Context, id int32) (Channel, error) GetEarliestCompleteRollupHour(ctx context.Context) (pgtype.Timestamptz, error) // ============================================================ @@ -203,6 +218,9 @@ type Querier interface { // message_count is a lifetime count, bumped only for a new message. A historical (backfilled) // message queues its observation hours for a re-roll in the same statement, so the two can't diverge. InsertChannelMessage(ctx context.Context, arg InsertChannelMessageParams) (InsertChannelMessageRow, error) + // The seeded insert's fallback: the same statement without the site seed. The read-model + // reconcile adds the message's sites within one interval. + InsertChannelMessageUnseeded(ctx context.Context, arg InsertChannelMessageUnseededParams) (InsertChannelMessageUnseededRow, error) // ============================================================ // PACKET OBSERVATIONS // ============================================================ @@ -216,9 +234,21 @@ type Querier interface { // Pass empty string for iata or scope to skip those filters. // Pass cursor=0 to start from the beginning. ListAllChannelMessages(ctx context.Context, arg ListAllChannelMessagesParams) ([]ListAllChannelMessagesRow, error) + // Every channel filtered by sites: each site's newest message ids from the read model, merged. + ListAllChannelMessagesByIATAs(ctx context.Context, arg ListAllChannelMessagesByIATAsParams) ([]ListAllChannelMessagesByIATAsRow, error) + // Every channel, unfiltered: a walk by id; a message counts once it has a stored observation. + ListAllChannelMessagesPlain(ctx context.Context, arg ListAllChannelMessagesPlainParams) ([]ListAllChannelMessagesPlainRow, error) + // Every channel filtered by scope alone: the scope's newest message ids from the read model. + ListAllChannelMessagesPlainScoped(ctx context.Context, arg ListAllChannelMessagesPlainScopedParams) ([]ListAllChannelMessagesPlainScopedRow, error) + // Every channel with since, optionally by scope (no sites): a walk by id. + ListAllChannelMessagesSince(ctx context.Context, arg ListAllChannelMessagesSinceParams) ([]ListAllChannelMessagesSinceRow, error) ListChannelCatalogues(ctx context.Context) ([]MeshmapperChannelCatalogue, error) // Every channel key and its id, preloaded at boot for the ingest write-through. ListChannelIDs(ctx context.Context) ([]ListChannelIDsRow, error) + // The busiest (channel, site) pairs among recent messages; the first-time verification compares their pages. + ListChannelMessageIATASamples(ctx context.Context, arg ListChannelMessageIATASamplesParams) ([]ListChannelMessageIATASamplesRow, error) + // The busiest (channel, scope) pairs among recent messages, with the scope name today's statement filters on. + ListChannelMessageScopeSamples(ctx context.Context, arg ListChannelMessageScopeSamplesParams) ([]ListChannelMessageScopeSamplesRow, error) // Returns messages for a channel identified by integer ID. // Pass a zero/null timestamp for since to return all messages up to limit. // Pass empty string for iata to skip IATA filtering. @@ -229,6 +259,16 @@ type Querier interface { // Pass empty string for iata or scope to skip those filters. // Pass cursor=0 to start from the beginning. ListChannelMessagesByHash(ctx context.Context, arg ListChannelMessagesByHashParams) ([]ListChannelMessagesByHashRow, error) + // One channel filtered by sites: each site's newest message ids from the read model, merged. + ListChannelMessagesByIATAs(ctx context.Context, arg ListChannelMessagesByIATAsParams) ([]ListChannelMessagesByIATAsRow, error) + // One channel filtered by sites and scope. + ListChannelMessagesByIATAsScoped(ctx context.Context, arg ListChannelMessagesByIATAsScopedParams) ([]ListChannelMessagesByIATAsScopedRow, error) + // One channel, unfiltered: a walk of the channel by id; a message counts once it has a stored observation. + ListChannelMessagesPlain(ctx context.Context, arg ListChannelMessagesPlainParams) ([]ListChannelMessagesPlainRow, error) + // One channel and scope: the read model has a row exactly when the message has a stored observation. + ListChannelMessagesPlainScoped(ctx context.Context, arg ListChannelMessagesPlainScopedParams) ([]ListChannelMessagesPlainScopedRow, error) + // One channel with since (no client sends it): a channel walk; sites filter through the read model. + ListChannelMessagesSinceWalk(ctx context.Context, arg ListChannelMessagesSinceWalkParams) ([]ListChannelMessagesSinceWalkRow, error) // Channels ordered by last seen, optionally filtered by hash and/or IATAs. // A channel belongs to an IATA when MeshMapper lists it there or config scopes it // to a region containing it (or Beacon-wide). NULL hash / empty array / NULL key_known skip those filters. @@ -334,6 +374,10 @@ type Querier interface { // Hours whose raw rows cleanup already started deleting can never be rolled completely. // Readers report the new status, so the revision moves too. MarkPartialRollupHours(ctx context.Context) error + MaxChannelMessageID(ctx context.Context) (int64, error) + MaxObservationID(ctx context.Context) (int64, error) + // The first message id above after_id, or 0 when there is none. + NextChannelMessageID(ctx context.Context, afterID int64) (int64, error) OldestMissingRollupHour(ctx context.Context) (pgtype.Timestamptz, error) PruneImportedRegions(ctx context.Context, keep []string) ([]string, error) // Drops imports for IATAs no longer configured, so their manual border returns. diff --git a/db/sqlc/queries.sql.go b/db/sqlc/queries.sql.go index ed09c11..203f2b0 100644 --- a/db/sqlc/queries.sql.go +++ b/db/sqlc/queries.sql.go @@ -523,6 +523,23 @@ func (q *Queries) GetBackgroundState(ctx context.Context, key string) (json.RawM return value, err } +const getBackgroundStateAge = `-- name: GetBackgroundStateAge :one +SELECT value, extract(epoch FROM statement_timestamp() - updated_at)::float8 AS age_seconds FROM background_state WHERE key = $1 +` + +type GetBackgroundStateAgeRow struct { + Value json.RawMessage `json:"value"` + AgeSeconds float64 `json:"age_seconds"` +} + +// A state with its age on the database clock: how long since its writer last saved it. +func (q *Queries) GetBackgroundStateAge(ctx context.Context, key string) (GetBackgroundStateAgeRow, error) { + row := q.db.QueryRow(ctx, getBackgroundStateAge, key) + var i GetBackgroundStateAgeRow + err := row.Scan(&i.Value, &i.AgeSeconds) + return i, err +} + const getChannelByID = `-- name: GetChannelByID :one SELECT id, channel_hash, key_fingerprint, name, hashtag, is_hashtag, is_public, key_known, first_seen, last_seen, message_count FROM channels WHERE id = $1 ` @@ -2726,6 +2743,14 @@ WITH inserted AS ( FROM packet_observations po JOIN inserted i ON i.packet_hash = po.packet_hash WHERE $6::boolean ON CONFLICT (hour) DO UPDATE SET enqueued_at = now() +), seed AS ( + -- Every stored observation's site, in the same statement; a later observation adds its own site. + INSERT INTO channel_message_iatas (message_id, iata, channel_id, scope_id) + SELECT DISTINCT i.id, po.iata, i.channel_id, p.scope_id + FROM inserted i + JOIN packets p ON p.packet_hash = i.packet_hash + JOIN packet_observations po ON po.packet_hash = i.packet_hash + ON CONFLICT (message_id, iata) DO NOTHING ) SELECT inserted.id, ts.name AS scope_name, p.transport_codes_present FROM inserted @@ -2769,6 +2794,59 @@ func (q *Queries) InsertChannelMessage(ctx context.Context, arg InsertChannelMes return i, err } +const insertChannelMessageUnseeded = `-- name: InsertChannelMessageUnseeded :one +WITH inserted AS ( + INSERT INTO channel_messages (channel_id, packet_hash, sender_name, content, sent_at) + VALUES ($1, $2, $3, $4, $5) + ON CONFLICT (packet_hash) DO NOTHING + RETURNING id, packet_hash, channel_id +), bump AS ( + UPDATE channels c SET message_count = c.message_count + 1 + FROM inserted WHERE c.id = inserted.channel_id +), dirty AS ( + INSERT INTO analytics_dirty_hours (hour) + SELECT DISTINCT date_trunc('hour', po.heard_at, 'UTC') + FROM packet_observations po JOIN inserted i ON i.packet_hash = po.packet_hash + WHERE $6::boolean + ON CONFLICT (hour) DO UPDATE SET enqueued_at = now() +) +SELECT inserted.id, ts.name AS scope_name, p.transport_codes_present +FROM inserted +JOIN packets p ON p.packet_hash = inserted.packet_hash +LEFT JOIN transport_scopes ts ON ts.id = p.scope_id +` + +type InsertChannelMessageUnseededParams struct { + ChannelID int32 `json:"channel_id"` + PacketHash []byte `json:"packet_hash"` + SenderName *string `json:"sender_name"` + Content *string `json:"content"` + SentAt pgtype.Timestamptz `json:"sent_at"` + Column6 bool `json:"column_6"` +} + +type InsertChannelMessageUnseededRow struct { + ID int64 `json:"id"` + ScopeName *string `json:"scope_name"` + TransportCodesPresent *bool `json:"transport_codes_present"` +} + +// The seeded insert's fallback: the same statement without the site seed. The read-model +// reconcile adds the message's sites within one interval. +func (q *Queries) InsertChannelMessageUnseeded(ctx context.Context, arg InsertChannelMessageUnseededParams) (InsertChannelMessageUnseededRow, error) { + row := q.db.QueryRow(ctx, insertChannelMessageUnseeded, + arg.ChannelID, + arg.PacketHash, + arg.SenderName, + arg.Content, + arg.SentAt, + arg.Column6, + ) + var i InsertChannelMessageUnseededRow + err := row.Scan(&i.ID, &i.ScopeName, &i.TransportCodesPresent) + return i, err +} + const insertObservation = `-- name: InsertObservation :one WITH ins AS ( diff --git a/db/store.go b/db/store.go index c472a84..d5da87e 100644 --- a/db/store.go +++ b/db/store.go @@ -31,6 +31,7 @@ type Store struct { payloadTypeGate bool // see WithPayloadTypeGate payloadTypesDone atomic.Bool // the payload-type backfill state has read done payloadTypeWarnAt atomic.Int64 // unix ns of the last state-read Warn; see payloadTypesReady + readModels *ReadModels // see WithReadModels; nil serves every page from the original statements } // New creates a Store whose statements run on dbtx (a pool, or a PlanRouter for the API). diff --git a/internal/background/readmodel_cmi.go b/internal/background/readmodel_cmi.go new file mode 100644 index 0000000..08b6689 --- /dev/null +++ b/internal/background/readmodel_cmi.go @@ -0,0 +1,273 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package background + +import ( + "context" + "errors" + "fmt" + "log/slog" + "sync/atomic" + "time" + + "github.com/MeshCore-Beacon/beacon-server/db" + "github.com/MeshCore-Beacon/beacon-server/internal/metrics" +) + +// CmiInterval is how often channel_message_iatas is reconciled. +const CmiInterval = 5 * time.Minute + +const ( + cmiModel = "cmi" + cmiBackfillBudget = 30 * time.Second // per Backfill call, so a stop request is honoured between batches + cmiBusyRetry = 5 * time.Second +) + +// CmiSession is the part of db.CmiSession the jobs use. +type CmiSession interface { + State() db.CmiState + Init(ctx context.Context) (db.CmiState, error) + Reconcile(ctx context.Context) (int64, error) + Backfill(ctx context.Context, budget time.Duration) (db.CmiState, error) + Verify(ctx context.Context) (db.CmiVerification, error) + Close(ctx context.Context) +} + +// CmiJobs repairs channel_message_iatas at boot and every Interval, and decides this process's trust in it. +type CmiJobs struct { + Begin func(ctx context.Context) (CmiSession, bool, error) + Wait func(ctx context.Context) error // db.WaitForPreBootWriters bound to the boot timestamp + Trust *db.Trust + Interval time.Duration + + booted atomic.Bool + busyRetry time.Duration // 0 = cmiBusyRetry +} + +// sleep waits d or until ctx ends; it reports whether ctx is still live. +func sleep(ctx context.Context, d time.Duration) bool { + select { + case <-ctx.Done(): + return false + case <-time.After(d): + return true + } +} + +// Boot waits until no transaction from before boot can still write, then repairs the table, finishes the +// backfill and, the first time ever, verifies it; then trust is earned. Until then every page is served by the +// original statements. A failure is logged and the repair retried after Interval. Boot returns once the repair is +// done (trust earned, or a failed first verification left to the periodic task) or ctx ends; main runs it in a +// goroutine. +func (j *CmiJobs) Boot(ctx context.Context) { + // Until the first reconcile finishes, the watermark age counts from boot, so a boot that never finishes shows. + metrics.SetReadModelWatermark(cmiModel, time.Now()) + for { + err := j.Wait(ctx) + if err == nil { + break + } + if ctx.Err() != nil { + return + } + if errors.Is(err, db.ErrPreBootWriters) { + slog.Warn("cmi boot repair waits for transactions from before boot", "component", "readmodel", "error", err) + continue + } + slog.Error("cmi boot repair: pre-boot writer check failed", "component", "readmodel", "error", err) + if !sleep(ctx, j.Interval) { + return + } + } + for { + done, err := j.bootOnce(ctx) + if done { + if err != nil { + slog.Error("cmi boot verification failed; the periodic task retries it", "component", "readmodel", "error", err) + } + return + } + if ctx.Err() != nil { + return + } + if err != nil { + slog.Error("cmi boot repair failed; retrying", "component", "readmodel", "error", err) + } + if !sleep(ctx, j.Interval) { + return + } + } +} + +func (j *CmiJobs) bootOnce(ctx context.Context) (bool, error) { + s, err := j.begin(ctx, true) + if err != nil || s == nil { + return false, err + } + defer s.Close(context.Background()) + gen := j.Trust.Generation() + st, err := s.Init(ctx) + if err != nil { + return false, err + } + if _, err := j.reconcile(ctx, s); err != nil { + return false, err + } + for !st.Complete { + if st, err = s.Backfill(ctx, cmiBackfillBudget); err != nil { + return false, err + } + slog.Info("cmi backfill progress", "component", "readmodel", "backfilled_to_id", st.BackfilledToID, "max_id", st.BackfillMaxID) + } + j.booted.Store(true) + if st.FirstVerifiedAt == nil { + v, err := s.Verify(ctx) + if err != nil { + return true, fmt.Errorf("cmi verification: %w", err) + } + if !v.OK() { + return true, nil // the task verifies again every interval + } + } + j.Trust.Earn() + j.Trust.Repaired(gen) + slog.Info("cmi trusted: region and scope message pages read channel_message_iatas", "component", "readmodel", "trusted", j.Trust.Trusted()) + return true, nil +} + +// begin takes the lock; at boot it retries a busy lock, in the task it skips the run (nil session). +func (j *CmiJobs) begin(ctx context.Context, retry bool) (CmiSession, error) { + for { + s, ok, err := j.Begin(ctx) + if err != nil { + return nil, err + } + if ok { + return s, nil + } + if !retry { + return nil, nil + } + wait := j.busyRetry + if wait == 0 { + wait = cmiBusyRetry + } + if !sleep(ctx, wait) { + return nil, ctx.Err() + } + } +} + +// reconcile runs one reconcile and publishes its rows and watermark. +func (j *CmiJobs) reconcile(ctx context.Context, s CmiSession) (int64, error) { + n, err := s.Reconcile(ctx) + if err != nil { + return n, err + } + metrics.ReadModelRepaired.WithLabelValues(cmiModel).Add(float64(n)) + metrics.SetReadModelWatermark(cmiModel, time.Now()) + if n > 0 { + slog.Warn(fmt.Sprintf("cmi reconcile repaired %d pair(s): a writer bypassed the read model", n), "component", "readmodel") + } + return n, nil +} + +// Task reconciles every Interval once Boot has repaired the table. Its rows feed the trust policy; a run that began +// after a writer's failure restores trust that failure dropped; a never-verified table is verified each run until +// it passes. A busy lock skips the run. +func (j *CmiJobs) Task() Task { + return Task{ + Name: "readmodel.cmi", + Interval: j.Interval, + Run: func(ctx context.Context) error { + if !j.booted.Load() { + return nil + } + gen := j.Trust.Generation() + s, err := j.begin(ctx, false) + if err != nil || s == nil { + return err + } + defer s.Close(context.Background()) + st, err := s.Init(ctx) + if err != nil { + return err + } + if !st.Complete || st.FirstVerifiedAt == nil { + // Rebuilt or never verified since this process earned trust: serve today's statements until this + // run (or a later one) completes and verifies it. + j.Trust.Invalidate("the read model state is incomplete or unverified") + gen = j.Trust.Generation() + } + n, err := j.reconcile(ctx, s) + if err != nil { + return err + } + j.Trust.ObserveRun(n) + if !st.Complete { + _, err := s.Backfill(ctx, cmiBackfillBudget) + return err + } + if st.FirstVerifiedAt == nil { + v, err := s.Verify(ctx) + if err != nil { + return err + } + if !v.OK() { + return nil + } + j.Trust.Earn() + } + j.Trust.Repaired(gen) + return nil + }, + } +} + +// cmiReadOnlyMaxAge is how old the writer's saved state may be before a read-only server stops trusting the +// table: two reconcile intervals. A writer that was rolled back, stopped or keeps failing stops saving it. +const cmiReadOnlyMaxAge = 2 * CmiInterval + +// CmiReadOnlyTrust earns trust on a read-only server when the persisted state is complete and verified, its writer +// saved it within two reconcile intervals, and the exact check over the newest messages is clean; otherwise it drops +// trust. It publishes the writer's watermark age and writes nothing. +func CmiReadOnlyTrust(ctx context.Context, check func(context.Context) (db.CmiReadOnlyCheck, error), trust *db.Trust) { + gen := trust.Generation() + c, err := check(ctx) + if err == nil && c.Found { + metrics.SetReadModelWatermark(cmiModel, time.Now().Add(-c.Age)) + } + st, v := c.State, c.Verification + switch { + case err != nil: + slog.Error("cmi read-only check failed", "component", "readmodel", "error", err) + case !st.Complete || st.FirstVerifiedAt == nil: + slog.Info("cmi not trusted on this read-only server: backfill or first verification not done", "component", "readmodel", "complete", st.Complete) + case c.Age > cmiReadOnlyMaxAge: + slog.Warn("cmi not trusted on this read-only server: the writer has not saved its state recently", "component", "readmodel", "age", c.Age.Round(time.Second)) + case !v.OK(): + slog.Warn("cmi not trusted on this read-only server: the newest messages fail the exact check", "component", "readmodel", "missing", v.Missing, "extra", v.Extra) + default: + if !trust.Trusted() { + slog.Info("cmi trusted on this read-only server: region and scope message pages read channel_message_iatas", "component", "readmodel") + } + // Trust ends when the writer's state turns too old, not at the next check, unless that check finds it + // saved again. + trust.SetExpiry(time.Now().Add(cmiReadOnlyMaxAge - c.Age)) + trust.Earn() + trust.Repaired(gen) + return + } + trust.Invalidate("read-only check not clean") +} + +// CmiReadOnlyWatch runs CmiReadOnlyTrust now and every interval until ctx ends. +func CmiReadOnlyWatch(ctx context.Context, check func(context.Context) (db.CmiReadOnlyCheck, error), trust *db.Trust, interval time.Duration) { + for { + CmiReadOnlyTrust(ctx, check, trust) + if !sleep(ctx, interval) { + return + } + } +} diff --git a/internal/background/readmodel_cmi_integration_test.go b/internal/background/readmodel_cmi_integration_test.go new file mode 100644 index 0000000..58a0a23 --- /dev/null +++ b/internal/background/readmodel_cmi_integration_test.go @@ -0,0 +1,296 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package background + +import ( + "context" + "fmt" + "reflect" + "strings" + "testing" + "time" + + "github.com/MeshCore-Beacon/beacon-server/db" + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" + "github.com/MeshCore-Beacon/beacon-server/internal/ingest" + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" +) + +// statementNames records the sqlc name of every statement run through it. +type statementNames struct { + sqlc.DBTX + names []string +} + +func (s *statementNames) note(sql string) { + name, _, _ := strings.Cut(strings.TrimPrefix(sql, "-- name: "), " ") + s.names = append(s.names, name) +} + +func (s *statementNames) Exec(ctx context.Context, sql string, args ...any) (pgconn.CommandTag, error) { + s.note(sql) + return s.DBTX.Exec(ctx, sql, args...) +} + +func (s *statementNames) Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error) { + s.note(sql) + return s.DBTX.Query(ctx, sql, args...) +} + +func (s *statementNames) QueryRow(ctx context.Context, sql string, args ...any) pgx.Row { + s.note(sql) + return s.DBTX.QueryRow(ctx, sql, args...) +} + +func cmiJobsFor(store *db.Store, tr *db.Trust) *CmiJobs { + return &CmiJobs{ + Begin: func(ctx context.Context) (CmiSession, bool, error) { + s, ok, err := store.BeginCmi(ctx) + if s == nil { + return nil, ok, err + } + return s, ok, err + }, + Wait: func(context.Context) error { return nil }, + Trust: tr, + Interval: 10 * time.Millisecond, + } +} + +func bootWithin(t *testing.T, ctx context.Context, j *CmiJobs, d time.Duration) { + t.Helper() + done := make(chan struct{}) + go func() { j.Boot(ctx); close(done) }() + select { + case <-done: + case <-time.After(d): + t.Fatal("boot did not finish") + } + if !j.Trust.Trusted() { + t.Fatal("not trusted after the boot") + } +} + +// cmiSite writes one group-text packet heard at sites (ids above 3,000,000,000), its message on channel 7, and the +// later hearings through the Add, as the live writer does. +func cmiSite(t *testing.T, ctx context.Context, store *db.Store, hash string, observers map[string]uuid.UUID, sites ...string) { + t.Helper() + if _, err := store.UpsertPacket(ctx, ingest.UpsertPacketParams{PacketHash: []byte(hash), PayloadType: 5, RouteType: 1, RawHeader: []byte{0x15}, RawPayload: []byte(hash)}); err != nil { + t.Fatal(err) + } + for i, site := range sites { + if _, _, err := store.InsertObservation(ctx, ingest.InsertObservationParams{PacketHash: []byte(hash), ObserverID: observers[site], IATA: site, HeardAt: time.Now(), HashSize: 1, PayloadType: 5}); err != nil { + t.Fatal(err) + } + if i == 0 { + if _, err := store.InsertChannelMessage(ctx, ingest.InsertChannelMessageParams{ChannelID: 7, PacketHash: []byte(hash), SentAt: time.Now()}); err != nil { + t.Fatal(err) + } + } else if _, err := store.AddChannelMessageIATA(ctx, []byte(hash), site); err != nil { + t.Fatal(err) + } + } +} + +func cmiPrepare(t *testing.T, ctx context.Context, pool *pgxpool.Pool) map[string]uuid.UUID { + t.Helper() + observers := map[string]uuid.UUID{} + if _, err := pool.Exec(ctx, `SELECT setval('channel_messages_id_seq', 3000000000); +SELECT setval('packet_observations_id_seq', 3000000000); +INSERT INTO iata_codes (iata) VALUES ('YUL'), ('YOW'), ('YYZ') ON CONFLICT DO NOTHING; +INSERT INTO channels (id, channel_hash, name) VALUES (7, '\x11', 'ch7')`); err != nil { + t.Fatal(err) + } + for _, site := range []string{"YUL", "YOW", "YYZ"} { + observers[site] = uuid.New() + if _, err := pool.Exec(ctx, "INSERT INTO observers (id, public_key) VALUES ($1, $2)", observers[site], []byte(site)); err != nil { + t.Fatal(err) + } + } + return observers +} + +func missingPairs(t *testing.T, ctx context.Context, pool *pgxpool.Pool) int64 { + t.Helper() + var n int64 + if err := pool.QueryRow(ctx, `SELECT count(*) FROM ( + SELECT DISTINCT cm.id, po.iata, cm.channel_id, p.scope_id + FROM channel_messages cm JOIN packets p ON p.packet_hash = cm.packet_hash JOIN packet_observations po ON po.packet_hash = cm.packet_hash + EXCEPT SELECT message_id, iata, channel_id, scope_id FROM channel_message_iatas) m`).Scan(&n); err != nil { + t.Fatal(err) + } + return n +} + +func TestCmiBootRepairPostgres(t *testing.T) { + t.Run("empty", func(t *testing.T) { + ctx, pool := migratedPool(t) + tr := db.NewTrust("cmi", true, db.CmiTrustPolicy) + bootWithin(t, ctx, cmiJobsFor(db.New(pool, pool, 0, 0), tr), 30*time.Second) + }) + + ctx, pool := migratedPool(t) + maint := db.New(pool, pool, 0, 0) + observers := cmiPrepare(t, ctx, pool) + for i := range 20 { + cmiSite(t, ctx, maint, fmt.Sprintf("p%02d", i), observers, []string{"YUL", "YOW", "YYZ"}[:1+i%3]...) + } + tr := db.NewTrust("cmi", true, db.CmiTrustPolicy) + bootWithin(t, ctx, cmiJobsFor(maint, tr), 30*time.Second) + rec := &statementNames{DBTX: pool} + trusted := db.New(rec, nil, 0, 0, db.WithReadModels(&db.ReadModels{Cmi: tr})) + ch := int32(7) + if _, err := trusted.ListChannelMessages(ctx, &ch, time.Time{}, 50, []string{"YUL"}, "", 0); err != nil { + t.Fatal(err) + } + if got := strings.Join(rec.names, ","); got != "ListChannelMessagesByIATAs" { + t.Fatalf("trusted store ran %s", got) + } + + // An older binary, while this one was down: key-import messages for old packets without sites, and hearings + // stored without their Add. + for i := range 3 { + hash := []byte(fmt.Sprintf("old%02d", i)) + if _, err := maint.UpsertPacket(ctx, ingest.UpsertPacketParams{PacketHash: hash, PayloadType: 5, RouteType: 1, RawHeader: []byte{0x15}, RawPayload: hash}); err != nil { + t.Fatal(err) + } + for _, site := range []string{"YUL", "YOW"} { + if _, _, err := maint.InsertObservation(ctx, ingest.InsertObservationParams{PacketHash: hash, ObserverID: observers[site], IATA: site, HeardAt: time.Now(), HashSize: 1, PayloadType: 5}); err != nil { + t.Fatal(err) + } + } + if _, err := pool.Exec(ctx, "INSERT INTO channel_messages (channel_id, packet_hash, sent_at) VALUES (7, $1, now())", hash); err != nil { + t.Fatal(err) + } + } + for i := range 4 { + if _, _, err := maint.InsertObservation(ctx, ingest.InsertObservationParams{PacketHash: []byte(fmt.Sprintf("p%02d", i*3)), ObserverID: observers["YYZ"], IATA: "YYZ", HeardAt: time.Now(), HashSize: 1, PayloadType: 5}); err != nil { + t.Fatal(err) + } + } + missing := missingPairs(t, ctx, pool) + if missing != 10 { + t.Fatalf("the older binary left %d pairs missing, want 10", missing) + } + + // The next boot: untrusted until its repair finishes, then every page equals today's statement. + tr2 := db.NewTrust("cmi", true, db.CmiTrustPolicy) + before := repairedRows("cmi") + if tr2.Trusted() { + t.Fatal("trusted before the boot") + } + j := cmiJobsFor(maint, tr2) + bootWithin(t, ctx, j, 30*time.Second) + if got := repairedRows("cmi") - before; got != float64(missing) { + t.Fatalf("repaired counter grew by %v, want %d", got, missing) + } + if n := missingPairs(t, ctx, pool); n != 0 { + t.Fatalf("%d pairs still missing", n) + } + served := db.New(pool, nil, 0, 0, db.WithReadModels(&db.ReadModels{Cmi: tr2})) + today := db.New(pool, nil, 0, 0) + for _, sites := range [][]string{{"YUL"}, {"YOW"}, {"YYZ"}, {"YUL", "YOW", "YYZ"}} { + for _, chID := range []*int32{&ch, nil} { + got, err := served.ListChannelMessages(ctx, chID, time.Time{}, 50, sites, "", 0) + if err != nil { + t.Fatal(err) + } + want, err := today.ListChannelMessages(ctx, chID, time.Time{}, 50, sites, "", 0) + if err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(got, want) || len(got.Items) == 0 { + t.Fatalf("%v: %+v, today %+v", sites, got, want) + } + } + } + before = repairedRows("cmi") + if err := j.Task().Run(ctx); err != nil { + t.Fatal(err) + } + if got := repairedRows("cmi") - before; got != 0 || !tr2.Trusted() { + t.Fatalf("the next run repaired %v, trusted %v", got, tr2.Trusted()) + } +} + +func TestCmiReadOnlyTrustPostgres(t *testing.T) { + ctx, pool := migratedPool(t) + maint := db.New(pool, pool, 0, 0) + observers := cmiPrepare(t, ctx, pool) + for i := range 10 { + cmiSite(t, ctx, maint, fmt.Sprintf("p%02d", i), observers, "YUL", "YOW") + } + cfg := pool.Config().Copy() + cfg.ConnConfig.RuntimeParams["default_transaction_read_only"] = "on" + ro, err := pgxpool.NewWithConfig(ctx, cfg) + if err != nil { + t.Fatal(err) + } + defer ro.Close() + roStore := db.New(ro, ro, 0, 0) + stateRow := func() string { + var v string + if err := pool.QueryRow(ctx, "SELECT coalesce((SELECT value::text || updated_at::text FROM background_state WHERE key = 'cmi'), '')").Scan(&v); err != nil { + t.Fatal(err) + } + return v + } + check := func(label string, want bool) { + t.Helper() + before := stateRow() + tr := db.NewTrust("cmi", true, db.CmiTrustPolicy) + CmiReadOnlyTrust(ctx, roStore.CheckCmiReadOnly, tr) + if tr.Trusted() != want { + t.Fatalf("%s: trusted %v, want %v", label, tr.Trusted(), want) + } + if stateRow() != before { + t.Fatalf("%s: the read-only check wrote the state", label) + } + } + check("no state", false) + + // Complete, never verified. + c, ok, err := maint.BeginCmi(ctx) + if err != nil || !ok { + t.Fatal(ok, err) + } + if _, err := c.Init(ctx); err != nil { + t.Fatal(err) + } + st := c.State() + st.Complete = true + if err := maint.SaveState(ctx, "cmi", st); err != nil { + t.Fatal(err) + } + c.Close(ctx) + check("not verified", false) + + now := time.Now() + st.FirstVerifiedAt = &now + if err := maint.SaveState(ctx, "cmi", st); err != nil { + t.Fatal(err) + } + check("verified and clean", true) + + if _, err := pool.Exec(ctx, "DELETE FROM channel_message_iatas WHERE message_id = (SELECT max(message_id) FROM channel_message_iatas) AND iata = 'YOW'"); err != nil { + t.Fatal(err) + } + check("a missing pair among the newest", false) + // Repaired: trusted again while the writer's state is fresh. + if _, err := pool.Exec(ctx, `INSERT INTO channel_message_iatas (message_id, iata, channel_id, scope_id) +SELECT max(id), 'YOW', 7, NULL FROM channel_messages`); err != nil { + t.Fatal(err) + } + check("repaired", true) + + // A writer that stopped saving its state (rolled back, or its reconcile failing): the read-only server stops + // trusting the table once the state is two intervals old. + if _, err := pool.Exec(ctx, "UPDATE background_state SET updated_at = now() - interval '11 minutes' WHERE key = 'cmi'"); err != nil { + t.Fatal(err) + } + check("the writer's state is 11 minutes old", false) +} diff --git a/internal/background/readmodel_cmi_test.go b/internal/background/readmodel_cmi_test.go new file mode 100644 index 0000000..d2e2556 --- /dev/null +++ b/internal/background/readmodel_cmi_test.go @@ -0,0 +1,340 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package background + +import ( + "context" + "errors" + "fmt" + "net/http/httptest" + "slices" + "strconv" + "strings" + "sync" + "testing" + "time" + + "github.com/MeshCore-Beacon/beacon-server/db" + "github.com/MeshCore-Beacon/beacon-server/internal/metrics" + "github.com/prometheus/client_golang/prometheus/testutil" +) + +// fakeCmi records every call, in order, across sessions. +type fakeCmi struct { + mu sync.Mutex + calls []string + state db.CmiState + repairs []int64 // Reconcile results, consumed in order; then 0 + reconErr []error + verifyBad int // Verify fails this many times, then passes + busy int // Begin reports a busy lock this many times + waitBusy int // Wait returns ErrPreBootWriters this many times + backfills int // Backfill calls before Complete +} + +func (f *fakeCmi) log(s string) { + f.mu.Lock() + f.calls = append(f.calls, s) + f.mu.Unlock() +} + +func (f *fakeCmi) seq() string { + f.mu.Lock() + defer f.mu.Unlock() + return strings.Join(f.calls, ",") +} + +func (f *fakeCmi) State() db.CmiState { return f.state } +func (f *fakeCmi) Init(context.Context) (db.CmiState, error) { + f.log("init") + return f.state, nil +} +func (f *fakeCmi) Reconcile(context.Context) (int64, error) { + f.log("reconcile") + if len(f.reconErr) > 0 { + err := f.reconErr[0] + f.reconErr = f.reconErr[1:] + if err != nil { + return 0, err + } + } + if len(f.repairs) == 0 { + return 0, nil + } + n := f.repairs[0] + f.repairs = f.repairs[1:] + return n, nil +} +func (f *fakeCmi) Backfill(context.Context, time.Duration) (db.CmiState, error) { + f.log("backfill") + if f.backfills--; f.backfills <= 0 { + f.state.Complete = true + } + return f.state, nil +} +func (f *fakeCmi) Verify(context.Context) (db.CmiVerification, error) { + f.log("verify") + if f.verifyBad > 0 { + f.verifyBad-- + return db.CmiVerification{Missing: 1}, nil + } + now := time.Now() + f.state.FirstVerifiedAt = &now + return db.CmiVerification{PagesCompared: 10}, nil +} +func (f *fakeCmi) Close(context.Context) { f.log("close") } + +func (f *fakeCmi) jobs(tr *db.Trust) *CmiJobs { + return &CmiJobs{ + Begin: func(context.Context) (CmiSession, bool, error) { + f.log("begin") + if f.busy > 0 { + f.busy-- + return nil, false, nil + } + return f, true, nil + }, + Wait: func(context.Context) error { + f.log("wait") + if f.waitBusy > 0 { + f.waitBusy-- + return fmt.Errorf("%w: 1 session(s), pids [7]", db.ErrPreBootWriters) + } + return nil + }, + Trust: tr, + Interval: time.Millisecond, + busyRetry: time.Millisecond, + } +} + +func repairedRows(model string) float64 { + return testutil.ToFloat64(metrics.ReadModelRepaired.WithLabelValues(model)) +} + +func TestCmiJobsBootOrder(t *testing.T) { + ctx := context.Background() + f := &fakeCmi{waitBusy: 2, busy: 1, backfills: 2, repairs: []int64{4}} + tr := db.NewTrust("cmi", true, db.CmiTrustPolicy) + before := repairedRows("cmi") + j := f.jobs(tr) + j.Boot(ctx) + want := "wait,wait,wait,begin,begin,init,reconcile,backfill,backfill,verify,close" + if got := f.seq(); got != want { + t.Fatalf("boot calls %s, want %s", got, want) + } + if !tr.Trusted() { + t.Fatal("trust not earned after a passing verification") + } + if got := repairedRows("cmi") - before; got != 4 { + t.Fatalf("repaired counter grew by %v, want 4", got) + } + + // Verified at an earlier boot: no verification. + now := time.Now() + f = &fakeCmi{state: db.CmiState{Complete: true, FirstVerifiedAt: &now}} + tr = db.NewTrust("cmi", true, db.CmiTrustPolicy) + f.jobs(tr).Boot(ctx) + if got := f.seq(); got != "wait,begin,init,reconcile,close" || !tr.Trusted() { + t.Fatalf("boot calls %s, trusted %v", got, tr.Trusted()) + } + + // A failing reconcile: no trust, the boot retries after the interval. + f = &fakeCmi{state: db.CmiState{Complete: true, FirstVerifiedAt: &now}, reconErr: []error{errors.New("boom")}} + tr = db.NewTrust("cmi", true, db.CmiTrustPolicy) + f.jobs(tr).Boot(ctx) + if got := f.seq(); got != "wait,begin,init,reconcile,close,begin,init,reconcile,close" || !tr.Trusted() { + t.Fatalf("boot calls %s, trusted %v", got, tr.Trusted()) + } + + // A failing verification: the boot repair is done, trust waits for the task. + f = &fakeCmi{state: db.CmiState{Complete: true}, verifyBad: 1} + tr = db.NewTrust("cmi", true, db.CmiTrustPolicy) + j = f.jobs(tr) + j.Boot(ctx) + if tr.Trusted() || !j.booted.Load() { + t.Fatalf("trusted %v after a failed verification, booted %v", tr.Trusted(), j.booted.Load()) + } + if err := j.Task().Run(ctx); err != nil { + t.Fatal(err) + } + if !tr.Trusted() || !strings.HasSuffix(f.seq(), "begin,init,reconcile,verify,close") { + t.Fatalf("task after a failed verification: %s, trusted %v", f.seq(), tr.Trusted()) + } + + // A stop request ends the boot. + f = &fakeCmi{waitBusy: 1 << 30} + tr = db.NewTrust("cmi", true, db.CmiTrustPolicy) + cctx, cancel := context.WithTimeout(ctx, 20*time.Millisecond) + defer cancel() + f.jobs(tr).Boot(cctx) + if tr.Trusted() { + t.Fatal("trusted after a cancelled boot") + } +} + +func TestCmiJobsTaskPolicy(t *testing.T) { + ctx := context.Background() + now := time.Now() + f := &fakeCmi{state: db.CmiState{Complete: true, FirstVerifiedAt: &now}} + tr := db.NewTrust("cmi", true, db.CmiTrustPolicy) + j := f.jobs(tr) + task := j.Task() + if task.Name != "readmodel.cmi" || task.Interval != j.Interval { + t.Fatalf("task %q every %s", task.Name, task.Interval) + } + if err := task.Run(ctx); err != nil || f.seq() != "" { + t.Fatalf("a run before the boot: %v, calls %s", err, f.seq()) + } + j.Boot(ctx) + f.repairs = []int64{1, 1, 1, 0, 0} + results := []bool{} + for range 5 { + if err := task.Run(ctx); err != nil { + t.Fatal(err) + } + results = append(results, tr.Trusted()) + } + if !slices.Equal(results, []bool{true, true, false, false, true}) { + t.Fatalf("trust after runs repairing 1,1,1,0,0 = %v", results) + } + + // A busy lock skips the run and leaves the policy counters alone. + f.repairs = []int64{1, 1} + task.Run(ctx) //nolint:errcheck + task.Run(ctx) //nolint:errcheck + f.busy = 1 + calls := f.seq() + if err := task.Run(ctx); err != nil { + t.Fatal(err) + } + if f.seq() != calls+",begin" { + t.Fatalf("a busy run called %s", strings.TrimPrefix(f.seq(), calls)) + } + f.repairs = []int64{1} + task.Run(ctx) //nolint:errcheck + if tr.Trusted() { + t.Fatal("the busy run reset the dirty count") + } + + // A writer failure drops trust until a run that began after it. + f.repairs = nil + task.Run(ctx) //nolint:errcheck + task.Run(ctx) //nolint:errcheck + if !tr.Trusted() { + t.Fatal("not restored by two clean runs") + } + tr.Invalidate("failed add") + if tr.Trusted() { + t.Fatal("trusted after a writer failure") + } + f.repairs = []int64{1} + if err := task.Run(ctx); err != nil || !tr.Trusted() { + t.Fatalf("the next run did not restore trust: %v", err) + } + + // Complete but never verified: each run verifies until it passes, then trust is earned. + f = &fakeCmi{state: db.CmiState{Complete: true}, verifyBad: 2} + tr = db.NewTrust("cmi", true, db.CmiTrustPolicy) + j = f.jobs(tr) + j.Boot(ctx) + task = j.Task() + task.Run(ctx) //nolint:errcheck + if tr.Trusted() { + t.Fatal("trusted before a passing verification") + } + task.Run(ctx) //nolint:errcheck + if !tr.Trusted() || strings.Count(f.seq(), "verify") != 3 { + t.Fatalf("calls %s, trusted %v", f.seq(), tr.Trusted()) + } +} + +func TestCmiReadOnlyTrust(t *testing.T) { + ctx := context.Background() + now := time.Now() + fresh := time.Minute + for _, c := range []struct { + name string + st db.CmiState + v db.CmiVerification + age time.Duration + err error + want bool + }{ + {"clean", db.CmiState{Complete: true, FirstVerifiedAt: &now}, db.CmiVerification{}, fresh, nil, true}, + {"just under two intervals old", db.CmiState{Complete: true, FirstVerifiedAt: &now}, db.CmiVerification{}, 2*CmiInterval - time.Second, nil, true}, + {"stale writer", db.CmiState{Complete: true, FirstVerifiedAt: &now}, db.CmiVerification{}, 2*CmiInterval + time.Second, nil, false}, + {"never verified", db.CmiState{Complete: true}, db.CmiVerification{}, fresh, nil, false}, + {"incomplete", db.CmiState{FirstVerifiedAt: &now}, db.CmiVerification{}, fresh, nil, false}, + {"missing pair", db.CmiState{Complete: true, FirstVerifiedAt: &now}, db.CmiVerification{Missing: 1}, fresh, nil, false}, + {"check error", db.CmiState{Complete: true, FirstVerifiedAt: &now}, db.CmiVerification{}, fresh, errors.New("boom"), false}, + } { + tr := db.NewTrust("cmi", true, db.CmiTrustPolicy) + tr.Earn() // a trusted read-only server whose next check fails drops trust + check := func(context.Context) (db.CmiReadOnlyCheck, error) { + return db.CmiReadOnlyCheck{Found: true, State: c.st, Verification: c.v, Age: c.age}, c.err + } + CmiReadOnlyTrust(ctx, check, tr) + if tr.Trusted() != c.want { + t.Errorf("%s: trusted %v, want %v", c.name, tr.Trusted(), c.want) + } + } + // Trust ends when the writer's state turns two intervals old, not at the next check: a state 9 min 30 s old + // leaves 30 s of trust. + tr := db.NewTrust("cmi", true, db.CmiTrustPolicy) + CmiReadOnlyTrust(ctx, func(context.Context) (db.CmiReadOnlyCheck, error) { + return db.CmiReadOnlyCheck{Found: true, State: db.CmiState{Complete: true, FirstVerifiedAt: &now}, Age: 2*CmiInterval - 30*time.Second}, nil + }, tr) + if exp := tr.Expiry(); !tr.Trusted() || exp.Before(time.Now().Add(25*time.Second)) || exp.After(time.Now().Add(31*time.Second)) { + t.Fatalf("trusted %v until %v, want about 30 s from now", tr.Trusted(), exp) + } + tr.SetExpiry(time.Now().Add(-time.Millisecond)) // the deadline passed + if tr.Trusted() { + t.Fatal("trusted past the writer's deadline") + } + + // The read-only server publishes the writer's watermark age. + CmiReadOnlyTrust(ctx, func(context.Context) (db.CmiReadOnlyCheck, error) { + return db.CmiReadOnlyCheck{Found: true, State: db.CmiState{Complete: true, FirstVerifiedAt: &now}, Age: 90 * time.Second}, nil + }, db.NewTrust("cmi", true, db.CmiTrustPolicy)) + if age := watermarkAge(t, "cmi"); age < 90 || age > 120 { + t.Fatalf("watermark age %v, want about 90", age) + } +} + +// watermarkAge scrapes beacon_readmodel_watermark_age_seconds{model}. +func watermarkAge(t *testing.T, model string) float64 { + t.Helper() + rec := httptest.NewRecorder() + metrics.Handler().ServeHTTP(rec, httptest.NewRequest("GET", "/metrics", nil)) + for _, line := range strings.Split(rec.Body.String(), "\n") { + if v, ok := strings.CutPrefix(line, `beacon_readmodel_watermark_age_seconds{model="`+model+`"} `); ok { + f, _ := strconv.ParseFloat(v, 64) + return f + } + } + return -1 +} + +// A task run that finds the state incomplete or unverified (a rebuild without a restart) drops trust; a boot that +// has not finished its first reconcile still shows a growing watermark age. +func TestCmiJobsTaskDropsOnIncompleteState(t *testing.T) { + ctx := context.Background() + now := time.Now() + f := &fakeCmi{state: db.CmiState{Complete: true, FirstVerifiedAt: &now}} + tr := db.NewTrust("cmi", true, db.CmiTrustPolicy) + j := f.jobs(tr) + j.Boot(ctx) + if !tr.Trusted() { + t.Fatal("not trusted after boot") + } + f.state = db.CmiState{BackfillMaxID: 9} + f.backfills = 1 << 20 + if err := j.Task().Run(ctx); err != nil { + t.Fatal(err) + } + if tr.Trusted() { + t.Fatal("trusted while the state is incomplete") + } +} diff --git a/internal/config/config.go b/internal/config/config.go index 39e6d32..3c4dbf7 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -53,6 +53,18 @@ type Config struct { Database DatabaseConfig `yaml:"database"` Guards GuardsConfig `yaml:"guards"` Planguard PlanguardConfig `yaml:"planguard"` + ReadModels ReadModelsConfig `yaml:"readmodels"` +} + +// ReadModelsConfig switches serving pages from each read model. +type ReadModelsConfig struct { + Cmi ReadModelConfig `yaml:"cmi"` +} + +// ReadModelConfig controls one read model. Enabled false serves every page from the original statements; the +// model is still maintained, so turning it back on needs only a restart. +type ReadModelConfig struct { + Enabled *bool `yaml:"enabled"` // nil = true } // PlanguardConfig controls the daily read-only plan regression check. @@ -185,6 +197,8 @@ type ResolvedConfig struct { ReadOnly bool // PlanguardDailyCheck runs the daily read-only plan check; off by default. PlanguardDailyCheck bool + // ReadModelCmiEnabled serves region and scope message pages from channel_message_iatas once trusted; default true. + ReadModelCmiEnabled bool } // RateLimitConfig controls the per-client REST API request budget. @@ -706,6 +720,7 @@ func Resolve(cfg *Config) ResolvedConfig { ReadOnly: cfg.Server.ReadOnly, PlanguardDailyCheck: cfg.Planguard.DailyCheck, + ReadModelCmiEnabled: cfg.ReadModels.Cmi.Enabled == nil || *cfg.ReadModels.Cmi.Enabled, } // Load has validated the layout; an unvalidated config falls back to the default. r.APIPlanLayout, _ = planpolicy.ParseLayout(cfg.Database.APIPlanLayout) @@ -780,12 +795,12 @@ func Resolve(cfg *Config) ResolvedConfig { func (r ResolvedConfig) String() string { return fmt.Sprintf( - "telemetryResolution=%s telemetryRetention=%s rollupRetention=%s packetRetention=%s routeRetention=%s routeGrace=%s routeMinObs=%d routeReconfirmRowsPerHour=%d maxConnsPerIP=%d maxConnectsPerMinute=%d viewRefresh=%s reconfirm=%s cleanup=%s presenceFlush=%s presencePacketTTL=%s clockDriftThreshold=%s nodeStaleThreshold=%s nodeDeleteAfter=%s observerDeleteAfter=%s rateLimitEnabled=%t requestsPerMinute=%d burst=%d apiPlanLayout=%s guardsEnforce=%v guardsBudget=%s adminListen=%q readOnly=%t planguardDailyCheck=%t", + "telemetryResolution=%s telemetryRetention=%s rollupRetention=%s packetRetention=%s routeRetention=%s routeGrace=%s routeMinObs=%d routeReconfirmRowsPerHour=%d maxConnsPerIP=%d maxConnectsPerMinute=%d viewRefresh=%s reconfirm=%s cleanup=%s presenceFlush=%s presencePacketTTL=%s clockDriftThreshold=%s nodeStaleThreshold=%s nodeDeleteAfter=%s observerDeleteAfter=%s rateLimitEnabled=%t requestsPerMinute=%d burst=%d apiPlanLayout=%s guardsEnforce=%v guardsBudget=%s adminListen=%q readOnly=%t planguardDailyCheck=%t readModelCmi=%t", r.TelemetryResolution, r.TelemetryRetention, r.RollupRetention, r.PacketRetention, r.RouteRetention, r.RouteGrace, r.RouteMinObservations, r.RouteReconfirmRowsPerHour, r.MaxConnsPerIP, r.MaxConnectsPerMinute, r.ViewRefreshInterval, r.ReconfirmInterval, r.CleanupInterval, r.PresenceFlushInterval, r.PresencePacketTTL, r.ClockDriftThreshold, r.NodeStaleThreshold, r.NodeDeleteAfter, r.ObserverDeleteAfter, r.RateLimit.Enabled, r.RateLimit.RequestsPerMinute, r.RateLimit.Burst, - r.APIPlanLayout, r.GuardsEnforce, r.GuardsBudget, r.AdminListen, r.ReadOnly, r.PlanguardDailyCheck, + r.APIPlanLayout, r.GuardsEnforce, r.GuardsBudget, r.AdminListen, r.ReadOnly, r.PlanguardDailyCheck, r.ReadModelCmiEnabled, ) } diff --git a/internal/config/config_test.go b/internal/config/config_test.go index 422713d..5bf71bc 100644 --- a/internal/config/config_test.go +++ b/internal/config/config_test.go @@ -4,6 +4,7 @@ package config import ( + "fmt" "os" "path/filepath" "strconv" @@ -523,3 +524,31 @@ func TestLoad_PlanguardDailyCheck(t *testing.T) { } } } + +func TestLoad_ReadModelsCmi(t *testing.T) { + for _, c := range []struct { + yaml string + want bool + }{ + {"", true}, + {"readmodels:\n cmi:\n enabled: false\n", false}, + {"readmodels:\n cmi:\n enabled: true\n", true}, + {"readmodels:\n cmi: {}\n", true}, + } { + path := filepath.Join(t.TempDir(), "config.yaml") + if err := os.WriteFile(path, []byte(c.yaml), 0600); err != nil { + t.Fatal(err) + } + cfg, err := Load(path) + if err != nil { + t.Fatal(err) + } + r := Resolve(cfg) + if r.ReadModelCmiEnabled != c.want { + t.Errorf("%q: ReadModelCmiEnabled = %v, want %v", c.yaml, r.ReadModelCmiEnabled, c.want) + } + if !strings.Contains(r.String(), fmt.Sprintf("readModelCmi=%t", c.want)) { + t.Errorf("%q: resolved line %q", c.yaml, r.String()) + } + } +} diff --git a/internal/ingest/backfill.go b/internal/ingest/backfill.go index 65402ec..d9a4ac1 100644 --- a/internal/ingest/backfill.go +++ b/internal/ingest/backfill.go @@ -93,6 +93,20 @@ func DecryptGroupText(ctx context.Context, db DB, keys ChannelKeyStore, packetHa }, nil } +// StoreGroupText decrypts and stores a live group-text observation's message (DecryptGroupText, historical=false). +// Whenever this call did not create the message (no key, a decrypt or store error, a payload that does not decode, +// a message that already exists) it records the observation's site with AddChannelMessageIATA, unless siteRecorded +// says an earlier Add for this hearing already found the stored message; an Add error is logged and never returned. +func StoreGroupText(ctx context.Context, db DB, keys ChannelKeyStore, packetHash, rawPayload []byte, iata string, siteRecorded bool) (*DecryptGroupTextResult, error) { + result, err := DecryptGroupText(ctx, db, keys, packetHash, rawPayload, false) + if !siteRecorded && (err != nil || result == nil || result.Message == nil) { + if _, addErr := db.AddChannelMessageIATA(ctx, packetHash, iata); addErr != nil { + slog.Error(fmt.Sprintf("ingest: failed to record site %s for channel packet %s", iata, hex.EncodeToString(packetHash)), "component", "ingest", "error", addErr) + } + } + return result, err +} + // BackfillChannelMessages scans packets already stored but never successfully decrypted and // retries decryption against the current keystore. Meant to run once at boot, after the // keystore is built from config: without this, a channel added to the config after its diff --git a/internal/ingest/channel_scope_test.go b/internal/ingest/channel_scope_test.go index 3ee6933..5ccfa95 100644 --- a/internal/ingest/channel_scope_test.go +++ b/internal/ingest/channel_scope_test.go @@ -47,7 +47,7 @@ func TestChannelMessageScopeLive(t *testing.T) { waitForSummarySubscriber(t, ctx, w.hub, client) packet := &meshcore.Packet{Header: meshcore.MakeHeader(meshcore.RouteTypeTransportFlood, meshcore.PayloadTypeGrpTxt, 0), Payload: encryptedGroupText(t, 0x11, psk, "Fixture", "test")} latest := "#different-later-reception" - w.handlePayloadTypeSideEffects(ctx, packet, "YOW", []byte{1}, RadioSettings{}, nil, &latest, nil, 0) + w.handlePayloadTypeSideEffects(ctx, packet, "YOW", []byte{1}, RadioSettings{}, nil, &latest, nil, 0, false) select { case event := <-client.Send: var got channelMessageEvent @@ -60,7 +60,7 @@ func TestChannelMessageScopeLive(t *testing.T) { case <-ctx.Done(): t.Fatal("no live message") } - w.handlePayloadTypeSideEffects(ctx, packet, "YOW", []byte{1}, RadioSettings{}, nil, &latest, nil, 0) + w.handlePayloadTypeSideEffects(ctx, packet, "YOW", []byte{1}, RadioSettings{}, nil, &latest, nil, 0, false) w.hub.Broadcast(hub.Event{Type: hub.EventObserverStatus}) select { case event := <-client.Send: diff --git a/internal/ingest/cmi_integration_test.go b/internal/ingest/cmi_integration_test.go new file mode 100644 index 0000000..3d07066 --- /dev/null +++ b/internal/ingest/cmi_integration_test.go @@ -0,0 +1,258 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package ingest_test + +import ( + "context" + "encoding/hex" + "encoding/json" + "fmt" + "math/rand/v2" + "os" + "strings" + "sync" + "testing" + "time" + + "github.com/MeshCore-Beacon/beacon-server/db" + "github.com/MeshCore-Beacon/beacon-server/internal/hub" + "github.com/MeshCore-Beacon/beacon-server/internal/ingest" + "github.com/MeshCore-Beacon/beacon-server/internal/keystore" + "github.com/MeshCore-Beacon/beacon-server/internal/scopestore" + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + "github.com/meshcore-go/meshcore-go" +) + +type keys map[byte][]keystore.Entry + +func (k keys) GetKey(hash []byte) []keystore.Entry { + if len(hash) == 0 { + return nil + } + return k[hash[0]] +} + +// migratedPool returns a pool on a fresh schema built by db.RunMigrations, dropped on cleanup. +func migratedPool(t *testing.T) (context.Context, *pgxpool.Pool) { + t.Helper() + dsn := os.Getenv("BEACON_TEST_POSTGRES_DSN") + if dsn == "" { + t.Skip("set BEACON_TEST_POSTGRES_DSN for PostgreSQL tests") + } + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) + t.Cleanup(cancel) + admin, err := pgx.Connect(ctx, dsn) + if err != nil { + t.Fatal(err) + } + schema := pgx.Identifier{"cmi_ingest_" + strings.ReplaceAll(uuid.NewString(), "-", "")}.Sanitize() + if _, err := admin.Exec(ctx, "CREATE SCHEMA "+schema); err != nil { + t.Fatal(err) + } + t.Cleanup(func() { + if _, err := admin.Exec(context.Background(), "DROP SCHEMA "+schema+" CASCADE"); err != nil { + t.Error(err) + } + admin.Close(context.Background()) + }) + cfg, err := pgxpool.ParseConfig(dsn) + if err != nil { + t.Fatal(err) + } + cfg.ConnConfig.RuntimeParams["search_path"] = schema + cfg.MaxConns = 4 + pool, err := pgxpool.NewWithConfig(ctx, cfg) + if err != nil { + t.Fatal(err) + } + t.Cleanup(pool.Close) + if err := db.RunMigrations(ctx, pool); err != nil { + t.Fatal(err) + } + return ctx, pool +} + +// A later hearing whose decrypt fails (the key was dropped at runtime) still records its site at once. +func TestCmiAddOnDecryptFailurePostgres(t *testing.T) { + ctx, pool := migratedPool(t) + store := db.New(pool, pool, 0, 0) + psk := make([]byte, 16) + grpTxt, err := (&meshcore.GroupTextPayload{Timestamp: 1000, Sender: "Fixture", Text: "test"}).Encrypt(0x11, psk) + if err != nil { + t.Fatal(err) + } + payload, err := grpTxt.ToBytes() + if err != nil { + t.Fatal(err) + } + hash := []byte("decrypt-failure") + if _, err := pool.Exec(ctx, ` +SELECT setval('channel_messages_id_seq', 3000000000); +SELECT setval('packet_observations_id_seq', 3000000000); +INSERT INTO iata_codes (iata) VALUES ('YUL'), ('YOW') ON CONFLICT DO NOTHING; +INSERT INTO observers (id, public_key) VALUES ('00000000-0000-0000-0000-000000000001', '\x01'), ('00000000-0000-0000-0000-000000000002', '\x02')`); err != nil { + t.Fatal(err) + } + if _, err := store.UpsertPacket(ctx, ingest.UpsertPacketParams{PacketHash: hash, PayloadType: 5, RouteType: 1, RawHeader: []byte{0x15}, RawPayload: payload, ChannelHash: []byte{0x11}}); err != nil { + t.Fatal(err) + } + observe := func(observer, iata string) { + t.Helper() + if _, _, err := store.InsertObservation(ctx, ingest.InsertObservationParams{PacketHash: hash, ObserverID: uuid.MustParse(observer), IATA: iata, HeardAt: time.Now(), HashSize: 1, PayloadType: 5}); err != nil { + t.Fatal(err) + } + } + + k1 := keys{0x11: {{Key: psk, Fingerprint: []byte{1}, Name: "fixture"}}} + observe("00000000-0000-0000-0000-000000000001", "YUL") + created, err := ingest.StoreGroupText(ctx, store, k1, hash, payload, "YUL", false) + if err != nil || created == nil || created.Message == nil { + t.Fatalf("first hearing: %+v, %v", created, err) + } + m := created.Message.ID + + // The key is gone; the next hearing cannot decrypt. + observe("00000000-0000-0000-0000-000000000002", "YOW") + result, err := ingest.StoreGroupText(ctx, store, keys{}, hash, payload, "YOW", false) + if result != nil || err != nil { + t.Fatalf("keyless hearing: %+v, %v", result, err) + } + + var sites []string + if err := pool.QueryRow(ctx, "SELECT array_agg(iata::text ORDER BY iata) FROM channel_message_iatas WHERE message_id = $1", m).Scan(&sites); err != nil { + t.Fatal(err) + } + if strings.Join(sites, ",") != "YOW,YUL" { + t.Fatalf("sites = %v, want YOW and YUL", sites) + } + var missing, extra int64 + if err := pool.QueryRow(ctx, `WITH def AS ( + SELECT DISTINCT cm.id AS message_id, po.iata, cm.channel_id, p.scope_id + FROM channel_messages cm JOIN packets p ON p.packet_hash = cm.packet_hash JOIN packet_observations po ON po.packet_hash = cm.packet_hash +), have AS (SELECT message_id, iata, channel_id, scope_id FROM channel_message_iatas) +SELECT (SELECT count(*) FROM (SELECT * FROM def EXCEPT SELECT * FROM have) m), (SELECT count(*) FROM (SELECT * FROM have EXCEPT SELECT * FROM def) x)`).Scan(&missing, &extra); err != nil { + t.Fatal(err) + } + if missing != 0 || extra != 0 { + t.Fatalf("missing %d, extra %d", missing, extra) + } + channelID := int32(created.ChannelID) + page, err := store.ListChannelMessages(ctx, &channelID, time.Time{}, 50, []string{"YOW"}, "", 0) + if err != nil || len(page.Items) != 1 || page.Items[0].ID != m { + t.Fatalf("YOW page = %+v, %v", page, err) + } +} + +type noScopes struct{} + +func (noScopes) Entries() []scopestore.Entry { return nil } + +// A clean ingest run, four workers hearing the same packets at once, leaves nothing for the reconcile: every site +// is recorded by the writers themselves. Reconciles run beside the workers too; what they repair is logged. +func TestCmiCleanIngestReconcilesNothingPostgres(t *testing.T) { + ctx, pool := migratedPool(t) + store := db.New(pool, pool, 0, 0) + h := hub.New() + go h.Run() + psk := make([]byte, 16) + k := keys{0x11: {{Key: psk, Fingerprint: []byte{1}, Name: "fixture"}}} + c, ok, err := store.BeginCmi(ctx) + if err != nil || !ok { + t.Fatal(ok, err) + } + defer c.Close(context.Background()) + if _, err := c.Init(ctx); err != nil { + t.Fatal(err) + } + + type hearing struct { + site, observer string + env []byte + } + var hearings []hearing + sites := []string{"YUL", "YOW", "YYZ", "YVR"} + for i := range 40 { + ch := byte(0x11) + if i%3 == 2 { + ch = 0x22 // no key: hash-only, no message + } + g, err := (&meshcore.GroupTextPayload{Timestamp: uint32(1000 + i), Sender: "s", Text: fmt.Sprint("m", i)}).Encrypt(ch, psk) + if err != nil { + t.Fatal(err) + } + payload, err := g.ToBytes() + if err != nil { + t.Fatal(err) + } + raw, err := (&meshcore.Packet{Header: meshcore.MakeHeader(meshcore.RouteTypeFlood, meshcore.PayloadTypeGrpTxt, 0), Payload: payload}).ToBytes() + if err != nil { + t.Fatal(err) + } + env, _ := json.Marshal(map[string]string{"raw": hex.EncodeToString(raw), "timestamp": time.Now().UTC().Format("2006-01-02T15:04:05.000000")}) + for o, site := range sites { + hearings = append(hearings, hearing{site, fmt.Sprintf("%02x%062x", o+1, i), env}) + } + } + rand.New(rand.NewPCG(7, 7)).Shuffle(len(hearings), func(a, b int) { hearings[a], hearings[b] = hearings[b], hearings[a] }) + + work := make(chan hearing) + var wg sync.WaitGroup + for range 4 { + w := ingest.New(ingest.Config{BrokerName: "test"}, store, h, k, noScopes{}) + wg.Go(func() { + for hr := range work { + w.HandlePacketForTest(ctx, hr.site, hr.observer, hr.env) + } + }) + } + stop := make(chan struct{}) + var during int64 + var runs int + reconciled := make(chan struct{}) + go func() { + defer close(reconciled) + for { + select { + case <-stop: + return + default: + } + n, err := c.Reconcile(ctx) + if err != nil { + t.Error(err) + return + } + during += n + runs++ + } + }() + for _, hr := range hearings { + work <- hr + } + close(work) + wg.Wait() + close(stop) + <-reconciled + t.Logf("%d reconciles beside 4 workers and %d hearings repaired %d pairs", runs, len(hearings), during) + + // After the run, a reconcile (both overlapping ranges) finds nothing to repair, and the table is exact. + for range 2 { + if n, err := c.Reconcile(ctx); err != nil || n != 0 { + t.Fatalf("reconcile after a clean ingest run repaired %d (%v)", n, err) + } + } + var messages, missing, extra int64 + if err := pool.QueryRow(ctx, `WITH def AS ( + SELECT DISTINCT cm.id AS message_id, po.iata, cm.channel_id, p.scope_id + FROM channel_messages cm JOIN packets p ON p.packet_hash = cm.packet_hash JOIN packet_observations po ON po.packet_hash = cm.packet_hash +), have AS (SELECT message_id, iata, channel_id, scope_id FROM channel_message_iatas) +SELECT (SELECT count(*) FROM channel_messages), (SELECT count(*) FROM (SELECT * FROM def EXCEPT SELECT * FROM have) m), (SELECT count(*) FROM (SELECT * FROM have EXCEPT SELECT * FROM def) x)`).Scan(&messages, &missing, &extra); err != nil { + t.Fatal(err) + } + if messages == 0 || missing != 0 || extra != 0 { + t.Fatalf("%d messages, missing %d, extra %d", messages, missing, extra) + } +} diff --git a/internal/ingest/cmi_rule_test.go b/internal/ingest/cmi_rule_test.go new file mode 100644 index 0000000..b371284 --- /dev/null +++ b/internal/ingest/cmi_rule_test.go @@ -0,0 +1,177 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package ingest + +import ( + "context" + "encoding/json" + "errors" + "slices" + "testing" + "time" + + "github.com/MeshCore-Beacon/beacon-server/internal/hub" + "github.com/MeshCore-Beacon/beacon-server/internal/keystore" + "github.com/meshcore-go/meshcore-go" +) + +// A live group-text hearing records its site unless this call created the message, whatever the decrypt result. +func TestStoreGroupTextAddsSiteUnlessCreated(t *testing.T) { + psk := make([]byte, 16) + payload := encryptedGroupText(t, 0x11, psk, "Fixture", "test") + keyed := &mapKeys{entries: map[byte][]keystore.Entry{0x11: {{Key: psk, Fingerprint: []byte{1}, Name: "fixture"}}}} + hash := []byte{0xab, 0xcd} + cases := []struct { + name string + keys ChannelKeyStore + payload []byte + setup func(*stubDB) + adds int + result bool + err bool + }{ + {name: "created", keys: keyed, payload: payload, setup: func(s *stubDB) { s.insertChannelMessageResult = true }, result: true}, + {name: "duplicate", keys: keyed, payload: payload, adds: 1, result: true}, + {name: "no key", keys: &mapKeys{}, payload: payload, adds: 1}, + {name: "upsert channel error", keys: keyed, payload: payload, setup: func(s *stubDB) { s.upsertChannelErr = errors.New("boom") }, adds: 1, err: true}, + {name: "payload does not decode", keys: keyed, payload: []byte{0x11}, adds: 1, err: true}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + db := &stubDB{} + if c.setup != nil { + c.setup(db) + } + result, err := StoreGroupText(context.Background(), db, c.keys, hash, c.payload, "YOW", false) + if (err != nil) != c.err || (result != nil) != c.result { + t.Fatalf("result %+v, err %v", result, err) + } + want := slices.Repeat([]addCall{{string(hash), "YOW"}}, c.adds) + if !slices.Equal(db.addCalls, want) { + t.Fatalf("adds = %v, want %v", db.addCalls, want) + } + }) + } +} + +// An Add error is logged only: the new message is still broadcast and a keyless hearing still records its channel. +func TestGroupTextAddErrorStillBroadcasts(t *testing.T) { + w, db := newTestWorker() + db.addErr = errors.New("add failed") + psk := make([]byte, 16) + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + go w.hub.Run() + client := w.hub.NewClient() + defer w.hub.Remove(client) + w.hub.AddScope(client, "scope", hub.Scope{Events: []hub.EventType{hub.EventChannelMessage, hub.EventObserverStatus}}) + waitForSummarySubscriber(t, ctx, w.hub, client) + packet := &meshcore.Packet{Header: meshcore.MakeHeader(meshcore.RouteTypeFlood, meshcore.PayloadTypeGrpTxt, 0), Payload: encryptedGroupText(t, 0x11, psk, "Fixture", "test")} + + // No key: the Add fails, the hash-only channel is still recorded. + w.handlePayloadTypeSideEffects(ctx, packet, "YOW", []byte{1}, RadioSettings{}, nil, nil, nil, 0, false) + if db.upsertChannelHashOnlyCalls != 1 || len(db.addCalls) != 1 { + t.Fatalf("hash-only upserts %d, adds %d", db.upsertChannelHashOnlyCalls, len(db.addCalls)) + } + + // A duplicate with a key: the Add fails, nothing is broadcast, nothing panics. + w.keys = &mapKeys{entries: map[byte][]keystore.Entry{0x11: {{Key: psk, Fingerprint: []byte{1}, Name: "fixture"}}}} + w.handlePayloadTypeSideEffects(ctx, packet, "YUL", []byte{2}, RadioSettings{}, nil, nil, nil, 0, false) + if len(db.addCalls) != 2 { + t.Fatalf("adds = %v", db.addCalls) + } + + // A new message: no Add, and the event is broadcast. + db.insertChannelMessageResult = true + w.handlePayloadTypeSideEffects(ctx, packet, "YYZ", []byte{3}, RadioSettings{}, nil, nil, nil, 0, false) + select { + case event := <-client.Send: + var got channelMessageEvent + if err := json.Unmarshal(event.Payload, &got); err != nil { + t.Fatal(err) + } + if got.ID != 1 || got.Content != "test" || got.ChannelHash != "11" { + t.Fatalf("event = %+v", got) + } + case <-ctx.Done(): + t.Fatal("no channelMessage event") + } + if len(db.addCalls) != 2 { + t.Fatalf("a created message added its site: %v", db.addCalls) + } +} + +// A stored group-text hearing records its site right after the observation insert, before any other DB call, so a +// message that already exists gains the site at once; a duplicate hearing records nothing. +func TestGroupTextObservationAddsSiteAtOnce(t *testing.T) { + w, db := newTestWorker() + db.observationInserted = true + adds := -1 + db.dbHook = func() { adds = len(db.addCalls) } + packet := buildGrpTxtPacket(t, 0x1a, make([]byte, 16)) + w.handlePacket(context.Background(), "YOW", "0102", packetEnvelope(t, packet)) + if adds != 1 || db.addCalls[0].iata != "YOW" { + t.Fatalf("adds before the next DB call = %d (%v), want 1 at YOW", adds, db.addCalls) + } + + w, db = newTestWorker() + db.observationInserted = false + w.handlePacket(context.Background(), "YOW", "0102", packetEnvelope(t, packet)) + if len(db.addCalls) != 0 { + t.Fatalf("a duplicate hearing added %v", db.addCalls) + } +} + +// orderDB records whether the hearing's path was already marked sent when the early Add ran. +type orderDB struct { + *stubDB + w *Worker + path []byte + markedFirst []bool + found bool +} + +func (o *orderDB) AddChannelMessageIATA(ctx context.Context, hash []byte, iata string) (bool, error) { + // MarkSent answers true for a new path only once the hearing's first path is recorded, so probing a path no + // copy uses tells whether the worker already marked this hearing. + o.markedFirst = append(o.markedFirst, o.w.hub.MarkSent(hash, make([]byte, 16), append(slices.Clone(o.path), 0xee, 0xee))) + _, err := o.stubDB.AddChannelMessageIATA(ctx, hash, iata) + return o.found, err +} + +// The hearing's path is recorded before the early Add, so a broker copy racing through the Add cannot be streamed as +// a repeat of this hearing. +func TestGroupTextAddAfterMarkSent(t *testing.T) { + w, base := newTestWorker() + base.observationInserted = true + packet := buildGrpTxtPacket(t, 0x1a, make([]byte, 16)) + db := &orderDB{stubDB: base, w: w, path: packet.Path} + w.db = db + w.handlePacket(context.Background(), "YOW", "0102", packetEnvelope(t, packet)) + if len(db.markedFirst) == 0 || !db.markedFirst[0] { + t.Fatalf("the early Add ran before MarkSent recorded the path: %v", db.markedFirst) + } +} + +// When the early Add found the stored message, the hearing's site is recorded and the backstop Add is skipped; when it +// found none (the message is new, or still being created by another hearing), the backstop runs. +func TestGroupTextBackstopOnlyWithoutStoredMessage(t *testing.T) { + psk := make([]byte, 16) + for _, c := range []struct { + found bool + adds int + }{{true, 1}, {false, 2}} { + w, base := newTestWorker() + base.observationInserted = true + w.keys = &mapKeys{entries: map[byte][]keystore.Entry{0x11: {{Key: psk, Fingerprint: []byte{1}, Name: "fixture"}}}} + packet := &meshcore.Packet{Header: meshcore.MakeHeader(meshcore.RouteTypeFlood, meshcore.PayloadTypeGrpTxt, 0), Payload: encryptedGroupText(t, 0x11, psk, "Fixture", "test")} + db := &orderDB{stubDB: base, w: w, path: packet.Path, found: c.found} + w.db = db + w.handlePacket(context.Background(), "YOW", "0102", packetEnvelope(t, packet)) + if len(base.addCalls) != c.adds { + t.Errorf("message found %v: %d Adds, want %d", c.found, len(base.addCalls), c.adds) + } + t.Logf("message found %v: %d Adds, %d channel upserts, %d message inserts", c.found, len(base.addCalls), base.upsertChannelCalls, len(base.channelMessages)) + } +} diff --git a/internal/ingest/export_test.go b/internal/ingest/export_test.go new file mode 100644 index 0000000..9359f71 --- /dev/null +++ b/internal/ingest/export_test.go @@ -0,0 +1,11 @@ +// Copyright 2026 Beacon Contributors +// SPDX-License-Identifier: AGPL-3.0-or-later + +package ingest + +import "context" + +// HandlePacketForTest runs one packet hearing through the worker, for tests in package ingest_test. +func (w *Worker) HandlePacketForTest(ctx context.Context, iata, pubkeyHex string, raw []byte) { + w.handlePacket(ctx, iata, pubkeyHex, raw) +} diff --git a/internal/ingest/foreign_nodes_test.go b/internal/ingest/foreign_nodes_test.go index 85f4fee..62b1202 100644 --- a/internal/ingest/foreign_nodes_test.go +++ b/internal/ingest/foreign_nodes_test.go @@ -56,7 +56,7 @@ func TestForeignNodeUpdates(t *testing.T) { data = binary.LittleEndian.AppendUint32(data, uint32(tc.lat)) data = binary.LittleEndian.AppendUint32(data, uint32(tc.lng)) } - w.handlePayloadTypeSideEffects(ctx, buildAdvertPacketWithData(t, data, false), "AAA", []byte{1}, RadioSettings{}, nil, nil, nil, 0) + w.handlePayloadTypeSideEffects(ctx, buildAdvertPacketWithData(t, data, false), "AAA", []byte{1}, RadioSettings{}, nil, nil, nil, 0, false) for { select { case event := <-client.Send: diff --git a/internal/ingest/ingest.go b/internal/ingest/ingest.go index 6c3abb7..5477400 100644 --- a/internal/ingest/ingest.go +++ b/internal/ingest/ingest.go @@ -136,6 +136,10 @@ type DB interface { // InsertChannelMessage stores a decrypted group text message. Returns the inserted message, nil for a duplicate, and an error. InsertChannelMessage(ctx context.Context, m InsertChannelMessageParams) (*InsertedChannelMessage, error) + // AddChannelMessageIATA records iata as a site of the packet's message; a no-op when the packet has none. + // found says whether the packet has a committed message (its site is then recorded). + AddChannelMessageIATA(ctx context.Context, packetHash []byte, iata string) (found bool, err error) + // UpdateObserverStatus updates the observer row from a /status message. Returns the OberserID // and any error. UpdateObserverStatus(ctx context.Context, p UpdateObserverStatusParams) (uuid.UUID, error) diff --git a/internal/ingest/ingest_test.go b/internal/ingest/ingest_test.go index cffa465..aff015f 100644 --- a/internal/ingest/ingest_test.go +++ b/internal/ingest/ingest_test.go @@ -190,6 +190,20 @@ type stubDB struct { undecryptedByHash []UndecryptedPacket backfillHashes [][]byte dbHook func() // runs in UpsertChannelIATA, the first DB call after InsertObservation + upsertChannelErr error + addCalls []addCall + addErr error +} + +// addCall is one AddChannelMessageIATA call. +type addCall struct { + hash string + iata string +} + +func (s *stubDB) AddChannelMessageIATA(_ context.Context, packetHash []byte, iata string) (bool, error) { + s.addCalls = append(s.addCalls, addCall{string(packetHash), iata}) + return false, s.addErr } type setCapabilityCall struct { @@ -273,7 +287,7 @@ func (s *stubDB) ResolveEndpointHashes(_ context.Context, _ string, _ [][]byte) func (s *stubDB) UpsertChannel(_ context.Context, _ []byte, _ []byte, _, _ string) (int, error) { s.upsertChannelCalls++ - return 0, nil + return 0, s.upsertChannelErr } func (s *stubDB) UpsertChannelHashOnly(_ context.Context, _ []byte) (int, error) { diff --git a/internal/ingest/packet.go b/internal/ingest/packet.go index e875492..ad76659 100644 --- a/internal/ingest/packet.go +++ b/internal/ingest/packet.go @@ -794,6 +794,18 @@ func (w *Worker) handlePacket(ctx context.Context, iata, pubkeyHex string, raw [ // A duplicate is streamed, never stored, to includeRepeats clients when its path is new. repeat := !inserted && pathNew && w.hub.RepeatsWanted() + // A hearing of a stored message records its site next, before any other DB work, so region pages see it at + // once. When no committed message was found, the group-text side effects add it again after their insert + // attempt, which covers a message another hearing is still creating. + siteRecorded := false + if inserted && packet.PayloadType() == meshcore.PayloadTypeGrpTxt { + found, err := w.db.AddChannelMessageIATA(ctx, packetHash[:], iata) + if err != nil { + w.log.Error(fmt.Sprintf("db: record channel message site failed from %s/%s", iata, pubkeyHex), "error", err) + } + siteRecorded = found && err == nil + } + if scopeID != nil && inserted { if err := w.db.UpsertObserverScope(ctx, id, *scopeID); err != nil { w.log.Error(fmt.Sprintf("failed to upsert observer scope for %s", id), "error", err) @@ -856,7 +868,7 @@ func (w *Worker) handlePacket(ctx context.Context, iata, pubkeyHex string, raw [ if inserted || repeat { if inserted { - w.handlePayloadTypeSideEffects(ctx, packet, iata, packetHash[:], radio, scopeID, matchedScope, pubkeyBytes, float32(parseNumber(envelope.SNR))) + w.handlePayloadTypeSideEffects(ctx, packet, iata, packetHash[:], radio, scopeID, matchedScope, pubkeyBytes, float32(parseNumber(envelope.SNR)), siteRecorded) } // Resolve after advert updates; suppressed copies need no endpoint lookup. var resolvedSource, resolvedDestination *api.ResolvedHop diff --git a/internal/ingest/side_effects.go b/internal/ingest/side_effects.go index 3299027..5e40bcd 100644 --- a/internal/ingest/side_effects.go +++ b/internal/ingest/side_effects.go @@ -82,7 +82,9 @@ type nodeUpdateEvent struct { // new observation is confirmed inserted. Currently handles: // - PayloadTypeAdvert (0x04): upsert node and node_iatas // - PayloadTypeGrpTxt (0x05): decrypt and store channel message if key is known -func (w *Worker) handlePayloadTypeSideEffects(ctx context.Context, packet *meshcore.Packet, iata string, packetHash []byte, radio RadioSettings, scopeID *int32, matchedScope *string, observerPubkey []byte, rxSNR float32) { +// +// siteRecorded says an earlier Add for this hearing found the stored message, so its site is already recorded. +func (w *Worker) handlePayloadTypeSideEffects(ctx context.Context, packet *meshcore.Packet, iata string, packetHash []byte, radio RadioSettings, scopeID *int32, matchedScope *string, observerPubkey []byte, rxSNR float32, siteRecorded bool) { if packet.PayloadType() == meshcore.PayloadTypeAdvert { advert, err := meshcore.AdvertFromBytes(packet.Payload) if err != nil { @@ -200,16 +202,13 @@ func (w *Worker) handlePayloadTypeSideEffects(ctx context.Context, packet *meshc return } if packet.PayloadType() == meshcore.PayloadTypeGrpTxt { - grpTxt, err := meshcore.GroupTextFromBytes(packet.Payload) + result, err := StoreGroupText(ctx, w.db, w.keys, packetHash, packet.Payload, iata, siteRecorded) if err != nil { - w.log.Warn("error decoding group text payload", "error", err) - return - } - channelHashBytes := []byte{grpTxt.ChannelHash} - - result, err := DecryptGroupText(ctx, w.db, w.keys, packetHash, packet.Payload, false) - if err != nil { - w.log.Error("decrypt group text failed", "error", err) + if _, decodeErr := meshcore.GroupTextFromBytes(packet.Payload); decodeErr != nil { + w.log.Warn("error decoding group text payload", "error", decodeErr) + } else { + w.log.Error("decrypt group text failed", "error", err) + } return } if result == nil { @@ -217,7 +216,8 @@ func (w *Worker) handlePayloadTypeSideEffects(ctx context.Context, packet *meshc // record a hash-only row so the channel is still visible. If a matching key // gets added to the config later, BackfillChannelMessages retries this packet // at the next boot. - _, _ = w.db.UpsertChannelHashOnly(ctx, channelHashBytes) + grpTxt, _ := meshcore.GroupTextFromBytes(packet.Payload) // decoded inside StoreGroupText + _, _ = w.db.UpsertChannelHashOnly(ctx, []byte{grpTxt.ChannelHash}) return } @@ -227,13 +227,13 @@ func (w *Worker) handlePayloadTypeSideEffects(ctx context.Context, packet *meshc Scope: result.Message.Scope, ScopeStatus: result.Message.ScopeStatus, ChannelID: result.ChannelID, - ChannelHash: hex.EncodeToString(channelHashBytes), + ChannelHash: hex.EncodeToString(result.ChannelHash), PacketHash: hex.EncodeToString(packetHash), SenderName: cleanText(result.Payload.Sender), Content: cleanText(result.Payload.Text), SentAt: time.Unix(int64(result.Payload.Timestamp), 0).UnixMilli(), } - w.broadcast(hub.EventChannelMessage, iata, 0, fmt.Sprintf("%02x", grpTxt.ChannelHash), evt) + w.broadcast(hub.EventChannelMessage, iata, 0, fmt.Sprintf("%02x", result.ChannelHash[0]), evt) } return } diff --git a/internal/ingest/side_effects_test.go b/internal/ingest/side_effects_test.go index d6e6fd5..fce8f55 100644 --- a/internal/ingest/side_effects_test.go +++ b/internal/ingest/side_effects_test.go @@ -92,7 +92,7 @@ func TestAdvertLocationPresence(t *testing.T) { } worker, store := newTestWorker() packet := buildAdvertPacketWithData(t, data, tc.tamper) - worker.handlePayloadTypeSideEffects(context.Background(), packet, "YOW", []byte{1}, RadioSettings{}, nil, nil, nil, 0) + worker.handlePayloadTypeSideEffects(context.Background(), packet, "YOW", []byte{1}, RadioSettings{}, nil, nil, nil, 0, false) if tc.tamper { if store.upsertNodeCalls != 0 { t.Fatal("invalid signature updated the node") @@ -146,7 +146,7 @@ func TestAdvertClearEmitsNullLocation(t *testing.T) { data = binary.LittleEndian.AppendUint32(data, uint32(tc.lat)) data = binary.LittleEndian.AppendUint32(data, uint32(tc.lon)) } - w.handlePayloadTypeSideEffects(ctx, buildAdvertPacketWithData(t, data, false), "AAA", []byte{1}, RadioSettings{}, nil, nil, nil, 0) + w.handlePayloadTypeSideEffects(ctx, buildAdvertPacketWithData(t, data, false), "AAA", []byte{1}, RadioSettings{}, nil, nil, nil, 0, false) for { select { case event := <-client.Send: @@ -175,7 +175,7 @@ func TestHandlePayloadTypeSideEffects_Advert_ValidSignature_UpsertsNode(t *testi w, db := newTestWorker() packet := buildAdvertPacket(t, false) - w.handlePayloadTypeSideEffects(context.Background(), packet, "TEST", []byte{0x01}, RadioSettings{}, nil, nil, nil, 0) + w.handlePayloadTypeSideEffects(context.Background(), packet, "TEST", []byte{0x01}, RadioSettings{}, nil, nil, nil, 0, false) if db.upsertNodeCalls != 1 { t.Errorf("expected UpsertNode to be called once for a validly-signed advert, got %d", db.upsertNodeCalls) @@ -186,7 +186,7 @@ func TestHandlePayloadTypeSideEffects_Advert_InvalidSignature_SkipsUpsert(t *tes w, db := newTestWorker() packet := buildAdvertPacket(t, true) - w.handlePayloadTypeSideEffects(context.Background(), packet, "TEST", []byte{0x01}, RadioSettings{}, nil, nil, nil, 0) + w.handlePayloadTypeSideEffects(context.Background(), packet, "TEST", []byte{0x01}, RadioSettings{}, nil, nil, nil, 0, false) if db.upsertNodeCalls != 0 { t.Errorf("expected UpsertNode NOT to be called for a tampered advert, got %d calls", db.upsertNodeCalls) @@ -222,7 +222,7 @@ func TestHandlePayloadTypeSideEffects_GrpTxt_KnownKey_OnlyUpsertsKeyedChannel(t }} packet := buildGrpTxtPacket(t, channelHash, psk) - w.handlePayloadTypeSideEffects(context.Background(), packet, "TEST", []byte{0x02}, RadioSettings{}, nil, nil, nil, 0) + w.handlePayloadTypeSideEffects(context.Background(), packet, "TEST", []byte{0x02}, RadioSettings{}, nil, nil, nil, 0, false) if db.upsertChannelCalls != 1 { t.Errorf("expected UpsertChannel to be called once, got %d", db.upsertChannelCalls) @@ -237,7 +237,7 @@ func TestHandlePayloadTypeSideEffects_GrpTxt_UnknownKey_OnlyUpsertsHashOnlyChann channelHash := byte(0x99) packet := buildGrpTxtPacket(t, channelHash, make([]byte, 16)) - w.handlePayloadTypeSideEffects(context.Background(), packet, "TEST", []byte{0x03}, RadioSettings{}, nil, nil, nil, 0) + w.handlePayloadTypeSideEffects(context.Background(), packet, "TEST", []byte{0x03}, RadioSettings{}, nil, nil, nil, 0, false) if db.upsertChannelHashOnlyCalls != 1 { t.Errorf("expected UpsertChannelHashOnly to be called once for an unknown-key channel, got %d", db.upsertChannelHashOnlyCalls) diff --git a/internal/metrics/metrics.go b/internal/metrics/metrics.go index 8011736..ad206ca 100644 --- a/internal/metrics/metrics.go +++ b/internal/metrics/metrics.go @@ -7,7 +7,9 @@ package metrics import ( "net/http" + "sync" "sync/atomic" + "time" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/collectors" @@ -113,6 +115,19 @@ var ( Name: "beacon_planguard_last_run_timestamp_seconds", Help: "Unix time the daily plan check last finished.", }) + + // ReadModelRepaired counts the rows each read model's reconcile wrote: anything above zero was missed by a writer + // that bypassed the model. + ReadModelRepaired = prometheus.NewCounterVec(prometheus.CounterOpts{ + Name: "beacon_readmodel_repaired_rows_total", + Help: "Rows the read-model reconcile repaired, by model.", + }, []string{"model"}) + + // ReadModelTrusted is 1 while this process serves pages from a read model, by model. + ReadModelTrusted = prometheus.NewGaugeVec(prometheus.GaugeOpts{ + Name: "beacon_readmodel_trusted", + Help: "1 while this process serves pages from the read model, 0 while it serves the original statements.", + }, []string{"model"}) ) var planguardEnabled atomic.Bool @@ -184,13 +199,41 @@ func SetPgActivity(a PgActivity) { pgActivity.last.Store(&a) } +var watermarkAgeDesc = prometheus.NewDesc("beacon_readmodel_watermark_age_seconds", + "Seconds since this process last finished a reconcile of the read model, by model.", []string{"model"}, nil) + +// watermarkCollector emits the age of each model's last finished reconcile at scrape time. +type watermarkCollector struct { + mu sync.Mutex + at map[string]time.Time +} + +func (c *watermarkCollector) Describe(ch chan<- *prometheus.Desc) { ch <- watermarkAgeDesc } + +func (c *watermarkCollector) Collect(ch chan<- prometheus.Metric) { + c.mu.Lock() + defer c.mu.Unlock() + for model, at := range c.at { + ch <- prometheus.MustNewConstMetric(watermarkAgeDesc, prometheus.GaugeValue, time.Since(at).Seconds(), model) + } +} + +var watermarks = &watermarkCollector{at: map[string]time.Time{}} + +// SetReadModelWatermark records when model's reconcile last finished. +func SetReadModelWatermark(model string, at time.Time) { + watermarks.mu.Lock() + watermarks.at[model] = at + watermarks.mu.Unlock() +} + func init() { Registry.MustRegister( collectors.NewGoCollector(), collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}), GuardWouldRefuse, GuardRefused, GuardDB, DBTime, HTTPRequest, PoolAcquire, IngestQueueDepth, IngestDropped, JobDuration, JobRows, IndexBytes, IndexBloat, - PlanguardFailures, setGauge{PlanguardLastRun, &planguardEnabled}, pgActivity, + PlanguardFailures, setGauge{PlanguardLastRun, &planguardEnabled}, pgActivity, ReadModelRepaired, ReadModelTrusted, watermarks, ) } diff --git a/internal/metrics/metrics_test.go b/internal/metrics/metrics_test.go index 6b565d9..4f4731e 100644 --- a/internal/metrics/metrics_test.go +++ b/internal/metrics/metrics_test.go @@ -6,8 +6,10 @@ package metrics import ( "io" "net/http/httptest" + "strconv" "strings" "testing" + "time" ) func scrape(t *testing.T) string { @@ -27,8 +29,21 @@ func scrape(t *testing.T) string { func TestHandlerServesBeaconMetrics(t *testing.T) { GuardWouldRefuse.WithLabelValues("other", "cap").Inc() SetPgActivity(PgActivity{WALBytes: 7, CheckpointsTimed: 2, CheckpointsRequested: 1, XIDAge: 9}) + ReadModelRepaired.WithLabelValues("cmi_test").Add(3) + ReadModelTrusted.WithLabelValues("cmi_test").Set(1) + SetReadModelWatermark("cmi_test", time.Now().Add(-90*time.Second)) body := scrape(t) + var age float64 + for _, line := range strings.Split(body, "\n") { + if v, ok := strings.CutPrefix(line, `beacon_readmodel_watermark_age_seconds{model="cmi_test"} `); ok { + age, _ = strconv.ParseFloat(v, 64) + } + } + if age < 90 || age > 120 { + t.Errorf("watermark age = %v, want about 90", age) + } for _, want := range []string{ + `beacon_readmodel_repaired_rows_total{model="cmi_test"} 3`, `beacon_readmodel_trusted{model="cmi_test"} 1`, `beacon_guard_would_refuse_total{family="other",guard="cap"} 1`, `beacon_pg_wal_bytes_total 7`, `beacon_pg_checkpoints_total{kind="requested"} 1`, `beacon_pg_xid_age 9`, "go_goroutines", diff --git a/internal/planguard/genpolicy_test.go b/internal/planguard/genpolicy_test.go index 9ed8e8d..0f953f0 100644 --- a/internal/planguard/genpolicy_test.go +++ b/internal/planguard/genpolicy_test.go @@ -116,7 +116,7 @@ func TestGenPolicyMatchesCorpus(t *testing.T) { t.Errorf("db/planpolicy/cached_gen.go is stale; run go run ./cmd/planguard gen-policy. Generated:\n%s", src) } got := slices.Sorted(maps.Keys(planpolicy.Cached)) - if !slices.Equal(got, []string{"GetNodeByID", "GetObserverTelemetrySince", "ListKnownRoutesByIATA", "ListKnownRoutesGlobal", "ListObserverAdverts", "ListPacketsByTypes", "ListPacketsPage"}) { + if !slices.Equal(got, []string{"GetNodeByID", "GetObserverTelemetrySince", "ListAllChannelMessagesByIATAs", "ListAllChannelMessagesPlain", "ListChannelMessagesByIATAs", "ListChannelMessagesPlain", "ListKnownRoutesByIATA", "ListKnownRoutesGlobal", "ListObserverAdverts", "ListPacketsByTypes", "ListPacketsPage"}) { t.Errorf("planpolicy.Cached = %v", got) } for _, line := range []string{ diff --git a/internal/planguard/storediff.go b/internal/planguard/storediff.go index 25c70aa..40d5f14 100644 --- a/internal/planguard/storediff.go +++ b/internal/planguard/storediff.go @@ -38,15 +38,15 @@ type StoreDiffSpec struct { // Any other difference fails. type StoreCase struct { ID string `yaml:"id"` - Path string `yaml:"path"` // /api/v1/...; {name} is replaced by Vars[name] - Query map[string]string `yaml:"query"` + Path string `yaml:"path"` // /api/v1/...; {name} is replaced by Vars[name] + Query map[string]string `yaml:"query"` // values may hold {name} too WebLimit int `yaml:"web_limit"` // the client's page size; default 50 Pages int `yaml:"pages"` // walk cap per limit; default 50 Follow []Follow `yaml:"follow"` // param ← nextPageCursor | nextCursor | last. Allowed []string `yaml:"allowed"` // tie_order (keyed by key) | additive_keys | latest_observer_tie Key []string `yaml:"key"` // item fields for tie_order Omit []string `yaml:"omit"` // item fields for latest_observer_tie - Vars map[string]StoreVar `yaml:"vars"` // path values read from another endpoint + Vars map[string]StoreVar `yaml:"vars"` // path and query values read from another endpoint } // Follow sets a query param of the next page from the old server's page. @@ -55,12 +55,14 @@ type Follow struct { From string `yaml:"from"` } -// StoreVar reads one path value from an endpoint of both servers: From is first. or last. of its -// items. Both servers must give the same value. +// StoreVar reads one value from an endpoint of both servers: From is first. or last. of its items. +// Add, when set, is added to the value, which must then be an integer (a time in epoch milliseconds, say). Both +// servers must give the same value. type StoreVar struct { Path string `yaml:"path"` Query map[string]string `yaml:"query"` From string `yaml:"from"` + Add int64 `yaml:"add"` } // StoreDiffReport is the outcome of RunStoreDiff: one result per case and page size. @@ -180,12 +182,20 @@ func (c StoreCase) validate() error { } used[m[1]] = true } + for k, v := range c.Query { + for _, m := range storeVarRe.FindAllStringSubmatch(v, -1) { + if _, ok := c.Vars[m[1]]; !ok { + return fmt.Errorf("query %s uses {%s}, but vars does not define it", k, m[1]) + } + used[m[1]] = true + } + } if strings.ContainsAny(storeVarRe.ReplaceAllString(c.Path, ""), "{}") { return fmt.Errorf("path %q: a {name} must be [a-z][a-z0-9_]*", c.Path) } for name, v := range c.Vars { if !used[name] { - return fmt.Errorf("vars %s is not used in the path", name) + return fmt.Errorf("vars %s is used in neither the path nor the query", name) } if err := validStorePath(v.Path); err != nil { return fmt.Errorf("vars %s: %w", name, err) @@ -272,10 +282,11 @@ func RunStoreDiff(ctx context.Context, hc *http.Client, oldBase, newBase string, sd := &storeDiff{ctx: ctx, hc: hc, old: strings.TrimRight(oldBase, "/"), new: strings.TrimRight(newBase, "/")} rep := &StoreDiffReport{} for _, c := range spec.Cases { - path, skip, detail, err := sd.resolvePath(c) + path, query, skip, detail, err := sd.resolvePath(c) if err != nil { return rep, fmt.Errorf("case %s: %w", c.ID, err) } + c.Query = query for _, size := range sizes { limit := size if limit == 0 { @@ -395,8 +406,9 @@ func samePage(o, n storePage) string { } // resolvePath fills the path's {name}s from both servers. skip: a var found no value; detail: the servers disagree. -func (sd *storeDiff) resolvePath(c StoreCase) (path string, skip bool, detail string, err error) { +func (sd *storeDiff) resolvePath(c StoreCase) (path string, query map[string]string, skip bool, detail string, err error) { path = c.Path + query = maps.Clone(c.Query) for _, name := range slices.Sorted(maps.Keys(c.Vars)) { v := c.Vars[name] q := url.Values{} @@ -407,27 +419,37 @@ func (sd *storeDiff) resolvePath(c StoreCase) (path string, skip bool, detail st for i, base := range []string{sd.old, sd.new} { p, err := sd.get(base, v.Path, q) if err != nil { - return "", false, "", fmt.Errorf("vars %s: %w", name, err) + return "", nil, false, "", fmt.Errorf("vars %s: %w", name, err) } side := [2]string{"old", "new"}[i] if p.status != http.StatusOK || !p.json { - return "", false, fmt.Sprintf("vars %s: %s server answered %d", name, side, p.status), nil + return "", nil, false, fmt.Sprintf("vars %s: %s server answered %d", name, side, p.status), nil } val, ok, err := pickValue(p.body, v.From) if err != nil { - return "", false, fmt.Sprintf("vars %s: %s server: %v", name, side, err), nil + return "", nil, false, fmt.Sprintf("vars %s: %s server: %v", name, side, err), nil } if !ok { - return "", true, fmt.Sprintf("vars %s: %s %s found no value", name, v.Path, v.From), nil + return "", nil, true, fmt.Sprintf("vars %s: %s %s found no value", name, v.Path, v.From), nil + } + if v.Add != 0 { + n, err := strconv.ParseInt(val, 10, 64) + if err != nil { + return "", nil, false, fmt.Sprintf("vars %s: %s server: %q is not an integer to add to", name, side, val), nil + } + val = strconv.FormatInt(n+v.Add, 10) } vals[i] = val } if vals[0] != vals[1] { - return "", false, fmt.Sprintf("vars %s: old %s, new %s", name, vals[0], vals[1]), nil + return "", nil, false, fmt.Sprintf("vars %s: old %s, new %s", name, vals[0], vals[1]), nil } path = strings.ReplaceAll(path, "{"+name+"}", url.PathEscape(vals[0])) + for k, qv := range query { + query[k] = strings.ReplaceAll(qv, "{"+name+"}", vals[0]) + } } - return path, false, "", nil + return path, query, false, "", nil } // pageItems returns a page's items: the body when it is an array, else its items field. diff --git a/internal/planguard/storediff_test.go b/internal/planguard/storediff_test.go index 8840240..25dbfce 100644 --- a/internal/planguard/storediff_test.go +++ b/internal/planguard/storediff_test.go @@ -531,3 +531,47 @@ func TestStoreDiffLatestObserverTie(t *testing.T) { t.Errorf("valid omit: %v", err) } } + +// Vars fill query values too, and add shifts a numeric value: a case can ask for the newest message's site and a +// since 10 hours before it, read from the data instead of fixed in the file. +func TestStoreDiffQueryVars(t *testing.T) { + var got []string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + switch r.URL.Path { + case "/api/v1/observers": + _ = json.NewEncoder(w).Encode(map[string]any{"items": []any{map[string]any{"iata": "AAA"}, map[string]any{"iata": "BBB"}}, "hasMore": false}) + case "/api/v1/messages": + if r.URL.Query().Get("since") == "" { + _ = json.NewEncoder(w).Encode(map[string]any{"items": []any{map[string]any{"sentAt": 100000}}, "hasMore": false}) + return + } + got = append(got, r.URL.Query().Get("iatas")+"|"+r.URL.Query().Get("since")) + _ = json.NewEncoder(w).Encode(map[string]any{"items": []any{}, "hasMore": false}) + default: + http.NotFound(w, r) + } + })) + t.Cleanup(srv.Close) + spec := &planguard.StoreDiffSpec{Cases: []planguard.StoreCase{{ + ID: "sites_since", Path: "/api/v1/messages", Query: map[string]string{"iatas": "{a},{b}", "since": "{t}"}, + Vars: map[string]planguard.StoreVar{ + "a": {Path: "/api/v1/observers", From: "first.iata"}, + "b": {Path: "/api/v1/observers", From: "last.iata"}, + "t": {Path: "/api/v1/messages", From: "first.sentAt", Add: -36000}, + }, + }}} + if err := spec.Validate(); err != nil { + t.Fatal(err) + } + if c := runStoreDiff(t, srv, srv, spec, "2").Cases[0]; c.Verdict != planguard.DiffIdentical { + t.Fatalf("case: %+v", c) + } + if len(got) == 0 || got[0] != "AAA,BBB|64000" { + t.Fatalf("requests %v, want iatas AAA,BBB and since 64000", got) + } + bad := &planguard.StoreDiffSpec{Cases: []planguard.StoreCase{{ID: "x", Path: "/api/v1/messages", Query: map[string]string{"iatas": "{nope}"}}}} + if err := bad.Validate(); err == nil || !strings.Contains(err.Error(), "vars does not define it") { + t.Fatalf("undefined query var: %v", err) + } +}