Embedded objects queries & Array Indexing/Querying. (#76)

Author: slorello89

README.md

@@ -84,13 +84,14 @@ docker run -p 6379:6379 redislabs/redismod:preview
 With Redis OM, you can model your data and declare indexes with minimal code. For example, here's how we might model a customer object:
 
 ```csharp
-[Document]
+[Document(StorageType = StorageType.Json)]
 public class Customer
 {
-   [Indexed(Sortable = true)] public string FirstName { get; set; }
-   [Indexed(Aggregatable = true)] public string LastName { get; set; }
+   [Indexed] public string FirstName { get; set; }
+   [Indexed] public string LastName { get; set; }
    public string Email { get; set; }
    [Indexed(Sortable = true)] public int Age { get; set; }
+   [Indexed] public string[] NickNames {get; set;}
 }
 ```
 
@@ -104,6 +105,63 @@ var provider = new RedisConnectionProvider("redis://localhost:6379");
 provider.Connection.CreateIndex(typeof(Customer));
 ```
 
+### Indexing Embedded Documents
+
+There are two methods for indexing embedded documents with Redis.OM, an embedded document is a complex object, e.g. if our `Customer` model had an `Address` property with the following model:
+
+```csharp
+[Document(IndexName = "address-idx", StorageType = StorageType.Json)]
+public partial class Address
+{
+    public string StreetName { get; set; }
+    public string ZipCode { get; set; }
+    [Indexed] public string City { get; set; }
+    [Indexed] public string State { get; set; }
+    [Indexed(CascadeDepth = 1)] public Address ForwardingAddress { get; set; }
+    [Indexed] public GeoLoc Location { get; set; }
+    [Indexed] public int HouseNumber { get; set; }
+}
+```
+
+#### Index By JSON Path
+
+You can index fields by JSON path, in the top level model, in this case `Customer` you can decorate the `Address` property with an `Indexed` and/or `Searchable` attribute, specifying the JSON path to the desired field:
+
+```csharp
+[Document(StorageType = StorageType.Json)]
+public class Customer
+{
+   [Indexed] public string FirstName { get; set; }
+   [Indexed] public string LastName { get; set; }
+   public string Email { get; set; }
+   [Indexed(Sortable = true)] public int Age { get; set; }
+   [Indexed] public string[] NickNames {get; set;}
+   [Indexed(JsonPath = "$.ZipCode")]
+   [Searchable(JsonPath = "$.StreetAddress")]
+   public Address Address {get; set;}
+}
+```
+
+#### Cascading Index
+
+Alternatively, you can also embedded models by cascading indexes. In this instance you'd simply decorate the property with `Indexed` and set the `CascadeDepth` to whatever to however may levels you want the model to cascade for. The default is 0, so if `CascadeDepth` is not set, indexing an object will be a no-op:
+
+```csharp
+[Document(StorageType = StorageType.Json)]
+public class Customer
+{
+   [Indexed] public string FirstName { get; set; }
+   [Indexed] public string LastName { get; set; }
+   public string Email { get; set; }
+   [Indexed(Sortable = true)] public int Age { get; set; }
+   [Indexed] public string[] NickNames {get; set;}
+   [Indexed(CascadeDepth = 2)]
+   public Address Address {get; set;}
+}
+```
+
+In the above case, all indexed/searchable fields in Address will be indexed down 2 levels, so the `ForwardingAddress` field in `Address` will also be indexed.
+
 Once the index is created, we can:
 
 * Insert Customer objects into Redis
@@ -120,14 +178,15 @@ Let's see how!
 Ids are unique per object, and are used as part of key generation for the primary index in Redis. The natively supported Id type in Redis OM is the [ULID][ulid-url]. You can bind ids to your model, by explicitly decorating your Id field with the `RedisIdField` attribute:
 
 ```csharp
-[Document]
+[Document(StorageType = StorageType.Json)]
 public class Customer
 {
     [RedisIdField] public Ulid Id { get; set; }
-    [Indexed(Sortable = true)] public string FirstName { get; set; }
-    [Indexed(Aggregatable = true)] public string LastName { get; set; }
+    [Indexed] public string FirstName { get; set; }
+    [Indexed] public string LastName { get; set; }
     public string Email { get; set; }
     [Indexed(Sortable = true)] public int Age { get; set; }
+    [Indexed] public string[] NickNames { get; set; }
 }
 ```
 
@@ -203,6 +262,9 @@ customers.Where(x => x.LastName == "Bond" || x.Age > 65);
 
 // Find all customers whose last name is Bond AND whose first name is James
 customers.Where(x => x.LastName == "Bond" && x.FirstName == "James");
+
+// Find all customers with the nickname of Jim
+customer.Where(x=>x.NickNames.Contains("Jim"));
 ```
 
 ### 🖩 Aggregations

src/Redis.OM/Common/ExpressionParserUtilities.cs

@@ -5,6 +5,7 @@
 using System.Reflection;
 using System.Text;
 using System.Text.RegularExpressions;
+using Redis.OM.Aggregation;
 using Redis.OM.Aggregation.AggregationPredicates;
 using Redis.OM.Modeling;
 using Redis.OM.Searching.Query;
@@ -155,21 +156,117 @@ internal static RedisGeoFilter TranslateGeoFilter(MethodCallExpression exp)
             return new RedisGeoFilter(memberOperand, longitude, latitude, radius, unit);
         }
 
+        /// <summary>
+        /// Gets the search field name from member expression. Will climb back up to the parent node and build the alias.
+        /// Which will be all the names in the path to the expression seperated by an underscore. e.g. Address_City.
+        /// </summary>
+        /// <param name="member">The member expression to pull the serach field name from.</param>
+        /// <returns>The alias to search for.</returns>
+        internal static string GetSearchFieldNameFromMember(MemberExpression member)
+        {
+            var stack = GetMemberChain(member);
+            var topMember = stack.Peek();
+            var memberPath = stack.Select(x => x.Name).ToArray();
+
+            if (topMember == member.Member)
+            {
+                var searchField = member.Member.GetCustomAttributes().Where(x => x is SearchFieldAttribute).Cast<SearchFieldAttribute>().FirstOrDefault();
+                if (searchField != null && !string.IsNullOrEmpty(searchField.PropertyName))
+                {
+                    return searchField.PropertyName;
+                }
+            }
+
+            return string.Join("_", memberPath);
+        }
+
+        /// <summary>
+        /// Gets the chain of members down to the currently accessed member.
+        /// </summary>
+        /// <param name="memberExpression">The member expression being accessed.</param>
+        /// <returns>The chain of members down to the currently accessed member, e.g. if a Person's
+        /// Address.City was being accessed a stack with Address at the top and City at the bottom would be returned.</returns>
+        internal static Stack<MemberInfo> GetMemberChain(MemberExpression memberExpression)
+        {
+            var memberStack = new Stack<MemberInfo>();
+            memberStack.Push(memberExpression.Member);
+
+            var parentExpression = memberExpression.Expression;
+            while (parentExpression is MemberExpression parentMember)
+            {
+                if (parentMember.Member.Name == nameof(AggregationResult<object>.RecordShell))
+                {
+                    break;
+                }
+
+                memberStack.Push(parentMember.Member);
+                parentExpression = parentMember.Expression;
+            }
+
+            return memberStack;
+        }
+
+        /// <summary>
+        /// Gets the Search Field type for the member.
+        /// </summary>
+        /// <param name="memberExpression">the member expression.</param>
+        /// <returns>the <see cref="SearchFieldAttribute"/>.</returns>
+        internal static SearchFieldAttribute? DetermineSearchAttribute(MemberExpression memberExpression)
+        {
+            var memberChain = GetMemberChain(memberExpression);
+            SearchFieldAttribute? attr;
+            do
+            {
+                var memberInfo = memberChain.Pop();
+                attr = memberInfo
+                    .GetCustomAttributes()
+                    .Where(x => x is SearchFieldAttribute)
+                    .Cast<SearchFieldAttribute>()
+                    .FirstOrDefault(x => x.JsonPath?.Split('.').Last() == memberExpression.Member.Name);
+            }
+            while (attr == null && memberChain.Any());
+
+            if (attr == null)
+            {
+                attr = memberExpression.Member.GetCustomAttributes().Where(x => x is SearchFieldAttribute).Cast<SearchFieldAttribute>().FirstOrDefault();
+            }
+
+            return attr;
+        }
+
         private static string GetOperandStringForMember(MemberExpression member)
         {
-            var searchField = member.Member.GetCustomAttribute<SearchFieldAttribute>();
+            var memberPath = new List<string>();
+            var parentExpression = member.Expression;
+            while (parentExpression is MemberExpression parentMember)
+            {
+                memberPath.Add(parentMember.Member.Name);
+                parentExpression = parentMember.Expression;
+            }
+
+            memberPath.Add(member.Member.Name);
+
+            var searchField = member.Member.GetCustomAttributes().Where(x => x is SearchFieldAttribute).Cast<SearchFieldAttribute>().FirstOrDefault();
             if (searchField == null)
             {
                 if (member.Expression is not ConstantExpression c)
                 {
-                    return Expression.Lambda(member).Compile().DynamicInvoke().ToString();
+                    try
+                    {
+                        return Expression.Lambda(member).Compile().DynamicInvoke().ToString();
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new InvalidOperationException(
+                            $"Could not retrieve value from {member.Member.Name}, most likely, it is not properly decorated in the model defining the index.", ex);
+                    }
                 }
 
                 var val = GetValue(member.Member, c.Value);
                 return val.ToString();
             }
 
-            var propertyName = string.IsNullOrEmpty(searchField.PropertyName) ? member.Member.Name : searchField.PropertyName;
+            var propertyName = GetSearchFieldNameFromMember(member);
             return $"@{propertyName}";
         }
 
@@ -400,14 +497,26 @@ private static IEnumerable<BinaryExpression> SplitBinaryExpression(BinaryExpress
 
         private static string TranslateContainsStandardQuerySyntax(MethodCallExpression exp)
         {
-            if (exp.Object is not MemberExpression member)
+            MemberExpression? expression = null;
+            if (exp.Object is MemberExpression)
             {
-                throw new ArgumentException("String that Contains is called on must be a member of an indexed class");
+                expression = exp.Object as MemberExpression;
             }
+            else if (exp.Arguments.FirstOrDefault() is MemberExpression)
+            {
+                expression = exp.Arguments.FirstOrDefault() as MemberExpression;
+            }
+
+            if (expression == null)
+            {
+                throw new InvalidOperationException($"Could not parse query for Contains");
+            }
+
+            var type = Nullable.GetUnderlyingType(expression.Type) ?? expression.Type;
 
-            var memberName = GetOperandStringForMember(member);
-            var literal = GetOperandStringForQueryArgs(exp.Arguments[0]);
-            return $"{memberName}:{literal}";
+            var memberName = GetOperandStringForMember(expression);
+            var literal = GetOperandStringForQueryArgs(exp.Arguments.Last());
+            return (type == typeof(string)) ? $"{memberName}:{literal}" : $"{memberName}:{{{literal}}}";
         }
     }
 }

src/Redis.OM/Common/ExpressionTranslator.cs

@@ -530,7 +530,7 @@ private static string TranslateBinaryExpression(BinaryExpression binExpression)
 
                 if (binExpression.Left is MemberExpression member)
                 {
-                    var predicate = BuildQueryPredicate(binExpression.NodeType, leftContent, rightContent, member.Member);
+                    var predicate = BuildQueryPredicate(binExpression.NodeType, leftContent, rightContent, member);
                     sb.Append("(");
                     sb.Append(predicate);
                     sb.Append(")");
@@ -558,25 +558,25 @@ private static string TranslateWhereMethod(MethodCallExpression expression)
             return BuildQueryFromExpression(lambda.Body);
         }
 
-        private static string BuildQueryPredicate(ExpressionType expType, string left, string right, MemberInfo member)
+        private static string BuildQueryPredicate(ExpressionType expType, string left, string right, MemberExpression memberExpression)
         {
             var queryPredicate = expType switch
             {
                 ExpressionType.GreaterThan => $"{left}:[({right} inf]",
                 ExpressionType.LessThan => $"{left}:[-inf ({right}]",
                 ExpressionType.GreaterThanOrEqual => $"{left}:[{right} inf]",
                 ExpressionType.LessThanOrEqual => $"{left}:[-inf {right}]",
-                ExpressionType.Equal => BuildEqualityPredicate(member, right),
-                ExpressionType.NotEqual => BuildEqualityPredicate(member, right, true),
+                ExpressionType.Equal => BuildEqualityPredicate(memberExpression, right),
+                ExpressionType.NotEqual => BuildEqualityPredicate(memberExpression, right, true),
                 _ => string.Empty
             };
             return queryPredicate;
         }
 
-        private static string BuildEqualityPredicate(MemberInfo member, string right, bool negated = false)
+        private static string BuildEqualityPredicate(MemberExpression member, string right, bool negated = false)
         {
             var sb = new StringBuilder();
-            var fieldAttribute = member.GetCustomAttribute<SearchFieldAttribute>();
+            var fieldAttribute = ExpressionParserUtilities.DetermineSearchAttribute(member);
             if (fieldAttribute == null)
             {
                 throw new InvalidOperationException("Searches can only be performed on fields marked with a " +
@@ -588,10 +588,10 @@ private static string BuildEqualityPredicate(MemberInfo member, string right, bo
                 sb.Append("-");
             }
 
-            sb.Append($"@{member.Name}:");
+            sb.Append($"@{ExpressionParserUtilities.GetSearchFieldNameFromMember(member)}:");
             var searchFieldType = fieldAttribute.SearchFieldType != SearchFieldType.INDEXED
                 ? fieldAttribute.SearchFieldType
-                : DetermineIndexFieldsType(member);
+                : DetermineIndexFieldsType(member.Member);
             switch (searchFieldType)
             {
                 case SearchFieldType.TAG:

src/Redis.OM/Modeling/RedisIndexingException.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace Redis.OM.Modeling
+{
+    /// <summary>
+    /// An exception thrown when trying to index classes in Redis.
+    /// </summary>
+    public class RedisIndexingException : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RedisIndexingException"/> class.
+        /// </summary>
+        /// <param name="message">the message.</param>
+        public RedisIndexingException(string message)
+            : base(message)
+        {
+        }
+    }
+}