Assume text index comparisons are exact (#2619)

* assume text index comparisons are exact

* fix tests

* better safety check for filter elim

* protect prefix indexes from filter elimination

* zach comments

enginetest/enginetests.go

@@ -4770,7 +4770,6 @@ func TestTracing(t *testing.T, harness Harness) {
 		"plan.Distinct",
 		"plan.Project",
 		"plan.Sort",
-		"plan.Filter",
 		"plan.IndexedTableAccess",
 	}
 

enginetest/queries/queries.go

@@ -1077,6 +1077,22 @@ Select * from (
 		Query:    "select count(*) from typestable where s1 in ('', 'bye');",
 		Expected: []sql.Row{{1}},
 	},
+	{
+		Query:    "select count(*) from mytable where s in ('', 'first row');",
+		Expected: []sql.Row{{1}},
+	},
+	{
+		Query:    "select count(*) from mytable where s in (1, 'first row');",
+		Expected: []sql.Row{{1}},
+	},
+	{
+		Query:    "select count(*) from mytable where s in (NULL, 'first row');",
+		Expected: []sql.Row{{1}},
+	},
+	{
+		Query:    "select count(*) from niltable where i2 in (NULL, 1);",
+		Expected: []sql.Row{{0}},
+	},
 	{
 		Query: "SELECT * FROM mytable;",
 		Expected: []sql.Row{

sql/analyzer/costed_index_scan.go

@@ -104,7 +104,7 @@ func indexSearchableLookup(n sql.Node, rt sql.TableNode, lookup sql.IndexLookup,
 		return n, transform.SameTree, nil
 	}
 
-	if !iat.PreciseMatch() {
+	if !preciseIndexAccess(iat, lookup.Index) {
 		// cannot drop any filters
 		newFilter = oldFilter
 	}
@@ -284,7 +284,7 @@ func getCostedIndexScan(ctx *sql.Context, statsProv sql.StatsProvider, rt sql.Ta
 	}
 
 	var retFilters []sql.Expression
-	if !iat.PreciseMatch() {
+	if !preciseIndexAccess(iat, lookup.Index) {
 		// cannot drop filters
 		retFilters = filters
 	} else if len(b.leftover) > 0 {
@@ -357,7 +357,7 @@ func addIndexScans(m *memo.Memo) error {
 				}
 
 				var keepFilters []sql.Expression
-				if !iat.PreciseMatch() {
+				if !preciseIndexAccess(iat, lookup.Index) {
 					// cannot drop any filters
 					keepFilters = filter.Filters
 				} else {
@@ -402,6 +402,12 @@ func addIndexScans(m *memo.Memo) error {
 	})
 }
 
+// preciseIndexAccess returns whether an indexed access into a table is a
+// replacement for relational filters.
+func preciseIndexAccess(t sql.IndexAddressableTable, i sql.Index) bool {
+	return t.PreciseMatch() && !i.IsFullText() && !i.IsSpatial() && len(i.PrefixLengths()) == 0
+}
+
 func newIndexCoster(ctx *sql.Context, underlyingName string) *indexCoster {
 	return &indexCoster{
 		ctx:            ctx,

sql/expression/comparison.go

@@ -50,21 +50,14 @@ func PreciseComparison(e sql.Expression) bool {
 				return true
 			}
 
+			// string type comparisons are exact
+			if types.IsText(left) && types.IsText(right) {
+				return true
+			}
+
 			if tupType, ok := right.(types.TupleType); ok {
-				if types.IsInteger(left) {
-					rightIsAllInt := true
-					for _, typ := range tupType {
-						if !types.IsInteger(typ) {
-							rightIsAllInt = false
-							break
-						}
-					}
-					if rightIsAllInt {
-						// left integer and right tuple integer types is OK
-						return true
-					}
-					imprecise = true
-					return false
+				if tupleTypesMatch(left, tupType, types.IsInteger) || tupleTypesMatch(left, tupType, types.IsText) {
+					return true
 				}
 				for _, right := range tupType {
 					if !left.Equals(right) {
@@ -86,6 +79,18 @@ func PreciseComparison(e sql.Expression) bool {
 	return !imprecise
 }
 
+func tupleTypesMatch(left sql.Type, tup types.TupleType, typeCb func(t sql.Type) bool) bool {
+	if !typeCb(left) {
+		return false
+	}
+	for _, right := range tup {
+		if !typeCb(right) {
+			return false
+		}
+	}
+	return true
+}
+
 type comparison struct {
 	BinaryExpressionStub
 }