fix: correct NOT token handling with look-ahead parsing

Address NOT token handling issue (same fix as PR #117).

Changes:
- Add peekToken() helper for look-ahead without advancing position
- Fix parseComparisonExpression() to only consume NOT when followed by
  BETWEEN, LIKE, ILIKE, or IN operators
- Update NOT case in parsePrimaryExpression() to use UnaryExpression
  with parseComparisonExpression for proper precedence

This properly handles all NOT use cases:
- NOT LIKE: WHERE name NOT LIKE '%Admin%'
- NOT BETWEEN: WHERE price NOT BETWEEN 10 AND 100
- NOT IN: WHERE status NOT IN ('cancelled', 'deleted')
- Boolean negation: WHERE NOT active AND name LIKE '%'
- NOT EXISTS: WHERE NOT EXISTS (SELECT ...)

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

Co-Authored-By: Claude <noreply@anthropic.com>

Author: 2 people

pkg/sql/parser/parser.go

@@ -238,6 +238,16 @@ func (p *Parser) advance() {
 	}
 }
 
+// peekToken returns the next token without advancing the parser position.
+// Returns an empty token if at the end of input.
+func (p *Parser) peekToken() token.Token {
+	nextPos := p.currentPos + 1
+	if nextPos < len(p.tokens) {
+		return p.tokens[nextPos]
+	}
+	return token.Token{}
+}
+
 // expectedError returns an error for unexpected token
 func (p *Parser) expectedError(expected string) error {
 	return fmt.Errorf("expected %s, got %s", expected, p.currentToken.Type)
@@ -361,10 +371,15 @@ func (p *Parser) parseComparisonExpression() (ast.Expression, error) {
 	}
 
 	// Check for NOT prefix for BETWEEN, LIKE, IN operators
+	// Only consume NOT if followed by BETWEEN, LIKE, ILIKE, or IN
+	// This prevents breaking cases like: WHERE NOT active AND name LIKE '%'
 	notPrefix := false
 	if p.currentToken.Type == "NOT" {
-		notPrefix = true
-		p.advance()
+		nextToken := p.peekToken()
+		if nextToken.Type == "BETWEEN" || nextToken.Type == "LIKE" || nextToken.Type == "ILIKE" || nextToken.Type == "IN" {
+			notPrefix = true
+			p.advance() // Consume NOT only if followed by valid operator
+		}
 	}
 
 	// Check for BETWEEN operator
@@ -734,16 +749,15 @@ func (p *Parser) parsePrimaryExpression() (ast.Expression, error) {
 			}, nil
 		}
 
-		// NOT followed by other expression
-		expr, err := p.parsePrimaryExpression()
+		// NOT followed by other expression (boolean negation)
+		// Parse at comparison level for proper precedence: NOT (a > b), NOT active
+		expr, err := p.parseComparisonExpression()
 		if err != nil {
 			return nil, err
 		}
-		return &ast.BinaryExpression{
-			Left:     expr,
-			Operator: "NOT",
-			Right:    nil,
-			Not:      true,
+		return &ast.UnaryExpression{
+			Operator: ast.Not,
+			Expr:     expr,
 		}, nil
 
 	default: