fixing #377 (#405)

slorello89 · web-flow · commit b0f2b9e9bde5 · 2023-08-16T10:26:00.000-04:00
diff --git a/docker/cluster/redis.conf b/docker/cluster/redis.conf
@@ -7,7 +7,6 @@ cluster-node-timeout 5000
 daemonize yes
 
 loadmodule /opt/redis-stack/lib/redisearch.so
-loadmodule /opt/redis-stack/lib/redisgraph.so
 loadmodule /opt/redis-stack/lib/redistimeseries.so
 loadmodule /opt/redis-stack/lib/rejson.so
 loadmodule /opt/redis-stack/lib/redisbloom.so
diff --git a/src/Redis.OM/Aggregation/AggregationPredicates/QueryPredicate.cs b/src/Redis.OM/Aggregation/AggregationPredicates/QueryPredicate.cs
@@ -45,32 +45,32 @@ protected override void ValidateAndPushOperand(Expression expression, Stack<stri
             {
                 if (binaryExpression.Right is ConstantExpression constantExpression)
                 {
-                    stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression.Member, constantExpression));
+                    stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression, constantExpression));
                 }
                 else if (binaryExpression.Right is UnaryExpression uni)
                 {
                     switch (uni.Operand)
                     {
                         case ConstantExpression c:
-                            stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression.Member, c));
+                            stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression, c));
                             break;
                         case MemberExpression mem when mem.Expression is ConstantExpression frame:
                         {
                             var val = ExpressionParserUtilities.GetValue(mem.Member, frame.Value);
-                            stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression.Member, System.Linq.Expressions.Expression.Constant(val)));
+                            stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression, System.Linq.Expressions.Expression.Constant(val)));
                             break;
                         }
                     }
                 }
                 else if (binaryExpression.Right is MemberExpression mem && mem.Expression is ConstantExpression frame)
                 {
                     var val = ExpressionParserUtilities.GetValue(mem.Member, frame.Value);
-                    stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression.Member, System.Linq.Expressions.Expression.Constant(val)));
+                    stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression, System.Linq.Expressions.Expression.Constant(val)));
                 }
                 else
                 {
                     var val = ExpressionParserUtilities.GetOperandStringForQueryArgs(binaryExpression.Right);
-                    stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression.Member, System.Linq.Expressions.Expression.Constant(val)));
+                    stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression, System.Linq.Expressions.Expression.Constant(val)));
                 }
             }
             else if (expression is ConstantExpression c
@@ -136,7 +136,7 @@ protected override void SplitBinaryExpression(BinaryExpression expression, Stack
             }
         }
 
-        private static string BuildEqualityPredicate(MemberInfo member, ConstantExpression expression)
+        private static string BuildEqualityPredicate(MemberInfo member, ConstantExpression expression, string memberStr)
         {
             var sb = new StringBuilder();
             var fieldAttribute = member.GetCustomAttribute<SearchFieldAttribute>();
@@ -145,7 +145,7 @@ private static string BuildEqualityPredicate(MemberInfo member, ConstantExpressi
                 throw new InvalidOperationException("Searches can only be performed on fields marked with a RedisFieldAttribute with the SearchFieldType not set to None");
             }
 
-            sb.Append($"@{member.Name}:");
+            sb.Append($"{memberStr}:");
             var searchFieldType = fieldAttribute.SearchFieldType != SearchFieldType.INDEXED
                 ? fieldAttribute.SearchFieldType
                 : ExpressionTranslator.DetermineIndexFieldsType(member);
@@ -167,16 +167,17 @@ private static string BuildEqualityPredicate(MemberInfo member, ConstantExpressi
             return sb.ToString();
         }
 
-        private string BuildQueryPredicate(ExpressionType expType, MemberInfo member, ConstantExpression constExpression)
+        private string BuildQueryPredicate(ExpressionType expType, MemberExpression member, ConstantExpression constExpression)
         {
+            var memberStr = ExpressionParserUtilities.GetOperandString(member);
             var queryPredicate = expType switch
             {
-                ExpressionType.GreaterThan => $"@{member.Name}:[({constExpression.Value} inf]",
-                ExpressionType.LessThan => $"@{member.Name}:[-inf ({constExpression.Value}]",
-                ExpressionType.GreaterThanOrEqual => $"@{member.Name}:[{constExpression.Value} inf]",
-                ExpressionType.LessThanOrEqual => $"@{member.Name}:[-inf {constExpression.Value}]",
-                ExpressionType.Equal => BuildEqualityPredicate(member, constExpression),
-                ExpressionType.NotEqual => $"@{member.Name} : -{{{constExpression.Value}}}",
+                ExpressionType.GreaterThan => $"{memberStr}:[({constExpression.Value} inf]",
+                ExpressionType.LessThan => $"{memberStr}:[-inf ({constExpression.Value}]",
+                ExpressionType.GreaterThanOrEqual => $"{memberStr}:[{constExpression.Value} inf]",
+                ExpressionType.LessThanOrEqual => $"{memberStr}:[-inf {constExpression.Value}]",
+                ExpressionType.Equal => BuildEqualityPredicate(member.Member, constExpression, memberStr),
+                ExpressionType.NotEqual => $"{memberStr} : -{{{constExpression.Value}}}",
                 _ => string.Empty
             };
             return queryPredicate;
diff --git a/src/Redis.OM/RediSearchCommands.cs b/src/Redis.OM/RediSearchCommands.cs
@@ -108,7 +108,7 @@ public static async Task<bool> CreateIndexAsync(this IRedisConnection connection
             }
             catch (Exception ex)
             {
-                if (ex.Message.Contains("Unknown Index name"))
+                if (ex.Message.ToLower().Contains("unknown index name"))
                 {
                     return null;
                 }
@@ -134,7 +134,7 @@ public static async Task<bool> CreateIndexAsync(this IRedisConnection connection
             }
             catch (Exception ex)
             {
-                if (ex.Message.Contains("Unknown Index name"))
+                if (ex.Message.ToLower().Contains("unknown index name"))
                 {
                     return null;
                 }
diff --git a/test/Redis.OM.Unit.Tests/RediSearchTests/AggregationFunctionalTests.cs b/test/Redis.OM.Unit.Tests/RediSearchTests/AggregationFunctionalTests.cs
@@ -271,16 +271,5 @@ public async Task GetGroupCount()
                 Assert.True(1<=result["COUNT"]);
             }
         }
-
-        [Fact]
-        public void TestUnsortedFields()
-        {
-            Setup();
-            var collection = new RedisAggregationSet<Person>(_connection);
-
-            Assert.Throws<NotSupportedException>(() =>
-                collection.Apply(x => $"{x.RecordShell.Email}", "TheEmailThatNeverWas").ToList());
-
-        }
     }
 }
diff --git a/test/Redis.OM.Unit.Tests/RediSearchTests/AggregationSetTests.cs b/test/Redis.OM.Unit.Tests/RediSearchTests/AggregationSetTests.cs
@@ -537,6 +537,27 @@ public void PunctuationMarkInTagQuery()
             _ = collection.Where(query).ToList();
             _substitute.Received().Execute("FT.AGGREGATE", "person-idx", "@FirstName:{Walter\\-Junior}", "WITHCURSOR", "COUNT", "10000");
         }
+        
+        [Fact]
+        public void CustomPropertyNamesInQuery()
+        {
+            //Arrange
+            _substitute.Execute("FT.AGGREGATE", Arg.Any<string[]>()).Returns(MockedResult);
+            _substitute.Execute("FT.CURSOR", Arg.Any<string[]>()).Returns(MockedResultCursorEnd);
+
+            var collection = new RedisAggregationSet<ObjectWithPropertyNamesDefined>(_substitute, true, 10);
+
+            //Act
+            _ = collection.Where(x => x.RecordShell.Key == "test").ToList();
+
+            //Assert
+            _substitute.Received().Execute("FT.AGGREGATE",
+                "objectwithpropertynamesdefined-idx",
+                "@notKey:{test}",
+                "WITHCURSOR",
+                "COUNT",
+                "10");
+        }
 
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -45,32 +45,32 @@ protected override void ValidateAndPushOperand(Expression expression, Stack<stri`
`45`	`45`	`{`
`46`	`46`	`if (binaryExpression.Right is ConstantExpression constantExpression)`
`47`	`47`	`{`
`48`		`- stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression.Member, constantExpression));`
	`48`	`+ stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression, constantExpression));`
`49`	`49`	`}`
`50`	`50`	`else if (binaryExpression.Right is UnaryExpression uni)`
`51`	`51`	`{`
`52`	`52`	`switch (uni.Operand)`
`53`	`53`	`{`
`54`	`54`	`case ConstantExpression c:`
`55`		`- stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression.Member, c));`
	`55`	`+ stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression, c));`
`56`	`56`	`break;`
`57`	`57`	`case MemberExpression mem when mem.Expression is ConstantExpression frame:`
`58`	`58`	`{`
`59`	`59`	`var val = ExpressionParserUtilities.GetValue(mem.Member, frame.Value);`
`60`		`- stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression.Member, System.Linq.Expressions.Expression.Constant(val)));`
	`60`	`+ stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression, System.Linq.Expressions.Expression.Constant(val)));`
`61`	`61`	`break;`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`	`else if (binaryExpression.Right is MemberExpression mem && mem.Expression is ConstantExpression frame)`
`66`	`66`	`{`
`67`	`67`	`var val = ExpressionParserUtilities.GetValue(mem.Member, frame.Value);`
`68`		`- stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression.Member, System.Linq.Expressions.Expression.Constant(val)));`
	`68`	`+ stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression, System.Linq.Expressions.Expression.Constant(val)));`
`69`	`69`	`}`
`70`	`70`	`else`
`71`	`71`	`{`
`72`	`72`	`var val = ExpressionParserUtilities.GetOperandStringForQueryArgs(binaryExpression.Right);`
`73`		`- stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression.Member, System.Linq.Expressions.Expression.Constant(val)));`
	`73`	`+ stack.Push(BuildQueryPredicate(binaryExpression.NodeType, memberExpression, System.Linq.Expressions.Expression.Constant(val)));`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`	`else if (expression is ConstantExpression c`
`@@ -136,7 +136,7 @@ protected override void SplitBinaryExpression(BinaryExpression expression, Stack`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`
`139`		`- private static string BuildEqualityPredicate(MemberInfo member, ConstantExpression expression)`
	`139`	`+ private static string BuildEqualityPredicate(MemberInfo member, ConstantExpression expression, string memberStr)`
`140`	`140`	`{`
`141`	`141`	`var sb = new StringBuilder();`
`142`	`142`	`var fieldAttribute = member.GetCustomAttribute<SearchFieldAttribute>();`
`@@ -145,7 +145,7 @@ private static string BuildEqualityPredicate(MemberInfo member, ConstantExpressi`
`145`	`145`	`throw new InvalidOperationException("Searches can only be performed on fields marked with a RedisFieldAttribute with the SearchFieldType not set to None");`
`146`	`146`	`}`
`147`	`147`
`148`		`- sb.Append($"@{member.Name}:");`
	`148`	`+ sb.Append($"{memberStr}:");`
`149`	`149`	`var searchFieldType = fieldAttribute.SearchFieldType != SearchFieldType.INDEXED`
`150`	`150`	`? fieldAttribute.SearchFieldType`
`151`	`151`	`: ExpressionTranslator.DetermineIndexFieldsType(member);`
`@@ -167,16 +167,17 @@ private static string BuildEqualityPredicate(MemberInfo member, ConstantExpressi`
`167`	`167`	`return sb.ToString();`
`168`	`168`	`}`
`169`	`169`
`170`		`- private string BuildQueryPredicate(ExpressionType expType, MemberInfo member, ConstantExpression constExpression)`
	`170`	`+ private string BuildQueryPredicate(ExpressionType expType, MemberExpression member, ConstantExpression constExpression)`
`171`	`171`	`{`
	`172`	`+ var memberStr = ExpressionParserUtilities.GetOperandString(member);`
`172`	`173`	`var queryPredicate = expType switch`
`173`	`174`	`{`
`174`		`- ExpressionType.GreaterThan => $"@{member.Name}:[({constExpression.Value} inf]",`
`175`		`- ExpressionType.LessThan => $"@{member.Name}:[-inf ({constExpression.Value}]",`
`176`		`- ExpressionType.GreaterThanOrEqual => $"@{member.Name}:[{constExpression.Value} inf]",`
`177`		`- ExpressionType.LessThanOrEqual => $"@{member.Name}:[-inf {constExpression.Value}]",`
`178`		`- ExpressionType.Equal => BuildEqualityPredicate(member, constExpression),`
`179`		`- ExpressionType.NotEqual => $"@{member.Name} : -{{{constExpression.Value}}}",`
	`175`	`+ ExpressionType.GreaterThan => $"{memberStr}:[({constExpression.Value} inf]",`
	`176`	`+ ExpressionType.LessThan => $"{memberStr}:[-inf ({constExpression.Value}]",`
	`177`	`+ ExpressionType.GreaterThanOrEqual => $"{memberStr}:[{constExpression.Value} inf]",`
	`178`	`+ ExpressionType.LessThanOrEqual => $"{memberStr}:[-inf {constExpression.Value}]",`
	`179`	`+ ExpressionType.Equal => BuildEqualityPredicate(member.Member, constExpression, memberStr),`
	`180`	`+ ExpressionType.NotEqual => $"{memberStr} : -{{{constExpression.Value}}}",`
`180`	`181`	`_ => string.Empty`
`181`	`182`	`};`
`182`	`183`	`return queryPredicate;`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ public static async Task<bool> CreateIndexAsync(this IRedisConnection connection`
`108`	`108`	`}`
`109`	`109`	`catch (Exception ex)`
`110`	`110`	`{`
`111`		`- if (ex.Message.Contains("Unknown Index name"))`
	`111`	`+ if (ex.Message.ToLower().Contains("unknown index name"))`
`112`	`112`	`{`
`113`	`113`	`return null;`
`114`	`114`	`}`
`@@ -134,7 +134,7 @@ public static async Task<bool> CreateIndexAsync(this IRedisConnection connection`
`134`	`134`	`}`
`135`	`135`	`catch (Exception ex)`
`136`	`136`	`{`
`137`		`- if (ex.Message.Contains("Unknown Index name"))`
	`137`	`+ if (ex.Message.ToLower().Contains("unknown index name"))`
`138`	`138`	`{`
`139`	`139`	`return null;`
`140`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -271,16 +271,5 @@ public async Task GetGroupCount()`
`271`	`271`	`Assert.True(1<=result["COUNT"]);`
`272`	`272`	`}`
`273`	`273`	`}`
`274`		`-`
`275`		`- [Fact]`
`276`		`- public void TestUnsortedFields()`
`277`		`- {`
`278`		`- Setup();`
`279`		`- var collection = new RedisAggregationSet<Person>(_connection);`
`280`		`-`
`281`		`- Assert.Throws<NotSupportedException>(() =>`
`282`		`- collection.Apply(x => $"{x.RecordShell.Email}", "TheEmailThatNeverWas").ToList());`
`283`		`-`
`284`		`- }`
`285`	`274`	`}`
`286`	`275`	`}`