Change DeleteAll to use SSCAN to page through data instead of pulling all keys into memory all at once. This will reduce memory, but make the command chatty for very large typed sets.

Author: Layoric

src/ServiceStack.Redis/Generic/RedisTypedClient.Async.cs

@@ -131,13 +131,24 @@ async Task IEntityStoreAsync<T>.DeleteByIdsAsync(IEnumerable ids, CancellationTo
 
         async Task IEntityStoreAsync<T>.DeleteAllAsync(CancellationToken token)
         {
-            var ids = await AsyncClient.GetAllItemsFromSetAsync(this.TypeIdsSetKey, token).ConfigureAwait(false);
+            await DeleteAllAsync(0,1000, token).ConfigureAwait(false);
+        }
+
+        private async Task DeleteAllAsync(ulong cursor, int pageSize, CancellationToken token)
+        {
+            var scanResult = await AsyncNative.SScanAsync(this.TypeIdsSetKey, cursor, pageSize, token: token).ConfigureAwait(false);
+            var lastCursor = scanResult.Cursor;
+            var ids = scanResult.Results.Select(x => Encoding.UTF8.GetString(x)).ToList();
             var urnKeys = ids.Map(t => client.UrnKey<T>(t));
             if (urnKeys.Count > 0)
             {
                 await AsyncClient.RemoveEntryAsync(urnKeys.ToArray(), token).ConfigureAwait(false);
-                await AsyncClient.RemoveEntryAsync(new[] { this.TypeIdsSetKey }, token).ConfigureAwait(false);
             }
+
+            if (lastCursor != 0)
+                await DeleteAllAsync(lastCursor, pageSize, token).ConfigureAwait(false);
+            else
+                await AsyncClient.RemoveEntryAsync(new[] { this.TypeIdsSetKey }, token).ConfigureAwait(false);
         }
 
         async ValueTask<List<T>> IRedisTypedClientAsync<T>.GetValuesAsync(List<string> keys, CancellationToken token)

src/ServiceStack.Redis/Generic/RedisTypedClient.cs

@@ -466,16 +466,25 @@ public void DeleteByIds(IEnumerable ids)
             }
         }
 
-        public void DeleteAll()
+        private void DeleteAll(ulong cursor, int pageSize)
         {
-            var ids = client.GetAllItemsFromSet(this.TypeIdsSetKey);
+            var scanResult = client.SScan(this.TypeIdsSetKey, cursor, pageSize);
+            var resultCursor = scanResult.Cursor;
+            var ids = scanResult.Results.Select(x => Encoding.UTF8.GetString(x)).ToList();
             var urnKeys = ids.Map(t => client.UrnKey<T>(t));
             if (urnKeys.Count > 0)
             {
-
                 this.RemoveEntry(urnKeys.ToArray());
-                this.RemoveEntry(this.TypeIdsSetKey);
             }
+            if(resultCursor != 0)
+                DeleteAll(resultCursor,1000);
+            else
+                this.RemoveEntry(this.TypeIdsSetKey);
+        }
+        
+        public void DeleteAll()
+        {
+            DeleteAll(0,1000);
         }
 
         #endregion

src/ServiceStack.Redis/RedisClient.Async.cs

@@ -658,15 +658,26 @@ async Task IEntityStoreAsync.DeleteByIdsAsync<T>(ICollection ids, CancellationTo
         }
 
         async Task IEntityStoreAsync.DeleteAllAsync<T>(CancellationToken token)
+        {
+            await DeleteAllAsync<T>(0, 1000, token).ConfigureAwait(false);
+        }
+        
+        private async Task DeleteAllAsync<T>(ulong cursor, int pageSize, CancellationToken token)
         {
             var typeIdsSetKey = this.GetTypeIdsSetKey<T>();
-            var ids = await AsAsync().GetAllItemsFromSetAsync(typeIdsSetKey, token).ConfigureAwait(false);
-            if (ids.Count > 0)
+            var scanResult = await NativeAsync.SScanAsync(typeIdsSetKey, cursor, pageSize, token: token).ConfigureAwait(false);
+            var lastCursor = scanResult.Cursor;
+            var ids = scanResult.Results.Select(x => x.FromUtf8Bytes());
+            var urnKeys = ids.Map(t => AsAsync().UrnKey<T>(t));
+            if (urnKeys.Count > 0)
             {
-                var urnKeys = ids.ToList().ConvertAll(UrnKey<T>);
                 await AsAsync().RemoveEntryAsync(urnKeys.ToArray(), token).ConfigureAwait(false);
-                await AsAsync().RemoveAsync(typeIdsSetKey, token).ConfigureAwait(false);
             }
+
+            if (lastCursor != 0)
+                await DeleteAllAsync<T>(lastCursor, pageSize, token).ConfigureAwait(false);
+            else
+                await AsAsync().RemoveEntryAsync(new[] { typeIdsSetKey }, token).ConfigureAwait(false);
         }
 
         ValueTask<List<string>> IRedisClientAsync.SearchSortedSetAsync(string setId, string start, string end, int? skip, int? take, CancellationToken token)

src/ServiceStack.Redis/RedisClient.cs

@@ -830,15 +830,25 @@ public void DeleteByIds<T>(ICollection ids)
         }
 
         public void DeleteAll<T>()
+        {
+            DeleteAll<T>(0,1000);
+        }
+
+        private void DeleteAll<T>(ulong cursor, int pageSize)
         {
             var typeIdsSetKey = this.GetTypeIdsSetKey<T>();
-            var ids = this.GetAllItemsFromSet(typeIdsSetKey);
-            if (ids.Count > 0)
+            var scanResult = this.SScan(typeIdsSetKey, cursor, pageSize);
+            var resultCursor = scanResult.Cursor;
+            var ids = scanResult.Results.Select(x => x.FromUtf8Bytes());
+            var urnKeys = ids.Map(t => this.UrnKey(t));
+            if (urnKeys.Count > 0)
             {
-                var urnKeys = ids.ToList().ConvertAll(UrnKey<T>);
                 this.RemoveEntry(urnKeys.ToArray());
-                this.Remove(typeIdsSetKey);
             }
+            if(resultCursor != 0)
+                DeleteAll<T>(resultCursor, 1000);
+            else
+                this.RemoveEntry(typeIdsSetKey);
         }
 
         public RedisClient CloneClient()