EQUAL PREDICATE

[SylvainAssemat]

Hi all

I am trying some tests on the 1.0.0 released yesterday to see if wen can update our 0.9.7 stack without too much regression.

I have an issue on a simple filter query using EntityStream and find out that the double quote seems problematic

💾 BACKINGQUERY : (( @reference:{CLIENTS}) ( @menuId:{"ae11d16c\-33b8\-4ed0\-b5d8\-a7fb5f47bc60"})) java.lang.RuntimeException: redis.clients.jedis.exceptions.JedisDataException: Syntax error at offset 36 near menuId
it seems in EqualPredicate.class , this method is adding the double quote because of i am escaping the hyphen

   private String escapeTagValue(String value) {
      return value.matches(".*[\\s,.<>{}\\[\\]\"':;!@#$%^&*()\\-+=~/].*") ? "{\"" + value + "\"}" : "{" + value + "}";
   }

This method is not present in 0.9.7 so, it 's working as expected .

What do you think ?

Thanks

---

Complément :

        EqualPredicate condition1 = RDMenu$.REFERENCE.eq(QueryUtils.escape(reference, true));
        EqualPredicate condition2 = RDMenu$.MENU_ID.eq(menuId.replaceAll("-", "\\-"));

        Predicate filter = condition1.and(condition2);

In my class

    @Id
    private String id; // UUID 

    @Indexed
    private String menuId;

In Metamodel :

  public static TextTagField<RDMenu, String> MENU_ID;
  public static TextTagField<RDMenu, String> ID;

[bsbodden]

@SylvainAssemat I tried to reproduce with 1.0.0 as follows:

package com.redis.om.spring.issues;

import com.redis.om.spring.annotations.Document;
import com.redis.om.spring.annotations.Indexed;
import com.redis.om.spring.annotations.TagIndexed;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import org.springframework.data.annotation.Id;

@Document
@Data
@RequiredArgsConstructor
@AllArgsConstructor(staticName = "of")
public class TestEntity644 {
    @Id
    private String id;
    
    @NonNull
    @Indexed
    private String name;
    
    @NonNull
    @TagIndexed
    private String menuId;  // UUID stored as string in a tag field
    
    @NonNull
    @TagIndexed
    private String reference;
}

and with a repo:

package com.redis.om.spring.issues;

import com.redis.om.spring.repository.RedisDocumentRepository;

public interface TestEntity644Repository extends RedisDocumentRepository<TestEntity644, String> {
}

here's my test:

package com.redis.om.spring.issues;

import com.redis.om.spring.AbstractBaseOMTest;
import com.redis.om.spring.TestConfig;
import com.redis.om.spring.annotations.EnableRedisDocumentRepositories;
import com.redis.om.spring.issues.TestEntity644$;
import com.redis.om.spring.search.stream.EntityStream;
import com.redis.om.spring.search.stream.predicates.SearchFieldPredicate;
import com.redis.om.spring.search.stream.predicates.tag.EqualPredicate;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.annotation.DirtiesContext;

import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatNoException;

/**
 * Regression test for issue #644
 * https://github.com/redis/redis-om-spring/issues/644
 * 
 * Tests that UUID values in tag fields work correctly with EntityStream queries.
 * The issue reported that in version 1.0.0, queries with UUID values fail with
 * a syntax error due to incorrect escaping in the EqualPredicate class.
 */
@SpringBootTest(
    classes = Issue644RegressionTest.Config.class,
    properties = { "spring.main.allow-bean-definition-overriding=true" }
)
@DirtiesContext
class Issue644RegressionTest extends AbstractBaseOMTest {
    
    @SpringBootApplication
    @Configuration
    @EnableRedisDocumentRepositories(basePackages = "com.redis.om.spring.issues")
    static class Config extends TestConfig {
    }

    @Autowired
    private TestEntity644Repository repository;
    
    @Autowired
    private EntityStream entityStream;
    
    private String testUuid1;
    private String testUuid2;
    
    @BeforeEach
    void setup() {
        repository.deleteAll();
        
        testUuid1 = UUID.randomUUID().toString();
        testUuid2 = UUID.randomUUID().toString();
        
        // Create test entities with UUID values
        TestEntity644 entity1 = new TestEntity644("client1", testUuid1, "CLIENTS");
        TestEntity644 entity2 = new TestEntity644("client2", testUuid2, "CLIENTS");
        TestEntity644 entity3 = new TestEntity644("supplier1", testUuid1, "SUPPLIERS");
        
        repository.save(entity1);
        repository.save(entity2);
        repository.save(entity3);
    }
    
    @Test
    void testEntityStreamWithUuidInTagField() {
        // This test reproduces the issue from #644
        // The query should find entities with matching menuId (UUID) and reference
        
        List<TestEntity644> results = entityStream
            .of(TestEntity644.class)
            .filter(TestEntity644$.MENU_ID.eq(testUuid1))
            .filter(TestEntity644$.REFERENCE.eq("CLIENTS"))
            .collect(Collectors.toList());
        
        assertThat(results).hasSize(1);
        assertThat(results.get(0).getName()).isEqualTo("client1");
    }
    
    @Test
    void testEntityStreamWithOnlyUuidFilter() {
        // Test with only UUID filter
        List<TestEntity644> results = entityStream
            .of(TestEntity644.class)
            .filter(TestEntity644$.MENU_ID.eq(testUuid1))
            .collect(Collectors.toList());
        
        assertThat(results).hasSize(2);
        assertThat(results).extracting(TestEntity644::getName)
            .containsExactlyInAnyOrder("client1", "supplier1");
    }
    
    @Test
    void testEntityStreamWithMultipleUuids() {
        // Test filtering with multiple different UUIDs
        List<TestEntity644> results = entityStream
            .of(TestEntity644.class)
            .filter(TestEntity644$.MENU_ID.eq(testUuid2))
            .filter(TestEntity644$.REFERENCE.eq("CLIENTS"))
            .collect(Collectors.toList());
        
        assertThat(results).hasSize(1);
        assertThat(results.get(0).getName()).isEqualTo("client2");
    }
    
    @Test
    void testPredicateCompositionWithUuidAsReportedInIssue() {
        // This test reproduces the EXACT pattern reported in issue #644
        // The user is manually escaping the UUID and using predicate composition
        
        String menuId = testUuid1;
        String reference = "CLIENTS";
        
        // Recreate the exact pattern from the issue - user manually escapes hyphens
        EqualPredicate<TestEntity644, String> condition1 = TestEntity644$.REFERENCE.eq(reference);
        EqualPredicate<TestEntity644, String> condition2 = TestEntity644$.MENU_ID.eq(menuId.replaceAll("-", "\\\\-"));
        
        // Compose predicates using andAny() for different field types
        SearchFieldPredicate<TestEntity644, ?> filter = condition1.andAny(condition2);
        
        // Apply the composed predicate - this should fail if there's a bug with double escaping
        assertThatNoException().isThrownBy(() -> {
            List<TestEntity644> results = entityStream
                .of(TestEntity644.class)
                .filter(filter)
                .collect(Collectors.toList());
            
            // If manual escaping causes double escaping, this will fail
            assertThat(results).hasSize(1);
            assertThat(results.get(0).getName()).isEqualTo("client1");
        });
    }
    
    @Test 
    void testPredicateCompositionWithoutManualEscaping() {
        // Test the same pattern but WITHOUT manual escaping (as it should be used)
        
        String menuId = testUuid1;
        String reference = "CLIENTS";
        
        // Create predicates without manual escaping - let EqualPredicate handle it
        EqualPredicate<TestEntity644, String> condition1 = TestEntity644$.REFERENCE.eq(reference);
        EqualPredicate<TestEntity644, String> condition2 = TestEntity644$.MENU_ID.eq(menuId);
        
        // Compose predicates using andAny()
        SearchFieldPredicate<TestEntity644, ?> filter = condition1.andAny(condition2);
        
        // Apply the composed predicate - this should work correctly
        assertThatNoException().isThrownBy(() -> {
            List<TestEntity644> results = entityStream
                .of(TestEntity644.class)
                .filter(filter)
                .collect(Collectors.toList());
            
            assertThat(results).hasSize(1);
            assertThat(results.get(0).getName()).isEqualTo("client1");
        });
    }
    
    @Test
    void testActualQueryGeneratedForUuidWithHyphens() {
        // Test to examine the actual query generated for UUID values
        String menuId = "ae11d16c-33b8-4ed0-b5d8-a7fb5f47bc60"; // Specific UUID from the issue
        String reference = "CLIENTS";
        
        // Create test entity with this specific UUID
        repository.deleteAll();
        TestEntity644 entity = new TestEntity644("testEntity", menuId, reference);
        repository.save(entity);
        
        // Test 1: Without manual escaping (correct way)
        EqualPredicate<TestEntity644, String> cond1 = TestEntity644$.REFERENCE.eq(reference);
        EqualPredicate<TestEntity644, String> cond2 = TestEntity644$.MENU_ID.eq(menuId);
        SearchFieldPredicate<TestEntity644, ?> filter = cond1.andAny(cond2);
        
        List<TestEntity644> results = entityStream
            .of(TestEntity644.class)
            .filter(filter)
            .collect(Collectors.toList());
        
        assertThat(results).hasSize(1);
        assertThat(results.get(0).getMenuId()).isEqualTo(menuId);
        
        // Test 2: With manual escaping (as user reported)
        String escapedMenuId = menuId.replaceAll("-", "\\\\-");
        EqualPredicate<TestEntity644, String> cond3 = TestEntity644$.MENU_ID.eq(escapedMenuId);
        SearchFieldPredicate<TestEntity644, ?> filter2 = cond1.andAny(cond3);
        
        // This might fail if double escaping occurs
        List<TestEntity644> results2 = entityStream
            .of(TestEntity644.class)
            .filter(filter2)
            .collect(Collectors.toList());
        
        // If double escaping is happening, this will return 0 results
        assertThat(results2).describedAs("Manual escaping should not cause double escaping").hasSize(1);
    }
}

I could be missing something but I can get it to reproduce. Maybe the METAMODELS need to be regenerated?

[SylvainAssemat]

Thanks Brian

My apologize, i should give a little small project with mandatory tests as you do to let you have more confort to treat my issue.

I try to check again (and reproduce if needed) tonight at home a i let you know ASAP what s goign on.