Duplictae policy

NRedisTimeSeries.Test/TestAPI/TestAdd.cs

@@ -1,7 +1,8 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Threading;
 using NRedisTimeSeries.DataTypes;
+using NRedisTimeSeries.Commands;
 using StackExchange.Redis;
 using Xunit;
 
@@ -22,23 +23,23 @@ public void Dispose()
         public void TestAddNotExistingTimeSeries()
         {
             IDatabase db = redisFixture.Redis.GetDatabase();
-            TimeStamp now = DateTime.UtcNow;
-            Assert.Equal(now, db.TimeSeriesAdd(key, now, 1.1));
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.1));
             TimeSeriesInformation info = db.TimeSeriesInfo(key);
-            Assert.Equal(now, info.FirstTimeStamp);
-            Assert.Equal(now, info.LastTimeStamp);
+            Assert.Equal(timeStamp, info.FirstTimeStamp);
+            Assert.Equal(timeStamp, info.LastTimeStamp);
         }
 
         [Fact]
         public void TestAddExistingTimeSeries()
         {
             IDatabase db = redisFixture.Redis.GetDatabase();
             db.TimeSeriesCreate(key);
-            TimeStamp now = DateTime.UtcNow;
-            Assert.Equal(now, db.TimeSeriesAdd(key, now, 1.1));
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.1));
             TimeSeriesInformation info = db.TimeSeriesInfo(key);
-            Assert.Equal(now, info.FirstTimeStamp);
-            Assert.Equal(now, info.LastTimeStamp);
+            Assert.Equal(timeStamp, info.FirstTimeStamp);
+            Assert.Equal(timeStamp, info.LastTimeStamp);
         }
 
         [Fact]
@@ -55,26 +56,26 @@ public void TestAddStar()
         public void TestAddWithRetentionTime()
         {
             IDatabase db = redisFixture.Redis.GetDatabase();
-            TimeStamp now = DateTime.UtcNow;
+            TimeStamp timeStamp = DateTime.UtcNow;
             long retentionTime = 5000;
-            Assert.Equal(now, db.TimeSeriesAdd(key, now, 1.1, retentionTime: retentionTime));
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.1, retentionTime: retentionTime));
             TimeSeriesInformation info = db.TimeSeriesInfo(key);
-            Assert.Equal(now, info.FirstTimeStamp);
-            Assert.Equal(now, info.LastTimeStamp);
+            Assert.Equal(timeStamp, info.FirstTimeStamp);
+            Assert.Equal(timeStamp, info.LastTimeStamp);
             Assert.Equal(retentionTime, info.RetentionTime);
         }
 
         [Fact]
         public void TestAddWithLabels()
         {
             IDatabase db = redisFixture.Redis.GetDatabase();
-            TimeStamp now = DateTime.UtcNow;
+            TimeStamp timeStamp = DateTime.UtcNow;
             TimeSeriesLabel label = new TimeSeriesLabel("key", "value");
             var labels = new List<TimeSeriesLabel> { label };
-            Assert.Equal(now, db.TimeSeriesAdd(key, now, 1.1, labels: labels));
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.1, labels: labels));
             TimeSeriesInformation info = db.TimeSeriesInfo(key);
-            Assert.Equal(now, info.FirstTimeStamp);
-            Assert.Equal(now, info.LastTimeStamp);
+            Assert.Equal(timeStamp, info.FirstTimeStamp);
+            Assert.Equal(timeStamp, info.LastTimeStamp);
             Assert.Equal(labels, info.Labels);
         }
 
@@ -83,25 +84,95 @@ public void TestAddWithUncompressed()
         {
             IDatabase db = redisFixture.Redis.GetDatabase();
             db.TimeSeriesCreate(key);
-            TimeStamp now = DateTime.UtcNow;
-            Assert.Equal(now, db.TimeSeriesAdd(key, now, 1.1, uncompressed: true));
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.1, uncompressed: true));
             TimeSeriesInformation info = db.TimeSeriesInfo(key);
-            Assert.Equal(now, info.FirstTimeStamp);
-            Assert.Equal(now, info.LastTimeStamp);
+            Assert.Equal(timeStamp, info.FirstTimeStamp);
+            Assert.Equal(timeStamp, info.LastTimeStamp);
         }
 
         [Fact]
         public void TestAddWithChunkSize()
         {
             IDatabase db = redisFixture.Redis.GetDatabase();
-            TimeStamp now = DateTime.UtcNow;
-            Assert.Equal(now, db.TimeSeriesAdd(key, now, 1.1, chunkSizeBytes: 128));
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.1, chunkSizeBytes: 128));
             TimeSeriesInformation info = db.TimeSeriesInfo(key);
-            Assert.Equal(now, info.FirstTimeStamp);
-            Assert.Equal(now, info.LastTimeStamp);
+            Assert.Equal(timeStamp, info.FirstTimeStamp);
+            Assert.Equal(timeStamp, info.LastTimeStamp);
             Assert.Equal(128, info.ChunkSize);
         }
 
+        [Fact]
+        public void TestAddWithDuplicatePolicyBlock() 
+        {
+            IDatabase db = redisFixture.Redis.GetDatabase();
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.1));
+
+            var ex = Assert.Throws<RedisServerException>(() => db.TimeSeriesAdd(key, timeStamp, 1.2));
+            Assert.Equal("ERR TSDB: Error at upsert, update is not supported in BLOCK mode", ex.Message);
+        }
+
+        [Fact]
+        public void TestAddWithDuplicatePolicyMin()
+        { 
+            IDatabase db = redisFixture.Redis.GetDatabase();
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.1));
+
+            // Insert a bigger number and check that it did not change the value
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.2, policy: TsDuplicatePolicy.MIN));
+            Assert.Equal(1.1, db.TimeSeriesRange(key, timeStamp, timeStamp)[0].Val);
+            // Insert a smaller number and check that it changed
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.0, policy: TsDuplicatePolicy.MIN));
+            Assert.Equal(1.0, db.TimeSeriesRange(key, timeStamp, timeStamp)[0].Val);
+        }
+
+        [Fact]
+        public void TestAddWithDuplicatePolicyMax()
+        { 
+            IDatabase db = redisFixture.Redis.GetDatabase();
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.1));
+
+            // Insert a smaller number and check that it did not change the value
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.0, policy: TsDuplicatePolicy.MAX));
+            Assert.Equal(1.1, db.TimeSeriesRange(key, timeStamp, timeStamp)[0].Val);
+            // Insert a bigger number and check that it changed
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.2, policy: TsDuplicatePolicy.MAX));
+            Assert.Equal(1.2, db.TimeSeriesRange(key, timeStamp, timeStamp)[0].Val);
+        }
+
+        [Fact]
+        public void TestAddWithDuplicatePolicySum()
+        { 
+            IDatabase db = redisFixture.Redis.GetDatabase();
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.1));
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.0, policy: TsDuplicatePolicy.SUM));
+            Assert.Equal(2.1, db.TimeSeriesRange(key, timeStamp, timeStamp)[0].Val);
+        }
+
+        [Fact]
+        public void TestAddWithDuplicatePolicyFirst()
+        { 
+            IDatabase db = redisFixture.Redis.GetDatabase();
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.1));
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.0, policy: TsDuplicatePolicy.FIRST));
+            Assert.Equal(1.1, db.TimeSeriesRange(key, timeStamp, timeStamp)[0].Val);
+        }
+
+        [Fact]
+        public void TestAddWithDuplicatePolicyLast()
+        { 
+            IDatabase db = redisFixture.Redis.GetDatabase();
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.1));
+            Assert.Equal(timeStamp, db.TimeSeriesAdd(key, timeStamp, 1.0, policy: TsDuplicatePolicy.LAST));
+            Assert.Equal(1.0, db.TimeSeriesRange(key, timeStamp, timeStamp)[0].Val);
+        }      
 
         [Fact]
         public void TestOldAdd()

NRedisTimeSeries.Test/TestAPI/TestAddAsync.cs

@@ -1,4 +1,5 @@
-using NRedisTimeSeries.DataTypes;
+using NRedisTimeSeries.DataTypes;
+using NRedisTimeSeries.Commands;
 using StackExchange.Redis;
 using System;
 using System.Collections.Generic;
@@ -107,6 +108,90 @@ public async Task TestAddWithUncompressed()
             Assert.Equal(timeStamp, info.LastTimeStamp);
         }
 
+        [Fact]
+        public async Task TestAddWithDuplicatePolicyBlock() 
+        {
+            var key = CreateKeyName();
+            var db = redisFixture.Redis.GetDatabase();
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.1));
+
+            var ex = await Assert.ThrowsAsync<RedisServerException>(async () => await db.TimeSeriesAddAsync(key, timeStamp, 1.2));
+            Assert.Equal("ERR TSDB: Error at upsert, update is not supported in BLOCK mode", ex.Message);
+        }
+
+        [Fact]
+        public async Task TestAddWithDuplicatePolicyMin()
+        { 
+            var key = CreateKeyName();
+            var db = redisFixture.Redis.GetDatabase();
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.1));
+
+            // Insert a bigger number and check that it did not change the value
+            Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.2, policy: TsDuplicatePolicy.MIN));
+            IReadOnlyList<TimeSeriesTuple> results = await db.TimeSeriesRangeAsync(key, timeStamp, timeStamp);
+            Assert.Equal(1.1, results[0].Val);
+
+            // Insert a smaller number and check that it changed
+            Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.0, policy: TsDuplicatePolicy.MIN));
+            results = await db.TimeSeriesRangeAsync(key, timeStamp, timeStamp);
+            Assert.Equal(1.0, results[0].Val);
+        }
+
+        [Fact]
+        public async Task TestAddWithDuplicatePolicyMax()
+        { 
+            var key = CreateKeyName();
+            var db = redisFixture.Redis.GetDatabase();
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.1));
+
+            // Insert a smaller number and check that it did not change the value
+            Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.0, policy: TsDuplicatePolicy.MAX));
+            IReadOnlyList<TimeSeriesTuple> results = await db.TimeSeriesRangeAsync(key, timeStamp, timeStamp);
+            Assert.Equal(1.1, results[0].Val);
+            // Insert a bigger number and check that it changed
+            Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.2, policy: TsDuplicatePolicy.MAX));
+            results = await db.TimeSeriesRangeAsync(key, timeStamp, timeStamp);
+            Assert.Equal(1.2, results[0].Val);
+        }
+
+        [Fact]
+        public async Task TestAddWithDuplicatePolicySum()
+        { 
+            var key = CreateKeyName();
+            var db = redisFixture.Redis.GetDatabase();
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.1));
+            Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.0, policy: TsDuplicatePolicy.SUM));
+            IReadOnlyList<TimeSeriesTuple> results = await db.TimeSeriesRangeAsync(key, timeStamp, timeStamp);
+            Assert.Equal(2.1, results[0].Val);
+        }
+
+        [Fact]
+        public async Task TestAddWithDuplicatePolicyFirst()
+        { 
+            var key = CreateKeyName();
+            var db = redisFixture.Redis.GetDatabase();
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.1));
+            Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.0, policy: TsDuplicatePolicy.FIRST));
+            IReadOnlyList<TimeSeriesTuple> results = await db.TimeSeriesRangeAsync(key, timeStamp, timeStamp);
+            Assert.Equal(1.1, results[0].Val);
+        }
+
+        [Fact]
+        public async Task TestAddWithDuplicatePolicyLast()
+        { 
+            var key = CreateKeyName();
+            var db = redisFixture.Redis.GetDatabase();
+            TimeStamp timeStamp = DateTime.UtcNow;
+            Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.1));
+            Assert.Equal(timeStamp, await db.TimeSeriesAddAsync(key, timeStamp, 1.0, policy: TsDuplicatePolicy.LAST));
+            IReadOnlyList<TimeSeriesTuple> results = await db.TimeSeriesRangeAsync(key, timeStamp, timeStamp);
+            Assert.Equal(1.0, results[0].Val);
+        }
 
         [Fact]
         public async Task TestOldAdd()

NRedisTimeSeries.Test/TestAPI/TestCreate.cs

@@ -1,7 +1,8 @@
-using System;
+using System;
 using System.Collections.Generic;
 using NRedisTimeSeries;
 using NRedisTimeSeries.DataTypes;
+using NRedisTimeSeries.Commands;
 using StackExchange.Redis;
 using Xunit;
 
@@ -63,5 +64,40 @@ public void TestCreateUncompressed()
             IDatabase db = redisFixture.Redis.GetDatabase();
             Assert.True(db.TimeSeriesCreate(key, uncompressed: true));
         }
+
+        [Fact]
+        public void TestCreatehDuplicatePolicyFirst()
+        {
+            IDatabase db = redisFixture.Redis.GetDatabase();
+            Assert.True(db.TimeSeriesCreate(key, policy: TsDuplicatePolicy.FIRST));
+        }
+
+        [Fact]
+        public void TestCreatehDuplicatePolicyLast()
+        {
+            IDatabase db = redisFixture.Redis.GetDatabase();
+            Assert.True(db.TimeSeriesCreate(key, policy: TsDuplicatePolicy.LAST));
+        }
+
+        [Fact]
+        public void TestCreatehDuplicatePolicyMin()
+        {
+            IDatabase db = redisFixture.Redis.GetDatabase();
+            Assert.True(db.TimeSeriesCreate(key, policy: TsDuplicatePolicy.MIN));
+        }
+
+        [Fact]
+        public void TestCreatehDuplicatePolicyMax()
+        {
+            IDatabase db = redisFixture.Redis.GetDatabase();
+            Assert.True(db.TimeSeriesCreate(key, policy: TsDuplicatePolicy.MAX));
+        }
+
+        [Fact]
+        public void TestCreatehDuplicatePolicySum()
+        {
+            IDatabase db = redisFixture.Redis.GetDatabase();
+            Assert.True(db.TimeSeriesCreate(key, policy: TsDuplicatePolicy.SUM));
+        }
     }
 }

NRedisTimeSeries.Test/TestAPI/TestCreateAsync.cs

@@ -1,4 +1,5 @@
-using NRedisTimeSeries.DataTypes;
+using NRedisTimeSeries.DataTypes;
+using NRedisTimeSeries.Commands;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using Xunit;
@@ -61,5 +62,45 @@ public async Task TestCreateUncompressed()
             var db = redisFixture.Redis.GetDatabase();
             Assert.True(await db.TimeSeriesCreateAsync(key, uncompressed: true));
         }
+
+        [Fact]
+        public async void TestCreatehDuplicatePolicyFirst()
+        {
+            var key = CreateKeyName();
+            var db = redisFixture.Redis.GetDatabase();
+            Assert.True(await db.TimeSeriesCreateAsync(key, policy: TsDuplicatePolicy.FIRST));
+        }
+
+        [Fact]
+        public async void TestCreatehDuplicatePolicyLast()
+        {
+            var key = CreateKeyName();
+            var db = redisFixture.Redis.GetDatabase();
+            Assert.True(await db.TimeSeriesCreateAsync(key, policy: TsDuplicatePolicy.LAST));
+        }
+
+        [Fact]
+        public async void TestCreatehDuplicatePolicyMin()
+        {
+            var key = CreateKeyName();
+            var db = redisFixture.Redis.GetDatabase();
+            Assert.True(await db.TimeSeriesCreateAsync(key, policy: TsDuplicatePolicy.MIN));
+        }
+
+        [Fact]
+        public async void TestCreatehDuplicatePolicyMax()
+        {
+            var key = CreateKeyName();
+            var db = redisFixture.Redis.GetDatabase();
+            Assert.True(await db.TimeSeriesCreateAsync(key, policy: TsDuplicatePolicy.MAX));
+        }
+
+        [Fact]
+        public async void TestCreatehDuplicatePolicySum()
+        {
+            var key = CreateKeyName();
+            var db = redisFixture.Redis.GetDatabase();
+            Assert.True(await db.TimeSeriesCreateAsync(key, policy: TsDuplicatePolicy.SUM));
+        }        
     }
 }

NRedisTimeSeries/Commands/CommandArgs.cs

@@ -1,4 +1,4 @@
-namespace NRedisTimeSeries.Commands
+namespace NRedisTimeSeries.Commands
 {
     internal class CommandArgs
     {
@@ -11,5 +11,7 @@ internal class CommandArgs
         public static string WITHLABELS => "WITHLABELS";
         public static string TIMESTAMP => "TIMESTAMP";
         public static string CHUNK_SIZE => "CHUNK_SIZE";
+        public static string DUPLICATE_POLICY => "DUPLICATE_POLICY";
+        public static string ON_DUPLICATE => "ON_DUPLICATE";
     }
 }