fix(where): parenthesized OR/AND evaluate correctly + fail-closed unrecognized predicates (#348)

Root cause: a WHERE wrapped in redundant parentheses, e.g. (col = @p0 OR col = @p1),
was passed to the single-condition evaluator as one condition, so the operator scan
found '=' with a malformed column name '(col' -> no row matched (0 rows). The
single-file OR/AND splitter and the directory token-walker (EvaluateJoinWhere) both
ignored parentheses at depth > 0, and unrecognized conditions fell through to
'return true' (accept ALL rows).

Fixes:
- SqlInPredicate: add shared StripOuterParentheses + SplitTopLevelLogical helpers
  (parenthesis/string-literal aware), used by every WHERE evaluation path.
- SingleFileTable.EvaluateCondition: strip redundant outer parens before OR/AND split;
  use the shared splitter (removed private duplicates); unrecognized single conditions
  now fail closed (return false) instead of accepting every row.
- Table.EvaluateWhere (directory): strip outer parens and split AND/OR recursively
  (parenthesized sub-expressions such as 'a = 1 AND (b = 2 OR c = 3)' now work);
  BETWEEN is excluded from the split (contains 'AND').
- SqlParser.EvaluateJoinWhere: strip outer parens (defensive, covers PageBasedScan).
- DatabaseExtensions.EvaluateSingleCondition: fail closed (dead path, same tautology).

Verified: the reporter's probe expectations for multi-value IN/VALUES/OR were
non-discriminating (both values matched all 3 seeded rows, so 3 rows is CORRECT).
New discriminating regression tests (non-matching values) cover literal/param/VALUES
lists, OR, parenthesized OR and AND+OR in single-file + directory + the EF Core
provider path. 1,630 SharpCoreDB.Tests + 116 EF Core tests green.

Author: MPCoreDeveloper

src/SharpCoreDB/DataStructures/Table.Scanning.cs

@@ -206,15 +206,34 @@ private bool EvaluateWhere(Dictionary<string, object> row, string? where)
     {
         if (string.IsNullOrEmpty(where)) return true;
 
+        // ✅ Issue #348: strip redundant outer parentheses so "(a = 1 OR b = 2)" and
+        // "(a = 1 AND b = 2)" evaluate like their unparenthesized forms (the legacy
+        // split-based evaluator treats a leading "(" as part of the column name).
+        where = SqlInPredicate.StripOuterParentheses(where);
+
         var parts = where.Split(' ', StringSplitOptions.RemoveEmptyEntries);
         if (parts.Length < 3) return true;
 
-        // ✅ FIX: Detect complex WHERE clauses (contains AND/OR) and delegate to SqlParser.EvaluateJoinWhere
-        // which has full support for compound conditions
-        var whereUpper = where.ToUpperInvariant();
-        if (whereUpper.Contains(" AND ") || whereUpper.Contains(" OR "))
+        // ✅ Issue #348: split compound conditions on top-level AND/OR and evaluate each
+        // operand recursively (via the full single-condition evaluator below). The previous
+        // delegation to SqlParser.EvaluateJoinWhere was a space-token walker that could not
+        // handle parenthesized sub-expressions such as "a = 1 AND (b = 2 OR c = 3)".
+        // BETWEEN contains "AND" as part of its syntax, so it is excluded from the split
+        // (same guard as SingleFileTable.EvaluateCondition).
+        bool hasBetween = where.Contains("BETWEEN", StringComparison.OrdinalIgnoreCase);
+        if (!hasBetween)
         {
-            return SqlParser.EvaluateJoinWhere(row, where);
+            var orParts = SqlInPredicate.SplitTopLevelLogical(where, "OR");
+            if (orParts.Count > 1)
+            {
+                return orParts.Any(part => EvaluateWhere(row, part));
+            }
+
+            var andParts = SqlInPredicate.SplitTopLevelLogical(where, "AND");
+            if (andParts.Count > 1)
+            {
+                return andParts.All(part => EvaluateWhere(row, part));
+            }
         }
 
         // ✅ Issue #339/#340: support IN / NOT IN lists for all column types, including

src/SharpCoreDB/DatabaseExtensions.cs

@@ -1473,7 +1473,7 @@ private bool EvaluateSingleCondition(Dictionary<string, object> row, string cond
 
         if (op == null || opIndex < 0)
         {
-            return true;
+            return false;
         }
 
         var columnName = condition.Substring(0, opIndex).Trim();

src/SharpCoreDB/Services/SqlInPredicate.cs

@@ -145,6 +145,148 @@ public static bool IsMatch(Dictionary<string, object> row, ParsedInPredicate par
     public static bool IsMatch(object? rowValue, IEnumerable<string> items)
         => items.Contains(rowValue?.ToString() ?? string.Empty);
 
+    /// <summary>
+    /// Removes redundant outer parentheses from a logical condition so that
+    /// <c>"(a = 1 OR b = 2)"</c> evaluates exactly like <c>"a = 1 OR b = 2"</c>.
+    /// Only parentheses that enclose the WHOLE expression are stripped (e.g.
+    /// <c>"(a = 1) OR (b = 2)"</c> is left intact), and parentheses inside string
+    /// literals are ignored. Used by every WHERE evaluation path so parenthesized
+    /// OR/AND predicates filter correctly (GitHub issue #348).
+    /// </summary>
+    public static string StripOuterParentheses(string condition)
+    {
+        var trimmed = condition.Trim();
+
+        while (trimmed.Length >= 2 && trimmed[0] == '(' && trimmed[^1] == ')')
+        {
+            int depth = 0;
+            bool inString = false;
+            char quote = '\0';
+            bool fullyWrapped = true;
+
+            // Scan up to (but excluding) the final ')' — if the depth returns to 0 before
+            // the end, the outer parens do not wrap the whole expression and must be kept.
+            for (int i = 0; i < trimmed.Length - 1; i++)
+            {
+                char c = trimmed[i];
+
+                if (inString)
+                {
+                    inString = c != quote; // closing quote exits the string literal
+                    continue;
+                }
+
+                if (c is '\'' or '"')
+                {
+                    inString = true;
+                    quote = c;
+                    continue;
+                }
+
+                if (c == '(')
+                {
+                    depth++;
+                }
+                else if (c == ')')
+                {
+                    depth--;
+                    if (depth == 0)
+                    {
+                        fullyWrapped = false;
+                        break;
+                    }
+                }
+            }
+
+            // The scan excludes the final ')' (which balances the outer '('), so a fully
+            // wrapped expression leaves exactly ONE unmatched '(' (depth == 1). If the depth
+            // returns to 0 before the end, the outer parens do not wrap the whole expression
+            // and must be kept.
+            if (!fullyWrapped || depth != 1)
+            {
+                break;
+            }
+
+            trimmed = trimmed[1..^1].Trim();
+        }
+
+        return trimmed;
+    }
+
+    /// <summary>
+    /// Splits a condition on a logical keyword (AND / OR) that appears at the top level only —
+    /// i.e. not inside parentheses or string literals. This keeps <c>IN ('a', 'b')</c> and
+    /// <c>(a = 1 OR b = 2)</c> intact while still splitting <c>col = 1 OR col = 2</c>.
+    /// </summary>
+    public static List<string> SplitTopLevelLogical(string text, string keyword)
+    {
+        var parts = new List<string>();
+        int depth = 0;
+        bool inString = false;
+        char quote = '\0';
+        int start = 0;
+        int i = 0;
+
+        while (i < text.Length)
+        {
+            char c = text[i];
+            if (inString)
+            {
+                inString = c != quote; // closing quote exits the string literal
+                i++;
+                continue;
+            }
+
+            if (c is '\'' or '"')
+            {
+                inString = true;
+                quote = c;
+            }
+            else if (c == '(')
+            {
+                depth++;
+            }
+            else if (c == ')')
+            {
+                depth = Math.Max(0, depth - 1);
+            }
+            else if (IsLogicalKeywordAt(text, i, keyword, depth))
+            {
+                parts.Add(text[start..i].Trim());
+                i += 1 + keyword.Length;
+                while (i < text.Length && char.IsWhiteSpace(text[i]))
+                {
+                    i++;
+                }
+
+                start = i;
+                continue;
+            }
+
+            i++;
+        }
+
+        parts.Add(text[start..].Trim());
+        return parts;
+    }
+
+    /// <summary>
+    /// True when <paramref name="keyword"/> (OR / AND) starts right after a top-level space at
+    /// <paramref name="index"/> and is followed by whitespace, e.g. <c>"col = 1 OR col = 2"</c>.
+    /// </summary>
+    private static bool IsLogicalKeywordAt(string text, int index, string keyword, int depth)
+    {
+        if (depth != 0 || text[index] is not (' ' or '\t'))
+        {
+            return false;
+        }
+
+        var after = index + 1 + keyword.Length;
+        return after < text.Length
+            && text.AsSpan(index + 1, keyword.Length).Equals(keyword.AsSpan(), StringComparison.OrdinalIgnoreCase)
+            && char.IsWhiteSpace(text[after]);
+    }
+
     /// <summary>
     /// Evaluates a raw IN value list (e.g. <c>('a', 'b')</c>, <c>(1,2,3)</c> or
     /// <c>(VALUES ('a'), ('b'))</c>) against a single row value. Commas inside parentheses

src/SharpCoreDB/Services/SqlParser.Helpers.cs

@@ -300,6 +300,10 @@ public static bool EvaluateJoinWhere(Dictionary<string, object> row, string wher
             return true;
         }
 
+        // ✅ Issue #348: strip redundant outer parentheses so "(a = 1 OR b = 2)" evaluates
+        // like "a = 1 OR b = 2" (a leading "(" would otherwise stick to the column name).
+        where = SqlInPredicate.StripOuterParentheses(where);
+
         var parts = where.Split(' ');
         if (parts.Length <= 3)
         {

src/SharpCoreDB/SingleFileTable.cs

@@ -1125,6 +1125,10 @@ private static string NormalizeColumnName(string columnName)
     {
         var trimmed = condition.Trim();
 
+        // ✅ Issue #348: strip redundant outer parentheses so "(a = 1)" is parsed with the
+        // bare column name ("a") instead of a malformed one ("(a").
+        trimmed = SqlInPredicate.StripOuterParentheses(trimmed);
+
         // Conservative eligibility: reject any condition that the full evaluator handles
         // with dedicated syntax (AND/OR chains, IN lists, LIKE, BETWEEN, IS [NOT] NULL).
         // Rejecting is always safe — the fallback preserves existing behavior.
@@ -1253,21 +1257,26 @@ private static bool EvaluateCondition(Dictionary<string, object> row, string con
     {
         var trimmedCondition = condition.Trim();
 
+        // ✅ Issue #348: strip redundant outer parentheses so "(a = 1 OR b = 2)" is split on
+        // OR like the unparenthesized form instead of being treated as one condition with a
+        // malformed column name ("(a").
+        trimmedCondition = SqlInPredicate.StripOuterParentheses(trimmedCondition);
+
         // ✅ Parity: BETWEEN contains " AND " as part of its syntax; don't split on it.
         if (trimmedCondition.Contains("BETWEEN", StringComparison.OrdinalIgnoreCase))
         {
             return EvaluateSingleCondition(row, trimmedCondition);
         }
 
-        // ✅ Issue #340: handle OR chains (e.g. col = @p0 OR col = @p1). Split on top-level
+        // ✅ Issue #348: handle OR chains (e.g. col = @p0 OR col = @p1). Split on top-level
         // OR first — any matching branch makes the whole condition true.
-        var orParts = SplitTopLevelLogical(trimmedCondition, "OR");
+        var orParts = SqlInPredicate.SplitTopLevelLogical(trimmedCondition, "OR");
         if (orParts.Count > 1)
         {
             return orParts.Any(part => EvaluateCondition(row, part));
         }
 
-        var parts = SplitTopLevelLogical(trimmedCondition, "AND");
+        var parts = SqlInPredicate.SplitTopLevelLogical(trimmedCondition, "AND");
         if (parts.Count > 1)
         {
             return parts.All(part => EvaluateCondition(row, part));
@@ -1276,80 +1285,6 @@ private static bool EvaluateCondition(Dictionary<string, object> row, string con
         return EvaluateSingleCondition(row, trimmedCondition);
     }
 
-    /// <summary>
-    /// Splits a condition on a logical keyword (AND / OR) that appears at the top level only —
-    /// i.e. not inside parentheses or string literals. This keeps <c>IN ('a', 'b')</c> and
-    /// <c>(a = 1 OR b = 2)</c> intact while still splitting <c>col = 1 OR col = 2</c>.
-    /// </summary>
-    private static List<string> SplitTopLevelLogical(string text, string keyword)
-    {
-        var parts = new List<string>();
-        int depth = 0;
-        bool inString = false;
-        char quote = '\0';
-        int start = 0;
-        int i = 0;
-
-        while (i < text.Length)
-        {
-            char c = text[i];
-            if (inString)
-            {
-                inString = c != quote; // closing quote exits the string literal
-                i++;
-                continue;
-            }
-
-            if (c is '\'' or '"')
-            {
-                inString = true;
-                quote = c;
-            }
-            else if (c == '(')
-            {
-                depth++;
-            }
-            else if (c == ')')
-            {
-                depth = Math.Max(0, depth - 1);
-            }
-            else if (IsLogicalKeywordAt(text, i, keyword, depth))
-            {
-                parts.Add(text[start..i].Trim());
-                i += 1 + keyword.Length;
-                while (i < text.Length && char.IsWhiteSpace(text[i]))
-                {
-                    i++;
-                }
-
-                start = i;
-                continue;
-            }
-
-            i++;
-        }
-
-        parts.Add(text[start..].Trim());
-        return parts;
-    }
-
-    /// <summary>
-    /// True when <paramref name="keyword"/> (OR / AND) starts right after a top-level space at
-    /// <paramref name="index"/> and is followed by whitespace, e.g. <c>"col = 1 OR col = 2"</c>.
-    /// </summary>
-    private static bool IsLogicalKeywordAt(string text, int index, string keyword, int depth)
-    {
-        if (depth != 0 || text[index] is not (' ' or '\t'))
-        {
-            return false;
-        }
-
-        var after = index + 1 + keyword.Length;
-        return after < text.Length
-            && text.AsSpan(index + 1, keyword.Length).Equals(keyword.AsSpan(), StringComparison.OrdinalIgnoreCase)
-            && char.IsWhiteSpace(text[after]);
-    }
-
     private static bool EvaluateSingleCondition(Dictionary<string, object> row, string condition)
     {
         var trimmed = condition.Trim();
@@ -1433,7 +1368,10 @@ private static bool EvaluateSingleCondition(Dictionary<string, object> row, stri
 
         if (op == null || opIndex < 0)
         {
-            return true;
+            // ✅ Issue #348: fail closed — an unrecognized condition must NOT accept every
+            // row (the old "return true" turned malformed/unsupported predicates into a
+            // tautology that silently returned the whole table).
+            return false;
         }
 
         var columnName = condition[..opIndex].Trim();