White space first of =* operator

[MrSEKIRO]

Version

2.14.2

Details

Hi,
I am using GridifyAsync for finding the records which some field contains some string starting with whitespace, but it ignores the first white space of that string.
e.g. I want to look for " Something" on column error:
error Like =* Something

the sql would be like:

SELECT * 
FROM tbl_Log 
WHERE Error Like '% Something%'

but it search for all strings in error column which has "Something".

Steps to reproduce

• Step 1
  make some table with string column
• Step 2
  search using below expression:
  error Like =* Something

[alirezanet]

Hi @MrSEKIRO,
Thank you for the feedback. this is a known issue, You can find a temporary workaround here (although not sure if it works for your case)
But I'll try to fix this issue in the next versions

[MrSEKIRO]

For my case it just return the result if there is no spaces and trimming is not needed.

I should wait for next version.
Tnx @alirezanet

[alirezanet]

I just tested the leading space behavior and noticed you can escape it if needed. so another workaround would be this:

Error =*\ Something

But I'm also considering adding a new configuration to disable the AutoTrim feature. what do you think?

[MrSEKIRO]

That may work but in my case I am doing some translations to Gridify filters and it won't fit well.
How about using quotations for Contains filters like that?

[alirezanet]

That may work but in my case I am doing some translations to Gridify filters and it won't fit well. How about using quotations for Contains filters like that?

If you mean something like this Error=*' Something' it will cause another problem, what if you want to search for a string that contains ' instead of space ... so basically it doesn't change anything and probably makes it worse because we need two escapes instead of one in that case. Error=*\' Something\'

[yasserebrahimi]

Root Cause & Solution

I've analyzed this bug and found the exact location of the issue.

Problem Location

The issue is in src/Gridify/Syntax/Parser.cs at line 19:

public Parser(string text, IEnumerable<IGridifyOperator> customOperators)
{
    var lexer = new Lexer(text, customOperators);
    SyntaxToken token;
    do
    {
        token = lexer.NextToken();
        if (token.Kind != SyntaxKind.WhiteSpace) _tokens.Add(token); // ⚠️ Issue here
    } while (token.Kind != SyntaxKind.End);
}

All whitespace tokens are filtered out, including those that are part of the search value.

Proposed Solution

Modify the Parser to distinguish between structural whitespace (between operators) and value whitespace:

public Parser(string text, IEnumerable<IGridifyOperator> customOperators)
{
    var lexer = new Lexer(text, customOperators);
    SyntaxToken token;
    SyntaxToken? previousToken = null;
    
    do
    {
        token = lexer.NextToken();
        
        // Only filter whitespace that's between operators/fields
        // Preserve whitespace that's part of values
        if (token.Kind != SyntaxKind.WhiteSpace)
        {
            _tokens.Add(token);
        }
        else if (previousToken != null && 
                 IsOperatorToken(previousToken.Value.Kind))
        {
            // Whitespace after operator might be part of value
            // Keep it for value processing
            _tokens.Add(token);
        }
        
        previousToken = token;
    } while (token.Kind != SyntaxKind.End);
}

private static bool IsOperatorToken(SyntaxKind kind)
{
    return kind is SyntaxKind.Equal or 
                   SyntaxKind.Like or 
                   SyntaxKind.NotLike or
                   SyntaxKind.StartsWith or
                   SyntaxKind.EndsWith;
}

Test Case

[Fact]
public void ShouldPreserveLeadingWhitespaceInLikeOperator()
{
    var query = new GridifyQuery { Filter = "error=* Something" };
    var result = testData.Where(x => x.Error.Contains(" Something")).ToList();
    var gridifyResult = testData.AsQueryable().Gridify(query);
    
    Assert.Equal(result.Count, gridifyResult.Count);
}

Happy to submit a PR with this fix and tests!

[alirezanet]

Hi @yasserebrahimi,
Thanks for your suggestion, it definitely addresses the root issue. My only reservation is that Gridify has been in use for a while without this behavior, so flipping the default could break existing filters (e.g., users who rely on trimming leading spaces field = value). To avoid that, I think we should add a configuration option (off by default) that enables conserving leading spaces. That way current users aren’t affected, and folks who want the new behavior can opt-in. Also if you’re up for it, I’d happily review a PR for this feature. 😊

[yasserebrahimi]

Hi, I investigated this issue and found that it's not possible to fix without breaking changes.

The problem is in the Lexer/Parser architecture:

• All whitespace between tokens is skipped during tokenization
• The Parser cannot distinguish between:
  • Name = John (whitespace between operator and value)
  • Name=* John (no whitespace, value starts with space)

Both cases result in the same token sequence after whitespace is stripped.

Possible solutions:

1. Add escape sequences (Recommended):

   • Name=*\ John - Backslash escapes the space
   • Name=*" John" - Quotes preserve whitespace

2. Breaking change:

   • Remove TrimStart() in Parser
   • This would require all existing users to update their queries

3. Track whitespace in tokens:

   • Add metadata to tokens about leading whitespace
   • Major refactoring required

Would you like me to implement solution #1 (escape sequences)?

[alirezanet]

Hi @yasserebrahimi,
If I'm not wrong we can escape the leading spaces right now, I already posted it before as a workaround here. the original request is to support it out of the box, which as we discussed we need a global configuration for that.