opt: index accelerate @> operator for ltree

The @> operator is accelerated by restricting the spans to be the union of
equality spans for all sub-ltrees rooted at ''. For example, a query with
predicate `WHERE a @> 'A.B'` would create spans [/'' - /''], [/'A' - /'A'],
[/'A.B' - /'A.B'].

Informs: #44657
Epic: CRDB-148

Release note (performance improvement): LTREE is now index accelerated with the
`@>` operator.

Author: paulniziolek

pkg/sql/opt/exec/execbuilder/testdata/select_index

@@ -1904,3 +1904,26 @@ vectorized: true
   missing stats
   table: t4@t4_pkey
   spans: [/1/1 - /1/1] [/1/5 - /1/5] [/5/1 - /5/1] [/5/5 - /5/5]
+
+# ------------------------------------------------------------------------------
+# Tests for index acceleration on ancestry operators (@> and <@) using
+# LTREE columns
+# ------------------------------------------------------------------------------
+
+statement ok
+CREATE TABLE t5 (a LTREE)
+
+statement ok
+CREATE INDEX t5_a_idx ON t5 (a)
+
+query T
+EXPLAIN SELECT a FROM t5 WHERE a @> 'A.B.C'
+----
+distribution: local
+vectorized: true
+·
+• scan
+  missing stats
+  table: t5@t5_a_idx
+  spans: [/'' - /''] [/'A' - /'A'] [/'A.B' - /'A.B'] [/'A.B.C' - /'A.B.C']
+

pkg/sql/opt/idxconstraint/BUILD.bazel

@@ -16,6 +16,7 @@ go_library(
         "//pkg/sql/sem/tree",
         "//pkg/sql/types",
         "//pkg/util",
+        "//pkg/util/ltree",
         "@com_github_cockroachdb_errors//:errors",
     ],
 )

pkg/sql/opt/idxconstraint/index_constraints.go

@@ -20,6 +20,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/sql/sem/tree"
 	"github.com/cockroachdb/cockroach/pkg/sql/types"
 	"github.com/cockroachdb/cockroach/pkg/util"
+	"github.com/cockroachdb/cockroach/pkg/util/ltree"
 	"github.com/cockroachdb/errors"
 )
 
@@ -338,6 +339,39 @@ func (c *indexConstraintCtx) makeSpansForSingleColumnDatum(
 				return complete
 			}
 		}
+
+	case opt.ContainsOp:
+		if l, ok := datum.(*tree.DLTree); ok {
+			var spans constraint.Spans
+			// We need to create an equality span for each subtree of the LTree that
+			// is rooted from the root, including the empty ltree.
+			spans.Alloc(l.LTree.Len() + 1)
+			keyCtx := &c.keyCtx[offset]
+			for i := 0; i <= l.LTree.Len(); i++ {
+				var subLTree ltree.T
+				if l.LTree.Compare(ltree.Empty) != 0 {
+					var err error
+					subLTree, err = l.LTree.SubPath(0 /* offset */, i /* length */)
+					if err != nil {
+						panic(err)
+					}
+				} else {
+					// SubPath is not graceful with empty ltree, thus we handle it here.
+					subLTree = ltree.Empty
+				}
+				key := constraint.MakeKey(tree.NewDLTree(subLTree))
+				var sp constraint.Span
+				sp.Init(key, includeBoundary, key, includeBoundary)
+				spans.Append(&sp)
+			}
+			// Given how we've constructed the spans, they already are ordered and
+			// unique, but we choose to call SortAndMerge for symmetry with other
+			// expressions and as a sanity check (the function exits quickly if the
+			// ordering is already correct).
+			spans.SortAndMerge(keyCtx)
+			out.Init(keyCtx, &spans)
+			return true
+		}
 	}
 	c.unconstrained(offset, out)
 	return false

pkg/sql/opt/idxconstraint/testdata/ltree

@@ -0,0 +1,23 @@
+index-constraints vars=(a ltree) index=a
+a @> '-'
+----
+[/'' - /'']
+[/'-' - /'-']
+
+index-constraints vars=(a ltree) index=a
+a @> 'A.B.C'
+----
+[/'' - /'']
+[/'A' - /'A']
+[/'A.B' - /'A.B']
+[/'A.B.C' - /'A.B.C']
+
+index-constraints vars=(a ltree) index=a
+a @> ''
+----
+[/'' - /'']
+
+index-constraints vars=(a ltree) index=a
+a @> NULL
+----
+