adding ability to index and query datetimes (#240)

* adding ability to index and query datetimes

* fixing sortable bit of index creation

Author: slorello89

README.md

@@ -188,6 +188,10 @@ Once the index is created, we can:
 
 Let's see how!
 
+### Indexing DateTimes
+
+As of version 0.4.0, all DateTime objects are indexed as numerics, and they are inserted as numerics into JSON documents. Because of this, you can query them as if they were numerics!
+
 ### 🔑 Keys and Ids
 
 #### ULIDs and strings

src/Redis.OM/Common/ExpressionParserUtilities.cs

@@ -673,6 +673,11 @@ private static string ValueToString(object value)
                 return ((double)value).ToString(CultureInfo.InvariantCulture);
             }
 
+            if (value is DateTime dt)
+            {
+                return new DateTimeOffset(dt).ToUnixTimeMilliseconds().ToString(CultureInfo.InvariantCulture);
+            }
+
             return value.ToString();
         }
 

src/Redis.OM/Common/ExpressionTranslator.cs

@@ -332,7 +332,7 @@ internal static string TranslateBinaryExpression(BinaryExpression binExpression)
                     }
                     else
                     {
-                        if (!int.TryParse(rightContent, out _))
+                        if (!int.TryParse(rightContent, out _) && !long.TryParse(rightContent, out _))
                         {
                             rightContent = ((int)Enum.Parse(member.Type, rightContent)).ToString();
                         }

src/Redis.OM/Modeling/DateTimeJsonConverter.cs

@@ -12,15 +12,16 @@ public class DateTimeJsonConverter : JsonConverter<DateTime>
         /// <inheritdoc />
         public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
-            var val = reader.GetString();
+            long val = reader.TokenType == JsonTokenType.String ? long.Parse(reader.GetString() !) : reader.GetInt64();
+
             DateTime dateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
-            return TimeZoneInfo.ConvertTimeFromUtc(dateTime.AddMilliseconds(long.Parse(val!)), TimeZoneInfo.Local);
+            return TimeZoneInfo.ConvertTimeFromUtc(dateTime.AddMilliseconds(val), TimeZoneInfo.Local);
         }
 
         /// <inheritdoc />
         public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
         {
-            writer.WriteStringValue(new DateTimeOffset(value).ToUnixTimeMilliseconds().ToString());
+            writer.WriteNumberValue(new DateTimeOffset(value).ToUnixTimeMilliseconds());
         }
     }
 }

src/Redis.OM/Modeling/TypeDeterminationUtilities.cs

@@ -24,6 +24,7 @@ internal static class TypeDeterminationUtilities
             typeof(uint),
             typeof(ushort),
             typeof(float),
+            typeof(DateTime),
         };
 
         /// <summary>

src/Redis.OM/Redis.OM.csproj

@@ -6,9 +6,9 @@
     <RootNamespace>Redis.OM</RootNamespace>
     <Nullable>enable</Nullable>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
-    <PackageVersion>0.3.1</PackageVersion>
-    <Version>0.3.1</Version>
-    <PackageReleaseNotes>https://github.com/redis/redis-om-dotnet/releases/tag/v0.3.1</PackageReleaseNotes>
+    <PackageVersion>0.4.0</PackageVersion>
+    <Version>0.4.0</Version>
+    <PackageReleaseNotes>https://github.com/redis/redis-om-dotnet/releases/tag/v0.4.0</PackageReleaseNotes>
     <Description>Object Mapping and More for Redis</Description>
     <Title>Redis OM</Title>
     <Authors>Steve Lorello</Authors>

test/Redis.OM.Unit.Tests/RediSearchTests/ObjectWithDateTime.cs

@@ -0,0 +1,27 @@
+using System;
+using Redis.OM.Modeling;
+
+namespace Redis.OM.Unit.Tests.RediSearchTests;
+
+[Document(StorageType = StorageType.Json)]
+public class ObjectWithDateTime
+{
+    [RedisField]
+    public string Id { get; set; }
+    [Indexed(Sortable = true)]
+    public DateTime Timestamp { get; set; }
+    [Indexed]
+    public DateTime? NullableTimestamp { get; set; }
+}
+
+[Document(StorageType = StorageType.Hash)]
+public class ObjectWithDateTimeHash
+{
+    [RedisField]
+    public string Id { get; set; }
+    
+    [Indexed]
+    public DateTime Timestamp { get; set; }
+    [Indexed]
+    public DateTime? NullableTimestamp { get; set; }
+}

test/Redis.OM.Unit.Tests/RediSearchTests/SearchFunctionalTests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.VisualBasic;
@@ -858,5 +859,44 @@ public async Task TestStatelessCollection()
             Assert.Equal(0,collection.StateManager.Data.Count);
             Assert.Equal(0,collection.StateManager.Snapshot.Count);
         }
+
+        public void CompareTimestamps(DateTime ts1, DateTime ts2)
+        {
+            Assert.Equal(ts1.ToString("yyyy-MM-ddTHH\\:mm\\:ss.fff", CultureInfo.InvariantCulture), ts2.ToString("yyyy-MM-ddTHH\\:mm\\:ss.fff", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public async Task TestTimeStampRanges()
+        {
+            var collection = new RedisCollection<ObjectWithDateTime>(_connection, false, 10000);
+            var timestamp = DateTime.Now;
+            var greaterThanTimestamp = DateTime.Now.Subtract(TimeSpan.FromHours(1));
+            var unixTimestamp = new DateTimeOffset(timestamp).ToUnixTimeMilliseconds();
+            var obj = new ObjectWithDateTime { Timestamp = timestamp, NullableTimestamp = timestamp };
+            var id = await collection.InsertAsync(obj);
+            var first = await collection.FirstOrDefaultAsync(x => x.Timestamp > greaterThanTimestamp);
+            Assert.NotNull(first);
+            Assert.NotNull(first.NullableTimestamp);
+            CompareTimestamps(timestamp, first.Timestamp);
+            CompareTimestamps(timestamp, first.NullableTimestamp.Value);
+            Assert.Equal(obj.Id, first.Id);
+        }
+
+        [Fact]
+        public async Task TestTimeStampRangesHash()
+        {
+            var collection = new RedisCollection<ObjectWithDateTimeHash>(_connection, false, 10000);
+            var timestamp = DateTime.Now;
+            var greaterThanTimestamp = DateTime.Now.Subtract(TimeSpan.FromHours(1));
+            var unixTimestamp = new DateTimeOffset(timestamp).ToUnixTimeMilliseconds();
+            var obj = new ObjectWithDateTimeHash { Timestamp = timestamp, NullableTimestamp = timestamp };
+            var id = await collection.InsertAsync(obj);
+            var first = await collection.FirstOrDefaultAsync(x => x.Timestamp > greaterThanTimestamp);
+            Assert.NotNull(first);
+            Assert.NotNull(first.NullableTimestamp);
+            CompareTimestamps(timestamp, first.Timestamp);
+            CompareTimestamps(timestamp, first.NullableTimestamp.Value);
+            Assert.Equal(obj.Id, first.Id);
+        }
     }
 }