jsonpath: add support for starts with

This commit adds support for using `starts with` within jsonpath
queries. This returns a boolean - whether or not the string or
variable following the `starts with` directive is the prefix of
the current json string.

Epic: None
Release note (sql change): Add support for `starts with ""` in JSONPath
queries. For example, `SELECT jsonb_path_query('"abcdef"', '$
starts with "abc"');`.

Author: normanchenn

pkg/sql/logictest/testdata/logic_test/jsonb_path_query

@@ -1099,3 +1099,58 @@ query T
 SELECT jsonb_path_query('{}', '(null like_regex "^he.*$") is unknown');
 ----
 true
+
+query T
+SELECT jsonb_path_query('"abcdef"', '$ starts with "abc"');
+----
+true
+
+query T
+SELECT jsonb_path_query('"abc"', '$ starts with "abc"');
+----
+true
+
+query T
+SELECT jsonb_path_query('"ab"', '$ starts with "abc"');
+----
+false
+
+query T
+SELECT jsonb_path_query('"abcdef"', '$ starts with $var', '{"var": "abc"}');
+----
+true
+
+query T
+SELECT jsonb_path_query('"abc"', '$ starts with $var', '{"var": "abc"}');
+----
+true
+
+query T
+SELECT jsonb_path_query('"ab"', '$ starts with $var', '{"var": "abc"}');
+----
+false
+
+query T
+SELECT jsonb_path_query('["ab", "abc"]', '$ starts with $var', '{"var": "abc"}');
+----
+true
+
+query T
+SELECT jsonb_path_query('["ab", "a"]', '$ starts with $var', '{"var": "abc"}');
+----
+false
+
+query T
+SELECT jsonb_path_query('["ab", "abc"]', 'strict $ starts with $var', '{"var": "abc"}');
+----
+null
+
+query T
+SELECT jsonb_path_query('["ab", "abc"]', 'strict $ starts with $var', '{"var": 1}');
+----
+null
+
+query T
+SELECT jsonb_path_query('["ab", 1]', 'strict $ starts with $var', '{"var": "abc"}');
+----
+null

pkg/util/jsonpath/eval/operation.go

@@ -6,6 +6,8 @@
 package eval
 
 import (
+	"strings"
+
 	"github.com/cockroachdb/apd/v3"
 	"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgcode"
 	"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgerror"
@@ -53,7 +55,8 @@ func (ctx *jsonpathCtx) evalOperation(
 	case jsonpath.OpLogicalAnd, jsonpath.OpLogicalOr, jsonpath.OpLogicalNot,
 		jsonpath.OpCompEqual, jsonpath.OpCompNotEqual, jsonpath.OpCompLess,
 		jsonpath.OpCompLessEqual, jsonpath.OpCompGreater, jsonpath.OpCompGreaterEqual,
-		jsonpath.OpLikeRegex, jsonpath.OpExists, jsonpath.OpIsUnknown:
+		jsonpath.OpLikeRegex, jsonpath.OpExists, jsonpath.OpIsUnknown,
+		jsonpath.OpStartsWith:
 		b, err := ctx.evalBoolean(op, jsonValue)
 		if err != nil {
 			return []json.JSON{convertFromBool(jsonpathBoolUnknown)}, err
@@ -89,11 +92,31 @@ func (ctx *jsonpathCtx) evalBoolean(
 		return ctx.evalExists(op, jsonValue)
 	case jsonpath.OpIsUnknown:
 		return ctx.evalIsUnknown(op, jsonValue)
+	case jsonpath.OpStartsWith:
+		return ctx.evalPredicate(op, jsonValue, evalStartsWithFunc, true /* evalRight */, false /* unwrapRight */)
 	default:
 		panic(errors.AssertionFailedf("unhandled operation type"))
 	}
 }
 
+func evalStartsWithFunc(_ jsonpath.Operation, l, r json.JSON) (jsonpathBool, error) {
+	if l.Type() != json.StringJSONType || r.Type() != json.StringJSONType {
+		return jsonpathBoolUnknown, nil
+	}
+	left, err := l.AsText()
+	if err != nil {
+		return jsonpathBoolUnknown, err
+	}
+	right, err := r.AsText()
+	if err != nil {
+		return jsonpathBoolUnknown, err
+	}
+	if strings.HasPrefix(*left, *right) {
+		return jsonpathBoolTrue, nil
+	}
+	return jsonpathBoolFalse, nil
+}
+
 func (ctx *jsonpathCtx) evalIsUnknown(
 	op jsonpath.Operation, jsonValue json.JSON,
 ) (jsonpathBool, error) {

pkg/util/jsonpath/operation.go

@@ -29,6 +29,7 @@ const (
 	OpMinus
 	OpExists
 	OpIsUnknown
+	OpStartsWith
 )
 
 var OperationTypeStrings = map[OperationType]string{
@@ -51,6 +52,7 @@ var OperationTypeStrings = map[OperationType]string{
 	OpMinus:            "-",
 	OpExists:           "exists",
 	OpIsUnknown:        "is unknown",
+	OpStartsWith:       "starts with",
 }
 
 type Operation struct {

pkg/util/jsonpath/parser/jsonpath.y

@@ -193,6 +193,8 @@ func regexBinaryOp(left jsonpath.Path, regex string) (jsonpath.Operation, error)
 %token <str> EXISTS
 %token <str> IS
 %token <str> UNKNOWN
+%token <str> STARTS
+%token <str> WITH
 
 %type <jsonpath.Jsonpath> jsonpath
 %type <jsonpath.Path> expr_or_predicate
@@ -205,6 +207,7 @@ func regexBinaryOp(left jsonpath.Path, regex string) (jsonpath.Operation, error)
 %type <jsonpath.Path> index_elem
 %type <jsonpath.Path> predicate
 %type <jsonpath.Path> delimited_predicate
+%type <jsonpath.Path> starts_with_initial
 %type <[]jsonpath.Path> accessor_expr
 %type <[]jsonpath.Path> index_list
 %type <jsonpath.OperationType> comp_op
@@ -420,6 +423,10 @@ predicate:
   {
     $$.val = unaryOp(jsonpath.OpIsUnknown, $2.path())
   }
+| expr STARTS WITH starts_with_initial
+  {
+    $$.val = binaryOp(jsonpath.OpStartsWith, $1.path(), $4.path())
+  }
 | expr LIKE_REGEX STRING
   {
     regex, err := regexBinaryOp($1.path(), $3)
@@ -446,6 +453,17 @@ delimited_predicate:
   }
 ;
 
+starts_with_initial:
+  STRING
+  {
+    $$.val = jsonpath.Scalar{Type: jsonpath.ScalarString, Value: json.FromString($1)}
+  }
+| VARIABLE
+  {
+    $$.val = jsonpath.Scalar{Type: jsonpath.ScalarVariable, Variable: $1}
+  }
+;
+
 comp_op:
   EQUAL
   {
@@ -531,10 +549,12 @@ unreserved_keyword:
 | LAX
 | LIKE_REGEX
 | NULL
+| STARTS
 | STRICT
 | TO
 | TRUE
 | UNKNOWN
+| WITH
 ;
 
 %%

pkg/util/jsonpath/parser/testdata/jsonpath

@@ -544,6 +544,21 @@ parse
 ----
 ((null like_regex "^he.*$")) is unknown -- normalized!
 
+parse
+$ starts with "abc"
+----
+($ starts with "abc") -- normalized!
+
+parse
+$.a ? (@.b starts with "def")
+----
+$."a"?((@."b" starts with "def")) -- normalized!
+
+parse
+$.a starts with $var
+----
+($."a" starts with $"var") -- normalized!
+
 # postgres allows floats as array indexes
 # parse
 # $.abc[1.0]