planner: add some e2e test cases for outer join elimination (#58070)

ref #54057

Author: qw4990

pkg/expression/schema.go

@@ -46,10 +46,10 @@ func (ki KeyInfo) String() string {
 // Schema stands for the row schema and unique key information get from input.
 type Schema struct {
 	Columns []*Column
-	Keys    []KeyInfo
-	// UniqueKeys stores those unique indexes that allow null values, but Keys does not allow null values.
-	// since equivalence conditions can filter out null values, in this case a unique index with null values can be a Key.
-	UniqueKeys []KeyInfo
+	PKOrUK  []KeyInfo // this fields stores the primary key or unique key.
+	// NullableUK stores those unique indexes that allow null values, but PKOrUK does not allow null values.
+	// Since equivalence conditions can filter out null values, in this case a unique index with null values can be a Key.
+	NullableUK []KeyInfo
 }
 
 // String implements fmt.Stringer interface.
@@ -58,17 +58,17 @@ func (s *Schema) String() string {
 	for _, col := range s.Columns {
 		colStrs = append(colStrs, col.String())
 	}
-	strs := make([]string, 0, len(s.Keys))
-	for _, key := range s.Keys {
+	strs := make([]string, 0, len(s.PKOrUK))
+	for _, key := range s.PKOrUK {
 		strs = append(strs, key.String())
 	}
-	ukStrs := make([]string, 0, len(s.Keys))
-	for _, key := range s.UniqueKeys {
+	ukStrs := make([]string, 0, len(s.PKOrUK))
+	for _, key := range s.NullableUK {
 		ukStrs = append(ukStrs, key.String())
 	}
 	return "Column: [" + strings.Join(colStrs, ",") +
-		"] Key: [" + strings.Join(strs, ",") +
-		"] Unique key: [" + strings.Join(ukStrs, ",") + "]"
+		"] PKOrUK: [" + strings.Join(strs, ",") +
+		"] NullableUK: [" + strings.Join(ukStrs, ",") + "]"
 }
 
 // Clone copies the total schema.
@@ -77,18 +77,18 @@ func (s *Schema) Clone() *Schema {
 		return nil
 	}
 	cols := make([]*Column, 0, s.Len())
-	keys := make([]KeyInfo, 0, len(s.Keys))
+	keys := make([]KeyInfo, 0, len(s.PKOrUK))
 	for _, col := range s.Columns {
 		cols = append(cols, col.Clone().(*Column))
 	}
-	for _, key := range s.Keys {
+	for _, key := range s.PKOrUK {
 		keys = append(keys, key.Clone())
 	}
 	schema := NewSchema(cols...)
 	schema.SetKeys(keys)
-	if s.UniqueKeys != nil {
-		uniqueKeys := make([]KeyInfo, 0, len(s.UniqueKeys))
-		for _, key := range s.UniqueKeys {
+	if s.NullableUK != nil {
+		uniqueKeys := make([]KeyInfo, 0, len(s.NullableUK))
+		for _, key := range s.NullableUK {
 			uniqueKeys = append(uniqueKeys, key.Clone())
 		}
 		schema.SetUniqueKeys(uniqueKeys)
@@ -145,9 +145,9 @@ func (s *Schema) RetrieveColumn(col *Column) *Column {
 // Pass strong=true to check strong contraint: unique && notnull.
 // Pass strong=false to check weak contraint: unique && nullable.
 func (s *Schema) IsUnique(strong bool, cols ...*Column) bool {
-	slicesToBeIterated := s.UniqueKeys
+	slicesToBeIterated := s.NullableUK
 	if strong {
-		slicesToBeIterated = s.Keys
+		slicesToBeIterated = s.PKOrUK
 	}
 	for _, key := range slicesToBeIterated {
 		if len(key) > len(cols) {
@@ -210,12 +210,12 @@ func (s *Schema) Append(col ...*Column) {
 
 // SetKeys will set the value of Schema.Keys.
 func (s *Schema) SetKeys(keys []KeyInfo) {
-	s.Keys = keys
+	s.PKOrUK = keys
 }
 
 // SetUniqueKeys will set the value of Schema.UniqueKeys.
 func (s *Schema) SetUniqueKeys(keys []KeyInfo) {
-	s.UniqueKeys = keys
+	s.NullableUK = keys
 }
 
 // ColumnsIndices will return a slice which contains the position of each column in schema.
@@ -269,18 +269,18 @@ func (s *Schema) MemoryUsage() (sum int64) {
 		return
 	}
 
-	sum = emptySchemaSize + int64(cap(s.Columns))*size.SizeOfPointer + int64(cap(s.Keys)+cap(s.UniqueKeys))*size.SizeOfSlice
+	sum = emptySchemaSize + int64(cap(s.Columns))*size.SizeOfPointer + int64(cap(s.PKOrUK)+cap(s.NullableUK))*size.SizeOfSlice
 
 	for _, col := range s.Columns {
 		sum += col.MemoryUsage()
 	}
-	for _, cols := range s.Keys {
+	for _, cols := range s.PKOrUK {
 		sum += int64(cap(cols)) * size.SizeOfPointer
 		for _, col := range cols {
 			sum += col.MemoryUsage()
 		}
 	}
-	for _, cols := range s.UniqueKeys {
+	for _, cols := range s.NullableUK {
 		sum += int64(cap(cols)) * size.SizeOfPointer
 		for _, col := range cols {
 			sum += col.MemoryUsage()

pkg/expression/schema_test.go

@@ -34,7 +34,7 @@ func generateKeys4Schema(schema *Schema) {
 	for i := 0; i < keyCount; i++ {
 		keys = append(keys, []*Column{schema.Columns[i]})
 	}
-	schema.Keys = keys
+	schema.PKOrUK = keys
 }
 
 // generateSchema will generate a schema for test. Used only in this file.
@@ -63,16 +63,16 @@ func TestSchemaClone(t *testing.T) {
 	clonedSchema := schema.Clone()
 	require.Equal(t, schema.String(), clonedSchema.String())
 
-	require.NotSame(t, unsafe.SliceData(schema.Keys), unsafe.SliceData(clonedSchema.Keys))
-	require.NotSame(t, unsafe.SliceData(schema.UniqueKeys), unsafe.SliceData(clonedSchema.UniqueKeys))
+	require.NotSame(t, unsafe.SliceData(schema.PKOrUK), unsafe.SliceData(clonedSchema.PKOrUK))
+	require.NotSame(t, unsafe.SliceData(schema.NullableUK), unsafe.SliceData(clonedSchema.NullableUK))
 }
 
 func TestSchemaString(t *testing.T) {
 	s := &schemaGenerator{}
 	schema := s.generateSchema(5)
-	require.Equal(t, "Column: [Column#1,Column#2,Column#3,Column#4,Column#5] Key: [] Unique key: []", schema.String())
+	require.Equal(t, "Column: [Column#1,Column#2,Column#3,Column#4,Column#5] PKOrUK: [] NullableUK: []", schema.String())
 	generateKeys4Schema(schema)
-	require.Equal(t, "Column: [Column#1,Column#2,Column#3,Column#4,Column#5] Key: [[Column#1],[Column#2],[Column#3],[Column#4]] Unique key: []", schema.String())
+	require.Equal(t, "Column: [Column#1,Column#2,Column#3,Column#4,Column#5] PKOrUK: [[Column#1],[Column#2],[Column#3],[Column#4]] NullableUK: []", schema.String())
 }
 
 func TestSchemaRetrieveColumn(t *testing.T) {

pkg/planner/cascades/old/stringer.go

@@ -74,9 +74,9 @@ func groupToString(ctx expression.EvalContext, g *memo.Group, idMap map[*memo.Gr
 	groupLine := bytes.NewBufferString("")
 	fmt.Fprintf(groupLine, "Group#%d Schema:[%s]", idMap[g], strings.Join(colStrs, ","))
 
-	if len(g.Prop.Schema.Keys) > 0 {
-		ukStrs := make([]string, 0, len(schema.Keys))
-		for _, key := range schema.Keys {
+	if len(g.Prop.Schema.PKOrUK) > 0 {
+		ukStrs := make([]string, 0, len(schema.PKOrUK))
+		for _, key := range schema.PKOrUK {
 			ukColStrs := make([]string, 0, len(key))
 			for _, col := range key {
 				ukColStrs = append(ukColStrs, col.StringWithCtx(ctx, errors.RedactLogDisable))

pkg/planner/cascades/old/transformation_rules.go

@@ -1904,7 +1904,7 @@ func (*outerJoinEliminator) prepareForEliminateOuterJoin(joinExpr *memo.GroupExp
 func (*outerJoinEliminator) isInnerJoinKeysContainUniqueKey(innerGroup *memo.Group, joinKeys *expression.Schema) (bool, error) {
 	// builds UniqueKey info of innerGroup.
 	innerGroup.BuildKeyInfo()
-	for _, keyInfo := range innerGroup.Prop.Schema.Keys {
+	for _, keyInfo := range innerGroup.Prop.Schema.PKOrUK {
 		joinKeysContainKeyInfo := true
 		for _, col := range keyInfo {
 			if !joinKeys.Contains(col) {
@@ -2191,7 +2191,7 @@ func (*TransformAggToProj) Match(expr *memo.ExprIter) bool {
 	childGroup := expr.GetExpr().Children[0]
 	childGroup.BuildKeyInfo()
 	schemaByGroupby := expression.NewSchema(agg.GetGroupByCols()...)
-	for _, key := range childGroup.Prop.Schema.Keys {
+	for _, key := range childGroup.Prop.Schema.PKOrUK {
 		if schemaByGroupby.ColumnsIndices(key) != nil {
 			return true
 		}

pkg/planner/core/casetest/BUILD.bazel

@@ -12,7 +12,7 @@ go_test(
     ],
     data = glob(["testdata/**"]),
     flaky = True,
-    shard_count = 28,
+    shard_count = 29,
     deps = [
         "//pkg/domain",
         "//pkg/errno",