Use selectivity in LookupJoin cost estimate

enginetest/join_planning_tests.go

@@ -260,7 +260,7 @@ var JoinPlanningTests = []joinPlanScript{
 			{
 				// When primary table is much larger, doing many lookups is expensive: prefer merge
 				q:     "select /*+ JOIN_ORDER(rs, xy) */ * from rs join xy on x = r order by 1,3",
-				types: []plan.JoinType{plan.JoinTypeLookup},
+				types: []plan.JoinType{plan.JoinTypeMerge},
 				exp:   []sql.Row{{0, 0, 0, 8}, {2, 3, 2, 1}, {3, 0, 3, 7}, {4, 8, 4, 0}, {5, 4, 5, 4}},
 			},
 			{
@@ -411,7 +411,7 @@ var JoinPlanningTests = []joinPlanScript{
 			},
 			{
 				q:     "select * from xy where y+1 not in (select u from uv);",
-				types: []plan.JoinType{plan.JoinTypeLeftOuterHashExcludeNulls},
+				types: []plan.JoinType{plan.JoinTypeLeftOuterLookup},
 				exp:   []sql.Row{{3, 3}},
 			},
 			{
@@ -822,7 +822,7 @@ where u in (select * from rec);`,
 		tests: []JoinPlanTest{
 			{
 				q:     "select * from xy where x in (select u from uv join ab on u = a and a = 2) order by 1;",
-				types: []plan.JoinType{plan.JoinTypeInner, plan.JoinTypeLookup},
+				types: []plan.JoinType{plan.JoinTypeLookup, plan.JoinTypeLookup},
 				exp:   []sql.Row{{2, 1}},
 			},
 			{

memory/table.go

@@ -507,6 +507,10 @@ func (i *indexScanRowIter) Next(ctx *sql.Context) (sql.Row, error) {
 }
 
 func indexRowMatches(ranges sql.Expression, candidate sql.Row) (bool, error) {
+	if ranges == nil {
+		// If there is no ranges expression, default to match all (return all rows)
+		return true, nil
+	}
 	result, err := ranges.Eval(nil, candidate)
 	if err != nil {
 		return false, err
@@ -1670,6 +1674,10 @@ func adjustRangeScanFilterForIndexLookup(filter sql.Expression, index *Index) sq
 		}
 	}
 
+	if filter == nil {
+		return filter
+	}
+
 	filter, _, err := transform.Expr(filter, func(e sql.Expression) (sql.Expression, transform.TreeIdentity, error) {
 		if gf, ok := e.(*expression.GetField); ok {
 			idxIdx := indexStorageSchema.IndexOfColName(gf.Name())

sql/memo/coster.go

@@ -124,15 +124,14 @@ func (c *coster) costRel(ctx *sql.Context, n RelExpr, s sql.StatsProvider) (floa
 			// TODO added overhead for right lookups
 			switch n := n.(type) {
 			case *LookupJoin:
-				if !n.Injective {
-					// partial index completion is undesirable
-					// TODO don't do this whe we have stats
-					selfJoinCard = math.Max(0, selfJoinCard+float64(indexCoverageAdjustment(n.Lookup)))
+				if n.Injective {
+					return lBest*seqIOCostFactor + lBest*randIOCostFactor, nil
 				}
-
+				sel := lookupJoinSelectivity(n.Lookup, n.JoinBase)
+				expectedRightRows := selfJoinCard * sel
 				// read the whole left table and randIO into table equivalent to
 				// this join's output cardinality estimate
-				return lBest*seqIOCostFactor + selfJoinCard*(randIOCostFactor+seqIOCostFactor), nil
+				return lBest*seqIOCostFactor + expectedRightRows*randIOCostFactor, nil
 			case *ConcatJoin:
 				return c.costConcatJoin(ctx, n, s)
 			}