Better join commutativity count (#1051)

We excluded joins on the basis of join factors in the logical join tree,
rather than distinct join subtrees subject to commutativity. The
difference is that we have to permute n! to optimize the search space
of all valid commutative trees, versus a k^n (k = table rows) execution
runtime. 12! blocks analysis, k^12 is steep but can be OK depending on
cardinality and indexes. We impose no limits on k^n joins.

Author: max-hoffman

enginetest/queries/queries.go

@@ -8491,26 +8491,6 @@ var ErrorQueries = []QueryErrorTest{
 						t14.i = t15.i`,
 		ExpectedErr: sql.ErrUnsupportedJoinFactorCount,
 	},
-	{
-		Query: `SELECT t1.*
-					  FROM
-						mytable as t1,
-						mytable as t2,
-						mytable as t3,
-						mytable as t4,
-						mytable as t5,
-						mytable as t6,
-						mytable as t7,
-						mytable as t8,
-						mytable as t9,
-						mytable as t10,
-						mytable as t11,
-						mytable as t12,
-						mytable as t13,
-						mytable as t14,
-						mytable as t15`,
-		ExpectedErr: sql.ErrUnsupportedJoinFactorCount,
-	},
 	{
 		Query: `SELECT t1.*
 					  FROM

sql/analyzer/indexed_joins.go

@@ -403,7 +403,10 @@ func replanJoin(
 	joinHint := extractJoinHint(node)
 
 	// Collect all tables
-	tableJoinOrder := newJoinOrderNode(node)
+	tableJoinOrder, cnt := newJoinOrderNode(node)
+	if cnt > joinComplexityLimit {
+		return nil, transform.SameTree, sql.ErrUnsupportedJoinFactorCount.New(joinComplexityLimit, cnt)
+	}
 
 	// Find a hinted or cost optimized access order for them
 	ordered := false

sql/analyzer/join_search.go

@@ -413,22 +413,22 @@ func visitCommutableJoinSearchNodes(indexes []int, nodes []joinOrderNode, cb fun
 // table, table alias or subquery alias gets a leaf node, a sequence
 // of commutable joins get coalesced into a single node with children
 // set in `commutes`, and a left or right join gets a node with a
-// `left` and a `right` child.  original on the left and the new table
-// being joined on the right.
-func newJoinOrderNode(node sql.Node) *joinOrderNode {
+// `left` and a `right` child original on the left and the new table
+// being joined on the right. Returns a tree's root and node count.
+func newJoinOrderNode(node sql.Node) (*joinOrderNode, int) {
 	switch node := node.(type) {
 	case *plan.TableAlias, *plan.ResolvedTable, *plan.SubqueryAlias, *plan.ValueDerivedTable:
 		n := node.(NameableNode)
-		return &joinOrderNode{node: n, name: strings.ToLower(n.Name())}
+		return &joinOrderNode{node: n, name: strings.ToLower(n.Name())}, 1
 	case *plan.CrossJoin:
-		return &joinOrderNode{node: node}
+		return &joinOrderNode{node: node}, 1
 	case plan.JoinNode:
-		ljo := newJoinOrderNode(node.Left())
-		rjo := newJoinOrderNode(node.Right())
+		ljo, lcnt := newJoinOrderNode(node.Left())
+		rjo, rcnt := newJoinOrderNode(node.Right())
 		if node.JoinType() == plan.JoinTypeLeft {
-			return &joinOrderNode{left: ljo, right: rjo}
+			return &joinOrderNode{left: ljo, right: rjo}, lcnt + rcnt
 		} else if node.JoinType() == plan.JoinTypeRight {
-			return &joinOrderNode{left: rjo, right: ljo}
+			return &joinOrderNode{left: rjo, right: ljo}, lcnt + rcnt
 		} else {
 			commutes := append(ljo.commutes, rjo.commutes...)
 			if ljo.left != nil || ljo.node != nil {
@@ -437,7 +437,7 @@ func newJoinOrderNode(node sql.Node) *joinOrderNode {
 			if rjo.left != nil || rjo.node != nil {
 				commutes = append(commutes, *rjo)
 			}
-			return &joinOrderNode{commutes: commutes}
+			return &joinOrderNode{commutes: commutes}, lcnt + rcnt
 		}
 	default:
 		panic(fmt.Sprintf("unexpected node type: %t", node))

sql/analyzer/rules.go

@@ -57,7 +57,6 @@ var OnceBeforeDefault = []Rule{
 	{validateDatabaseSetId, validateDatabaseSet},
 	{validatePriviledgesId, validatePrivileges}, // Ensure that checking privileges happens after db, table  & table function resolution
 	{stripDecorationsId, stripDecorations},
-	{validateJoinComplexityId, validateJoinComplexity},
 }
 
 // DefaultRules to apply when analyzing nodes.