java-topology/docs/tickets/cockroachdb-0001-indexes-used-slice-contains-per-add.md

cockroachdb-0001: IndexesUsed.add() slices.Contains on growing slice — O(N²)

Severity: MEDIUM File: pkg/sql/opt/exec/execbuilder/builder.go Line: 206–216 Status: PATCHED

Description

IndexesUsed accumulates the set of (tableID, indexID) pairs referenced by a query. Its add method deduplicates by scanning the existing slice:

func (iu *IndexesUsed) add(tableID, indexID cat.StableID) {
    s := struct{ tableID cat.StableID; indexID cat.StableID }{tableID, indexID}
    if !slices.Contains(iu.indexes, s) {
        iu.indexes = append(iu.indexes, s)
    }
}

add is called once per index reference during execution plan building (relational.go lines 859, 1009, 2475, 2999, 3197, 3339×2, 4123, 4170). A query joining N tables each with multiple indexes calls add O(N) times; each call scans the slice from position 0, giving O(N²) total comparisons.

For a 200-table star-schema query this is ~20 000 struct comparisons where a map lookup would be ~200.

Root Cause

IndexesUsed uses []struct{...} as its backing store. slices.Contains performs a linear scan. No map or set is used to track membership separately.

Fix

Replace the slice with a map for O(1) deduplication; keep the slice for ordered iteration in Strings():

type IndexesUsed struct {
    indexes []struct {
        tableID cat.StableID
        indexID cat.StableID
    }
    seen map[[2]cat.StableID]struct{}
}

func (iu *IndexesUsed) add(tableID, indexID cat.StableID) {
    key := [2]cat.StableID{tableID, indexID}
    if iu.seen == nil {
        iu.seen = make(map[[2]cat.StableID]struct{})
    }
    if _, ok := iu.seen[key]; !ok {
        iu.seen[key] = struct{}{}
        iu.indexes = append(iu.indexes, struct {
            tableID cat.StableID
            indexID cat.StableID
        }{tableID, indexID})
    }
}

Strings() is unchanged — it still iterates iu.indexes.

Speedup

O(N²) → O(N). ~100x at N=200 indexes per complex query.