Merge #151226

151226: jsonpath: fix empty array comparison behavior in lax mode r=petermattis a=petermattis

Fix handling of empty arrays in JSONPath lax mode comparisons. Empty arrays
should return false for comparisons in lax mode and null in strict mode,
matching PostgreSQL behavior.

Changes:
- Updated eval.go to return empty slice instead of nil for empty arrays
- Modified operation.go to distinguish between nil (path not found) and
  empty slice (empty array) in comparison operations
- Added comprehensive test cases for empty array comparisons

Fixes #145099

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Co-authored-by: Peter Mattis <[email protected]>

Author: craig[bot]

pkg/sql/logictest/testdata/logic_test/jsonb_path_query

@@ -947,11 +947,141 @@ SELECT jsonb_path_query('{"a": [1, 2], "b": "hello"}', '$.a ? ($.b == "hello") '
 1
 2
 
+# Test empty array comparisons in lax mode (should return false) - Issue #145099
+query T
+SELECT jsonb_path_query('{"a": [1], "b": []}', '$.a == $.b')
+----
+false
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": []}', '$.a == $.b')
+----
+false
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": {}}', '$.a == $.b')
+----
+false
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": {"c": 1}}', '$.a == $.b')
+----
+false
+
+# Test empty array comparisons with different operators in lax mode
+query T
+SELECT jsonb_path_query('{"a": [], "b": []}', '$.a != $.b')
+----
+false
+
+query T
+SELECT jsonb_path_query('{"a": [1], "b": []}', '$.a != $.b')
+----
+false
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": [1]}', '$.a < $.b')
+----
+false
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": [1]}', '$.a <= $.b')
+----
+false
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": [1]}', '$.a > $.b')
+----
+false
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": [1]}', '$.a >= $.b')
+----
+false
+
+# Test empty array comparisons in strict mode (should return null)
+query T
+SELECT jsonb_path_query('{"a": [1], "b": []}', 'strict $.a == $.b')
+----
+null
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": []}', 'strict $.a == $.b')
+----
+null
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": {}}', 'strict $.a == $.b')
+----
+null
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": {"c": 1}}', 'strict $.a == $.b')
+----
+null
+
+# Test mixed empty/non-empty arrays
+query T
+SELECT jsonb_path_query('{"a": [1, 2], "b": []}', '$.a == $.b')
+----
+false
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": [1, 2]}', '$.a == $.b')
+----
+false
+
+# Test empty array vs specific value types
+query T
+SELECT jsonb_path_query('{"a": [], "b": [null]}', '$.a == $.b')
+----
+false
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": [0]}', '$.a == $.b')
+----
+false
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": [false]}', '$.a == $.b')
+----
+false
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": [""]}', '$.a == $.b')
+----
+false
+
+# Regression tests - ensure existing behavior is preserved
+query T
+SELECT jsonb_path_query('{"a": [1], "b": [1]}', '$.a == $.b')
+----
+true
+
+query T
+SELECT jsonb_path_query('{"a": [1], "b": [2]}', '$.a == $.b')
+----
+false
+
+query T
+SELECT jsonb_path_query('{"a": "test", "b": "test"}', '$.a == $.b')
+----
+true
+
 query T
 SELECT jsonb_path_query('{"a": [1, 2], "b": "hello"}', 'strict $.a ? ($.b == "hello") ');
 ----
 [1, 2]
 
+# Test logical operators with empty arrays
+query T
+SELECT jsonb_path_query('{"a": [], "b": []}', '$ ? ($.a == $.b || $.a != $.b)')
+----
+
+query T
+SELECT jsonb_path_query('{"a": [], "b": []}', '$ ? ($.a == $.b && $.a != $.b)')
+----
+
 query T rowsort
 SELECT jsonb_path_query('{"a": "world", "b": 2, "c": true}', '$.*');
 ----

pkg/util/jsonpath/eval/eval.go

@@ -144,6 +144,23 @@ func jsonpathQuery(
 	return ctx.eval(expr.Path, ctx.root, !ctx.strict /* unwrap */)
 }
 
+// eval evaluates a JSONPath expression against a JSON value and returns a
+// slice of results.
+//
+// Return value semantics are critical for proper JSONPath behavior:
+//   - nil slice: Path evaluation failed or path does not exist (e.g., $.nonexistent)
+//     In comparisons: returns unknown/null in strict mode, false in lax mode
+//   - Empty slice ([]json.JSON{}): Path exists but contains no items (e.g., empty array [])
+//     In comparisons: returns false in lax mode (no items to compare).
+//   - Non-empty slice: Path found one or more matching items.
+//
+// This distinction is essential for JSONPath comparison operations to match
+// PostgreSQL behavior.
+//
+// Many of jsonpath operations require automatic unwrapping of arrays in lax
+// mode. If the input value is an array the operation is performed not on the
+// array itself, but on all of its members one by one. The unwrap parameter
+// indicates whether array unwrapping is needed.
 func (ctx *jsonpathCtx) eval(
 	jsonPath jsonpath.Path, jsonValue json.JSON, unwrap bool,
 ) ([]json.JSON, error) {
@@ -219,7 +236,8 @@ func (ctx *jsonpathCtx) executeAnyItem(
 	jsonPath jsonpath.Path, jsonValue json.JSON, unwrapNext bool,
 ) ([]json.JSON, error) {
 	if jsonValue.Len() == 0 {
-		return nil, nil
+		// Return empty slice (not nil) to indicate "empty array found" vs "path not found".
+		return []json.JSON{}, nil
 	}
 	var agg []json.JSON
 	processItem := func(item json.JSON) error {
@@ -272,6 +290,11 @@ func (ctx *jsonpathCtx) evalAndUnwrapResult(
 		return nil, err
 	}
 	if unwrap && !ctx.strict {
+		// If evalResults is nil, preserve nil to indicate path evaluation
+		// failure.
+		if evalResults == nil {
+			return nil, nil
+		}
 		var agg []json.JSON
 		for _, j := range evalResults {
 			if j.Type() == json.ArrayJSONType {
@@ -285,6 +308,12 @@ func (ctx *jsonpathCtx) evalAndUnwrapResult(
 				agg = append(agg, j)
 			}
 		}
+		// If agg is nil, return an empty slice to distinguish empty arrays
+		// from missing paths. Note that agg can be nil even if evalResults is
+		// non-nil if unwrapping an argument produces an empty array.
+		if agg == nil {
+			return []json.JSON{}, nil
+		}
 		return agg, nil
 	}
 	return evalResults, nil

pkg/util/jsonpath/eval/operation.go

@@ -290,6 +290,16 @@ func (ctx *jsonpathCtx) evalPredicate(
 		right = append(right, nil)
 	}
 
+	// In lax mode, if either operand is empty (empty array unwrapped),
+	// no items to compare means no matches found -> false
+	// Note: For OpLikeRegex, evalRight is false and right contains [nil], so we only check left
+	if !ctx.strict && len(left) == 0 {
+		return jsonpathBoolFalse, nil
+	}
+	if !ctx.strict && evalRight && len(right) == 0 {
+		return jsonpathBoolFalse, nil
+	}
+
 	errored := false
 	found := false
 	for _, l := range left {