sql: add LTREE valueside encoding

LTREE datums are valueside encoded by their byte representation including path
separators.

Informs: #44657
Epic: CRDB-148

Release note: None

Author: paulniziolek

pkg/sql/catalog/colinfo/col_type_info.go

@@ -230,6 +230,10 @@ func MustBeValueEncoded(semanticType *types.T) bool {
 		return true
 	case types.PGVectorFamily:
 		return true
+	case types.LTreeFamily:
+		// TODO(paulniziolek): LTreeFamily should be supported in keyside encoding.
+		// Temporarily, we disallow it, until implemented.
+		return true
 	}
 	return false
 }

pkg/sql/logictest/testdata/logic_test/ltree

@@ -0,0 +1,80 @@
+statement ok
+CREATE TABLE l (lt LTREE);
+
+statement ok
+CREATE TABLE la (lta LTREE[]);
+
+statement ok
+INSERT INTO l VALUES ('A'), ('A.B'), ('A.B.C'), ('A.B.D'), ('Z');
+
+statement ok
+INSERT INTO la VALUES (ARRAY['A', 'A.B']), (ARRAY['A.B.C', 'A.B.D', 'Z']), (ARRAY['X', 'Y']), (ARRAY[]), (ARRAY['']);
+
+query T
+SELECT * FROM l ORDER BY lt;
+----
+A
+A.B
+A.B.C
+A.B.D
+Z
+
+query T
+SELECT * FROM la ORDER BY lta;
+----
+{}
+{""}
+{A,A.B}
+{A.B.C,A.B.D,Z}
+{X,Y}
+
+query T
+SELECT pg_typeof(lt) FROM l LIMIT 1;
+----
+ltree
+
+query T
+SELECT pg_typeof(lta) FROM la LIMIT 1;
+----
+ltree[]
+
+query error label length is 1001, must be at most 1000
+INSERT INTO l VALUES (repeat('A', 1001)::LTREE)
+
+query error number of ltree labels \(65536\) exceeds the maximum allowed \(65535\)
+INSERT INTO l VALUES ((SELECT string_agg('A', '.') FROM generate_series(1, 65536))::LTREE)
+
+query B
+SELECT 'A.B.C'::LTREE = 'A.B.C'
+----
+true
+
+query B
+SELECT 'A.B.C'::LTREE = 'A.B'
+----
+false
+
+query B
+SELECT 'A.B.C'::LTREE < 'A.B'
+----
+false
+
+query B
+SELECT 'A.B'::LTREE < 'A.B.C'
+----
+true
+
+query B
+SELECT ARRAY['A', 'A.B']::LTREE[] = ARRAY['A', 'A.B']
+----
+true
+
+query B
+SELECT ARRAY['A', 'A.B']::LTREE[] = ARRAY['A.B', 'A']
+----
+false
+
+query B
+SELECT ARRAY['A', 'A.B']::LTREE[] < ARRAY['A', 'A.B.C']
+----
+true

pkg/sql/rowenc/encoded_datum_test.go

@@ -218,6 +218,10 @@ func TestEncDatumCompare(t *testing.T) {
 		case types.AnyFamily, types.UnknownFamily, types.ArrayFamily, types.JsonFamily, types.TupleFamily, types.VoidFamily,
 			types.TSQueryFamily, types.TSVectorFamily, types.PGVectorFamily, types.TriggerFamily, types.JsonpathFamily:
 			continue
+		case types.LTreeFamily:
+			// TODO(paulniziolek): Temporarily skip LTrees as they are
+			// currently missing keyside indexing support.
+			continue
 		case types.CollatedStringFamily:
 			typ = types.MakeCollatedString(types.String, *randgen.RandCollationLocale(rng))
 		}

pkg/sql/rowenc/index_encoding_test.go

@@ -587,6 +587,11 @@ func TestEncodeContainingArrayInvertedIndexSpans(t *testing.T) {
 		if typ.ArrayContents().Family() == types.JsonpathFamily {
 			continue
 		}
+		// TODO(paulniziolek): Temporarily skip arrays with LTREEs as they are
+		// currently missing keyside indexing support.
+		if typ.ArrayContents().Family() == types.LTreeFamily {
+			continue
+		}
 
 		// Generate two random arrays and evaluate the result of `left @> right`.
 		left := randgen.RandArray(rng, typ, 0 /* nullChance */)
@@ -729,6 +734,12 @@ func TestEncodeContainedArrayInvertedIndexSpans(t *testing.T) {
 	for i := 0; i < 100; i++ {
 		typ := randgen.RandArrayType(rng)
 
+		// TODO(paulniziolek): Temporarily skip arrays with LTREEs as they are
+		// currently missing keyside indexing support.
+		if typ.ArrayContents().Family() == types.LTreeFamily {
+			continue
+		}
+
 		// Generate two random arrays and evaluate the result of `left <@ right`.
 		left := randgen.RandArray(rng, typ, 0 /* nullChance */)
 		right := randgen.RandArray(rng, typ, 0 /* nullChance */)
@@ -973,6 +984,11 @@ func TestEncodeOverlapsArrayInvertedIndexSpans(t *testing.T) {
 		if typ.ArrayContents().Family() == types.JsonpathFamily {
 			continue
 		}
+		// TODO(paulniziolek): Temporarily skip arrays with LTREEs as they are
+		// currently missing keyside indexing support.
+		if typ.ArrayContents().Family() == types.LTreeFamily {
+			continue
+		}
 
 		// Generate two random arrays and evaluate the result of `left && right`.
 		// Using 1/9th as the Null Chance to generate arrays with a small

pkg/sql/rowenc/valueside/array.go

@@ -241,6 +241,8 @@ func DatumTypeToArrayElementEncodingType(t *types.T) (encoding.Type, error) {
 		return encoding.IPAddr, nil
 	case types.JsonFamily:
 		return encoding.JSON, nil
+	case types.LTreeFamily:
+		return encoding.LTree, nil
 	case types.TupleFamily:
 		return encoding.Tuple, nil
 	case types.ArrayFamily:
@@ -362,6 +364,8 @@ func encodeArrayElement(b []byte, d tree.Datum) ([]byte, error) {
 			return nil, err
 		}
 		return encoding.EncodeUntaggedBytesValue(b, encoded), nil
+	case *tree.DLTree:
+		return encoding.EncodeUntaggedLTreeValue(b, t.LTree), nil
 	default:
 		return nil, errors.Errorf("don't know how to encode %s (%T)", d, d)
 	}

pkg/sql/rowenc/valueside/decode.go

@@ -244,6 +244,9 @@ func DecodeUntaggedDatum(
 		// the loss of variable length encoding.
 		b, data, err := encoding.DecodeUntaggedIntValue(buf)
 		return a.NewDOid(tree.MakeDOid(oid.Oid(data), t)), b, err
+	case types.LTreeFamily:
+		b, l, err := encoding.DecodeUntaggedLTreeValue(buf)
+		return tree.NewDLTree(l), b, err
 	case types.ArrayFamily:
 		// Skip the encoded data length.
 		b, _, _, err := encoding.DecodeNonsortingUvarint(buf)

pkg/sql/rowenc/valueside/encode.go

@@ -125,6 +125,8 @@ func EncodeWithScratch(
 		return encoding.EncodeBytesValue(appendTo, uint32(colID), t.UnsafeContentBytes()), scratch, nil
 	case *tree.DOid:
 		return encoding.EncodeIntValue(appendTo, uint32(colID), int64(t.Oid)), scratch, nil
+	case *tree.DLTree:
+		return encoding.EncodeLTreeValue(appendTo, uint32(colID), t.LTree), scratch, nil
 	case *tree.DEnum:
 		return encoding.EncodeBytesValue(appendTo, uint32(colID), t.PhysicalRep), scratch, nil
 	case *tree.DVoid:

pkg/sql/rowenc/valueside/legacy.go

@@ -13,6 +13,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/sql/pgrepl/lsn"
 	"github.com/cockroachdb/cockroach/pkg/sql/sem/tree"
 	"github.com/cockroachdb/cockroach/pkg/sql/types"
+	"github.com/cockroachdb/cockroach/pkg/util/encoding"
 	"github.com/cockroachdb/cockroach/pkg/util/ipaddr"
 	"github.com/cockroachdb/cockroach/pkg/util/json"
 	"github.com/cockroachdb/cockroach/pkg/util/timeutil/pgdate"
@@ -174,6 +175,12 @@ func MarshalLegacy(colType *types.T, val tree.Datum) (roachpb.Value, error) {
 			r.SetBytes(data)
 			return r, nil
 		}
+	case types.LTreeFamily:
+		if v, ok := val.(*tree.DLTree); ok {
+			data := encoding.EncodeUntaggedLTreeValue(nil, v.LTree)
+			r.SetBytes(data)
+			return r, nil
+		}
 	case types.ArrayFamily:
 		if v, ok := val.(*tree.DArray); ok {
 			if err := checkElementType(v.ParamTyp, colType.ArrayContents()); err != nil {
@@ -389,6 +396,16 @@ func UnmarshalLegacy(a *tree.DatumAlloc, typ *types.T, value roachpb.Value) (tre
 			return nil, err
 		}
 		return a.NewDOid(tree.MakeDOid(oid.Oid(v), typ)), nil
+	case types.LTreeFamily:
+		v, err := value.GetBytes()
+		if err != nil {
+			return nil, err
+		}
+		_, l, err := encoding.DecodeUntaggedLTreeValue(v)
+		if err != nil {
+			return nil, err
+		}
+		return tree.NewDLTree(l), nil
 	case types.ArrayFamily:
 		v, err := value.GetBytes()
 		if err != nil {

pkg/util/encoding/BUILD.bazel

@@ -18,6 +18,7 @@ go_library(
         "//pkg/util/duration",
         "//pkg/util/encoding/encodingtype",
         "//pkg/util/ipaddr",
+        "//pkg/util/ltree",
         "//pkg/util/protoutil",
         "//pkg/util/timeofday",
         "//pkg/util/timetz",

pkg/util/encoding/encoding.go

@@ -25,6 +25,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/util/duration"
 	"github.com/cockroachdb/cockroach/pkg/util/encoding/encodingtype"
 	"github.com/cockroachdb/cockroach/pkg/util/ipaddr"
+	"github.com/cockroachdb/cockroach/pkg/util/ltree"
 	"github.com/cockroachdb/cockroach/pkg/util/protoutil"
 	"github.com/cockroachdb/cockroach/pkg/util/timeofday"
 	"github.com/cockroachdb/cockroach/pkg/util/timetz"
@@ -1786,6 +1787,7 @@ const (
 	JsonEmptyArray     Type = 42
 	JsonEmptyArrayDesc Type = 43
 	PGVector           Type = 44
+	LTree              Type = 45
 )
 
 // typMap maps an encoded type byte to a decoded Type. It's got 256 slots, one
@@ -2840,6 +2842,22 @@ func EncodePGVectorValue(appendTo []byte, colIDDelta uint32, data []byte) []byte
 	return EncodeUntaggedBytesValue(appendTo, data)
 }
 
+// EncodeLTreeValue encodes a ltree.T value with its value tag, appends it to
+// the supplied buffer, and returns the final buffer.
+func EncodeLTreeValue(appendTo []byte, colIDDelta uint32, l ltree.T) []byte {
+	appendTo = EncodeValueTag(appendTo, colIDDelta, LTree)
+	return EncodeUntaggedLTreeValue(appendTo, l)
+}
+
+// EncodeUntaggedLTreeValue encodes a ltree.T value, appends it to the supplied
+// buffer, and returns the final buffer.
+func EncodeUntaggedLTreeValue(appendTo []byte, l ltree.T) []byte {
+	var buf bytes.Buffer
+	l.FormatToBuffer(&buf)
+	appendTo = EncodeUntaggedBytesValue(appendTo, buf.Bytes())
+	return appendTo
+}
+
 // DecodeValueTag decodes a value encoded by EncodeValueTag, used as a prefix in
 // each of the other EncodeFooValue methods.
 //
@@ -3189,6 +3207,28 @@ func DecodeUntaggedIPAddrValue(b []byte) (remaining []byte, u ipaddr.IPAddr, err
 	return remaining, u, err
 }
 
+// DecodeLTreeValue decodes a value encoded by EncodeLTreeValue.
+func DecodeLTreeValue(b []byte) (remaining []byte, l ltree.T, err error) {
+	b, err = decodeValueTypeAssert(b, LTree)
+	if err != nil {
+		return b, l, err
+	}
+	return DecodeUntaggedLTreeValue(b)
+}
+
+// DecodeUntaggedLTreeValue decodes a value encoded by EncodeUntaggedLTreeValue.
+func DecodeUntaggedLTreeValue(b []byte) (remaining []byte, l ltree.T, err error) {
+	remaining, data, err := DecodeUntaggedBytesValue(b)
+	if err != nil {
+		return b, l, err
+	}
+	l, err = ltree.ParseLTree(string(data))
+	if err != nil {
+		return b, l, err
+	}
+	return remaining, l, nil
+}
+
 func decodeValueTypeAssert(b []byte, expected Type) ([]byte, error) {
 	_, dataOffset, _, typ, err := DecodeValueTag(b)
 	if err != nil {
@@ -3243,7 +3283,7 @@ func PeekValueLengthWithOffsetsAndType(b []byte, dataOffset int, typ Type) (leng
 		return dataOffset + n, err
 	case Float:
 		return dataOffset + floatValueEncodedLength, nil
-	case Bytes, Array, JSON, Geo, TSVector, TSQuery, PGVector:
+	case Bytes, Array, JSON, Geo, TSVector, TSQuery, PGVector, LTree:
 		_, n, i, err := DecodeNonsortingUvarint(b)
 		return dataOffset + n + int(i), err
 	case Box2D: