jsonpath: update error handling for undefined variable errors

This commit updates error handling logic for undefined variable errors
within JSONPath queries. Instead of silencing all errors into
jsonpathBoolUnknown in evalPredicate, we explicitly check if it's the
variable not found error. Additionally, this commit also allows for
assertion failures to be not silenced when passed to evalPredicate.

Release note: None

Author: normanchenn

pkg/sql/logictest/testdata/logic_test/jsonb_path_query

@@ -1600,3 +1600,43 @@ query T
 SELECT jsonb_path_query('[1, 2, 3]', '$[-0.99999999]');
 ----
 1
+
+statement error pgcode 42704 pq: could not find jsonpath variable "value"
+SELECT jsonb_path_query('{"a": 10}', '$ ? (@.a < $value)');
+
+statement error pgcode 42704 pq: could not find jsonpath variable "value"
+SELECT jsonb_path_query('{"a": 10}', '$ ? (@.a < $value)', '{}');
+
+statement error pgcode 42704 pq: could not find jsonpath variable "value"
+SELECT jsonb_path_query('{"a": 10}', '$ ? (@.a < $value)', '{"other": 10}');
+
+query T
+SELECT jsonb_path_query('{"a": 10}', '$ ? (@.a < $value)', '{"value": 11}');
+----
+{"a": 10}
+
+statement error pgcode 42704 pq: could not find jsonpath variable "value"
+SELECT jsonb_path_query('{"a": 10, "b": 20}', '$ ? (@.a < $value && @.b > $value)');
+
+statement error pgcode 42704 pq: could not find jsonpath variable "min"
+SELECT jsonb_path_query('{"a": 10, "b": 20}', '$ ? (@.a < $min && @.b > $max)');
+
+statement error pgcode 42704 pq: could not find jsonpath variable "value"
+SELECT jsonb_path_query('{"a": 10}', 'strict $ ? (@.a < $value)', '{}', true);
+
+statement error pgcode 42704 pq: could not find jsonpath variable "value"
+SELECT jsonb_path_query('{"a": 10}', 'strict $ ? (@.a < $value)', '{}', false);
+
+statement error pgcode 42704 pq: could not find jsonpath variable "value"
+SELECT jsonb_path_query('{"a": 10}', '$ ? (@.a < $value)', '{}', true);
+
+statement error pgcode 42704 pq: could not find jsonpath variable "value"
+SELECT jsonb_path_query('{"a": 10}', '$ ? (@.a < $value)', '{}', false);
+
+statement error pgcode 42704 pq: could not find jsonpath variable "d"
+SELECT jsonb_path_query('{}', '$ ? ($d < $a && @.c > $b)');
+
+query T
+SELECT jsonb_path_query('{"a": 10}', '$ ? ((@.a < 12) || (@.a < $value))');
+----
+{"a": 10}

pkg/util/jsonpath/eval/filter.go

@@ -24,11 +24,8 @@ func (ctx *jsonpathCtx) evalFilter(
 	}
 	b, err := ctx.evalBoolean(op, jsonValue)
 	if err != nil {
-		// Postgres doesn't error when there's a structure error within filter
-		// conditions, and will return nothing instead.
-		return nil, nil //nolint:returnerrcheck
+		return nil, err
 	}
-
 	if b == jsonpathBoolTrue {
 		return []json.JSON{jsonValue}, nil
 	}

pkg/util/jsonpath/eval/operation.go

@@ -129,7 +129,7 @@ func (ctx *jsonpathCtx) evalIsUnknown(
 	}
 	leftBool, err := ctx.evalBoolean(leftOp, jsonValue)
 	if err != nil {
-		return jsonpathBoolUnknown, errors.AssertionFailedf("left is not a boolean")
+		return jsonpathBoolUnknown, err
 	}
 	if leftBool == jsonpathBoolUnknown {
 		return jsonpathBoolTrue, nil
@@ -204,7 +204,7 @@ func (ctx *jsonpathCtx) evalLogical(
 	}
 	leftBool, err := ctx.evalBoolean(leftOp, jsonValue)
 	if err != nil {
-		return jsonpathBoolUnknown, errors.AssertionFailedf("left is not a boolean")
+		return jsonpathBoolUnknown, err
 	}
 	switch op.Type {
 	case jsonpath.OpLogicalAnd:
@@ -233,7 +233,7 @@ func (ctx *jsonpathCtx) evalLogical(
 	}
 	rightBool, err := ctx.evalBoolean(rightOp, jsonValue)
 	if err != nil {
-		return jsonpathBoolUnknown, errors.AssertionFailedf("right is not a boolean")
+		return jsonpathBoolUnknown, err
 	}
 	switch op.Type {
 	case jsonpath.OpLogicalAnd:
@@ -251,6 +251,10 @@ func (ctx *jsonpathCtx) evalLogical(
 	}
 }
 
+func isIgnorableError(err error) bool {
+	return err == nil || (!errors.HasAssertionFailure(err) && !errors.Is(err, &errVariableNotFound{}))
+}
+
 // evalPredicate evaluates a predicate operation. Predicates have existence
 // semantics. True is returned if any pair of items from the left and right
 // paths satisfy the condition. In strict mode, even if a pair has been found,
@@ -263,13 +267,19 @@ func (ctx *jsonpathCtx) evalPredicate(
 ) (jsonpathBool, error) {
 	// The left argument results are always auto-unwrapped.
 	left, err := ctx.evalAndUnwrapResult(op.Left, jsonValue, true /* unwrap */)
+	if !isIgnorableError(err) {
+		return jsonpathBoolUnknown, err
+	}
 	if err != nil || left == nil {
 		return jsonpathBoolUnknown, nil //nolint:returnerrcheck
 	}
 	var right []json.JSON
 	if evalRight {
 		// The right argument results are conditionally evaluated and unwrapped.
 		right, err = ctx.evalAndUnwrapResult(op.Right, jsonValue, unwrapRight)
+		if !isIgnorableError(err) {
+			return jsonpathBoolUnknown, err
+		}
 		if err != nil || right == nil {
 			return jsonpathBoolUnknown, nil //nolint:returnerrcheck
 		}

pkg/util/jsonpath/eval/scalar.go

@@ -10,16 +10,25 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgerror"
 	"github.com/cockroachdb/cockroach/pkg/util/json"
 	"github.com/cockroachdb/cockroach/pkg/util/jsonpath"
+	"github.com/cockroachdb/errors"
 )
 
+type errVariableNotFound struct{}
+
+func (e *errVariableNotFound) Error() string {
+	return ""
+}
+
 func (ctx *jsonpathCtx) resolveScalar(scalar jsonpath.Scalar) (json.JSON, error) {
 	if scalar.Type == jsonpath.ScalarVariable {
 		val, err := ctx.vars.FetchValKey(scalar.Variable)
 		if err != nil {
 			return nil, err
 		}
 		if val == nil {
-			return nil, pgerror.Newf(pgcode.UndefinedObject, "could not find jsonpath variable %q", scalar.Variable)
+			return nil, errors.Mark(pgerror.Newf(pgcode.UndefinedObject,
+				"could not find jsonpath variable %q", scalar.Variable),
+				&errVariableNotFound{})
 		}
 		return val, nil
 	}