opt: make functional dependency calculation deterministic

We recently added additional logic for inferring functional dependencies
for join expressions. However, this logic iterates through a map, which
leads to nondeterminism in which order functional dependencies are added
to the FD set. Functional dependency calculation is best-effort, so this
can lead to a different resulting FD set, which causes flaky tests. This
patch makes the calculation deterministic by iterating instead through a
`intsets.Fast` set.

Fixes cockroachdb#107148

Release note: None

Author: DrewKimball

pkg/sql/opt/memo/logical_props_builder.go

@@ -2526,57 +2526,54 @@ func (h *joinPropsHelper) addSelfJoinImpliedFDs(rel *props.Relational) {
 		// There are no equalities between left and right columns.
 		return
 	}
-	// Map from the table ID to the column ordinals within the table.
-	getTables := func(cols opt.ColSet) map[opt.TableID]intsets.Fast {
-		var tables map[opt.TableID]intsets.Fast
+	// Retrieve the tables that originate the given columns.
+	getTables := func(cols opt.ColSet) intsets.Fast {
+		var tables intsets.Fast
 		cols.ForEach(func(col opt.ColumnID) {
 			if tab := md.ColumnMeta(col).Table; tab != opt.TableID(0) {
-				if tables == nil {
-					tables = make(map[opt.TableID]intsets.Fast)
-				}
-				colOrds := tables[tab]
-				colOrds.Add(tab.ColumnOrdinal(col))
-				tables[tab] = colOrds
+				tables.Add(int(tab))
 			}
 		})
 		return tables
 	}
-	leftTables := getTables(leftCols)
-	if leftTables == nil {
-		return
-	}
-	rightTables := getTables(rightCols)
-	if rightTables == nil {
+	leftTables, rightTables := getTables(leftCols), getTables(rightCols)
+	if leftTables.Empty() || rightTables.Empty() {
 		return
 	}
-	for leftTable, leftTableOrds := range leftTables {
+	leftTables.ForEach(func(left int) {
+		leftTable := opt.TableID(left)
 		baseTabFDs := MakeTableFuncDep(md, leftTable)
-		for rightTable, rightTableOrds := range rightTables {
+		rightTables.ForEach(func(right int) {
+			rightTable := opt.TableID(right)
 			if md.TableMeta(leftTable).Table.ID() != md.TableMeta(rightTable).Table.ID() {
-				continue
+				return
 			}
 			// This is a self-join. If there are equalities between columns at the
 			// same ordinal positions in each (meta) table and those columns form a
 			// key on the base table, *every* pair of columns at the same ordinal
 			// position is equal.
 			var eqCols opt.ColSet
-			colOrds := leftTableOrds.Intersection(rightTableOrds)
-			for colOrd, ok := colOrds.Next(0); ok; colOrd, ok = colOrds.Next(colOrd + 1) {
+			var outColOrds intsets.Fast
+			numCols := md.Table(leftTable).ColumnCount()
+			for colOrd := 0; colOrd < numCols; colOrd++ {
 				leftCol, rightCol := leftTable.ColumnID(colOrd), rightTable.ColumnID(colOrd)
-				if rel.FuncDeps.AreColsEquiv(leftCol, rightCol) {
-					eqCols.Add(leftCol)
-					eqCols.Add(rightCol)
+				if rel.OutputCols.Contains(leftCol) && rel.OutputCols.Contains(rightCol) {
+					outColOrds.Add(colOrd)
+					if rel.FuncDeps.AreColsEquiv(leftCol, rightCol) {
+						eqCols.Add(leftCol)
+						eqCols.Add(rightCol)
+					}
 				}
 			}
 			if !eqCols.Empty() && baseTabFDs.ColsAreStrictKey(eqCols) {
 				// Add equalities between each pair of columns at the same ordinal
 				// position, ignoring those that aren't part of the output.
-				for colOrd, ok := colOrds.Next(0); ok; colOrd, ok = colOrds.Next(colOrd + 1) {
+				outColOrds.ForEach(func(colOrd int) {
 					rel.FuncDeps.AddEquivalency(leftTable.ColumnID(colOrd), rightTable.ColumnID(colOrd))
-				}
+				})
 			}
-		}
-	}
+		})
+	})
 }
 
 func (h *joinPropsHelper) cardinality() props.Cardinality {