Fix precendence bug in S3Select SQL IN clauses (#18708)

Fixes a precendence issue in SQL Select where `a in b and c = 3` was parsed as `a
in (b and c = 3)`.

Fixes #18682

internal/s3select/select_test.go

@@ -109,6 +109,21 @@ func TestJSONQueries(t *testing.T) {
 			query:      `SELECT * from s3object s WHERE 'bar' in s.synonyms[*]`,
 			wantResult: `{"id":0,"title":"Test Record","desc":"Some text","synonyms":["foo","bar","whatever"]}`,
 		},
+		{
+			name:       "in-expression-precedence-1",
+			query:      "select * from s3object s where 'bar' in s.synonyms and s.id = 0",
+			wantResult: `{"id":0,"title":"Test Record","desc":"Some text","synonyms":["foo","bar","whatever"]}`,
+		},
+		{
+			name:       "in-expression-precedence-2",
+			query:      "select * from s3object s where 'some' in ('somex', s.synonyms[0]) and s.id = 1",
+			wantResult: `{"id":1,"title":"Second Record","desc":"another text","synonyms":["some","synonym","value"]}`,
+		},
+		{
+			name:       "in-expression-with-aggregation",
+			query:      "select SUM(s.id) from s3object s Where 2 in s.numbers[*] or 'some' in s.synonyms[*]",
+			wantResult: `{"_1":3}`,
+		},
 		{
 			name:  "bignum-1",
 			query: `SELECT id from s3object s WHERE s.id <= 9223372036854775807`,

internal/s3select/sql/aggregation.go

@@ -211,10 +211,8 @@ func (e *ConditionOperand) aggregateRow(r Record, tableAlias string) error {
 		}
 		return e.ConditionRHS.Between.End.aggregateRow(r, tableAlias)
 	case e.ConditionRHS.In != nil:
-		elt := e.ConditionRHS.In.ListExpression
+		if e.ConditionRHS.In.ListExpr != nil {
-		err = elt.aggregateRow(r, tableAlias)
+			return e.ConditionRHS.In.ListExpr.aggregateRow(r, tableAlias)
-		if err != nil {
-			return err
 		}
 		return nil
 	case e.ConditionRHS.Like != nil:

internal/s3select/sql/analysis.go

@@ -134,7 +134,7 @@ func (e *ConditionRHS) analyze(s *Select) (result qProp) {
 		result.combine(e.Between.Start.analyze(s))
 		result.combine(e.Between.End.analyze(s))
 	case e.In != nil:
-		result.combine(e.In.ListExpression.analyze(s))
+		result.combine(e.In.analyze(s))
 	case e.Like != nil:
 		result.combine(e.Like.Pattern.analyze(s))
 		if e.Like.EscapeChar != nil {
@@ -146,6 +146,25 @@ func (e *ConditionRHS) analyze(s *Select) (result qProp) {
 	return
 }
 
+func (e *In) analyze(s *Select) (result qProp) {
+	switch {
+	case e.JPathExpr != nil:
+		// Check if the path expression is valid
+		if len(e.JPathExpr.PathExpr) > 0 {
+			if e.JPathExpr.BaseKey.String() != s.From.As && !strings.EqualFold(e.JPathExpr.BaseKey.String(), baseTableName) {
+				result = qProp{err: errInvalidKeypath}
+				return
+			}
+		}
+		result = qProp{isRowFunc: true}
+	case e.ListExpr != nil:
+		result = e.ListExpr.analyze(s)
+	default:
+		result = qProp{err: errUnexpectedInvalidNode}
+	}
+	return
+}
+
 func (e *Operand) analyze(s *Select) (result qProp) {
 	result.combine(e.Left.analyze(s))
 	for _, r := range e.Right {

internal/s3select/sql/evaluate.go

@@ -289,13 +289,23 @@ func (e *In) evalInNode(r Record, lhs *Value, tableAlias string) (*Value, error)
 	}
 
 	var rhs Value
-	if elt := e.ListExpression; elt != nil {
+	var err error
-		eltVal, err := elt.evalNode(r, tableAlias)
+	var eltVal *Value
+	switch {
+	case e.JPathExpr != nil:
+		eltVal, err = e.JPathExpr.evalNode(r, tableAlias)
 		if err != nil {
 			return nil, err
 		}
-		rhs = *eltVal
+	case e.ListExpr != nil:
+		eltVal, err = e.ListExpr.evalNode(r, tableAlias)
+		if err != nil {
+			return nil, err
+		}
+	default:
+		return nil, errInvalidASTNode
 	}
+	rhs = *eltVal
 
 	// If RHS is array compare each element.
 	if arr, ok := rhs.ToArray(); ok {

internal/s3select/sql/parser.go

@@ -166,8 +166,7 @@ type Condition struct {
 	Not     *Condition        `parser:"| \"NOT\" @@"`
 }
 
-// ConditionOperand is a operand followed by an an optional operation
+// ConditionOperand is a operand followed by an optional operation expression.
-// expression
 type ConditionOperand struct {
 	Operand      *Operand      `parser:"@@"`
 	ConditionRHS *ConditionRHS `parser:"@@?"`
@@ -202,9 +201,13 @@ type Between struct {
 	End   *Operand `parser:" \"AND\" @@ "`
 }
 
-// In represents the RHS of an IN expression
+// In represents the RHS of an IN expression. The RHS can be a list-literal
+// (i.e. enclosed in parantheses like `IN (1,2,4)`) or it could be a JSON path
+// expression (as in `8.5 IN s.nested[*][*]`). Specifically, it cannot be an
+// `Expression` as an expression can never evaluate to a list.
 type In struct {
-	ListExpression *Expression `parser:"@@ "`
+	JPathExpr *JSONPath `parser:"@@"`
+	ListExpr  *ListExpr `parser:"| @@"`
 }
 
 // Grammar for Operand: