Merge pull request #24 from RayTale/develop

u-less · web-flow · commit 37b89fa80a73 · 2020-11-18T22:11:52.000+08:00
Improve storage scalability
diff --git a/src/Storage/Vertex.Storage.Linq2db/Core/EventStorageAttribute.cs b/src/Storage/Vertex.Storage.Linq2db/Core/EventStorageAttribute.cs
@@ -5,33 +5,42 @@
 namespace Vertex.Storage.Linq2db.Core
 {
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
-    public class EventStorageAttribute : Attribute
+    public class EventStorageAttribute : EventStorageBaseAttribute
     {
+        private readonly Func<string, string> shardingFunc;
+        private readonly string optionName;
+
         public EventStorageAttribute(string optionName, string name, int sharding = 0)
         {
             this.Name = name;
-            this.OptionName = optionName;
+            this.optionName = optionName;
             if (sharding < 0)
             {
                 throw new ArgumentOutOfRangeException("sharding must be greater than 0");
             }
 
             if (sharding == 0)
             {
-                this.ShardingFunc = actorId => $"Vertex_Event_{name}".ToLower();
+                this.shardingFunc = actorId => $"Vertex_Event_{name}".ToLower();
             }
             else
             {
                 var tableNames = Enumerable.Range(0, sharding).Select(index => $"Vertex_Event_{name}_{index}".ToLower()).ToList();
                 var hash = new ConsistentHash(tableNames, tableNames.Count * 10);
-                this.ShardingFunc = actorId => hash.GetNode(actorId);
+                this.shardingFunc = actorId => hash.GetNode(actorId);
             }
         }
 
-        public string OptionName { get; init; }
-
         public string Name { get; init; }
 
-        public Func<string, string> ShardingFunc { get; init; }
+        public override string GetTableName(string actorId)
+        {
+            return this.shardingFunc(actorId);
+        }
+
+        public override string GetOptionName(string actorId)
+        {
+            return this.optionName;
+        }
     }
 }
diff --git a/src/Storage/Vertex.Storage.Linq2db/Core/EventStorageBaseAttribute.cs b/src/Storage/Vertex.Storage.Linq2db/Core/EventStorageBaseAttribute.cs
@@ -0,0 +1,12 @@
+﻿using System;
+
+namespace Vertex.Storage.Linq2db.Core
+{
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+    public abstract class EventStorageBaseAttribute : Attribute
+    {
+        public abstract string GetTableName(string actorId);
+
+        public abstract string GetOptionName(string actorId);
+    }
+}
diff --git a/src/Storage/Vertex.Storage.Linq2db/Core/SnapshotStorageAttribute.cs b/src/Storage/Vertex.Storage.Linq2db/Core/SnapshotStorageAttribute.cs
@@ -5,33 +5,42 @@
 namespace Vertex.Storage.Linq2db.Core
 {
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
-    public class SnapshotStorageAttribute : Attribute
+    public class SnapshotStorageAttribute : SnapshotStorageBaseAttribute
     {
+        private readonly Func<string, string> shardingFunc;
+        private readonly string optionName;
+
         public SnapshotStorageAttribute(string optionName, string name, int sharding = 0)
         {
             this.Name = name;
-            this.OptionName = optionName;
+            this.optionName = optionName;
             if (sharding < 0)
             {
                 throw new ArgumentOutOfRangeException("sharding must be greater than 0");
             }
 
             if (sharding == 0)
             {
-                this.ShardingFunc = actorId => $"Vertex_Snapshot_{name}".ToLower();
+                this.shardingFunc = actorId => $"Vertex_Snapshot_{name}".ToLower();
             }
             else
             {
                 var tableNames = Enumerable.Range(0, sharding).Select(index => $"Vertex_Snapshot_{name}_{index}".ToLower()).ToList();
                 var hash = new ConsistentHash(tableNames, tableNames.Count * 10);
-                this.ShardingFunc = actorId => hash.GetNode(actorId);
+                this.shardingFunc = actorId => hash.GetNode(actorId);
             }
         }
 
-        public string OptionName { get; init; }
-
         public string Name { get; init; }
 
-        public Func<string, string> ShardingFunc { get; init; }
+        public override string GetOptionName(string actorId)
+        {
+            return this.optionName;
+        }
+
+        public override string GetTableName(string actorId)
+        {
+            return this.shardingFunc(actorId);
+        }
     }
 }
diff --git a/src/Storage/Vertex.Storage.Linq2db/Core/SnapshotStorageBaseAttribute.cs b/src/Storage/Vertex.Storage.Linq2db/Core/SnapshotStorageBaseAttribute.cs
@@ -0,0 +1,12 @@
+﻿using System;
+
+namespace Vertex.Storage.Linq2db.Core
+{
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+    public abstract class SnapshotStorageBaseAttribute : Attribute
+    {
+        public abstract string GetTableName(string actorId);
+
+        public abstract string GetOptionName(string actorId);
+    }
+}
diff --git a/src/Storage/Vertex.Storage.Linq2db/Core/TxEventStorageAttribute.cs b/src/Storage/Vertex.Storage.Linq2db/Core/TxEventStorageAttribute.cs
@@ -5,33 +5,42 @@
 namespace Vertex.Storage.Linq2db.Core
 {
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
-    public class TxEventStorageAttribute : Attribute
+    public class TxEventStorageAttribute : TxEventStorageBaseAttribute
     {
+        private readonly Func<string, string> shardingFunc;
+        private readonly string optionName;
+
         public TxEventStorageAttribute(string optionName, string name, int sharding = 0)
         {
             this.Name = name;
-            this.OptionName = optionName;
+            this.optionName = optionName;
             if (sharding < 0)
             {
                 throw new ArgumentOutOfRangeException("sharding must be greater than 0");
             }
 
             if (sharding == 0)
             {
-                this.ShardingFunc = actorId => $"Vertex_TxEvent_{name}".ToLower();
+                this.shardingFunc = actorId => $"Vertex_TxEvent_{name}".ToLower();
             }
             else
             {
                 var tableNames = Enumerable.Range(0, sharding).Select(index => $"Vertex_TxEvent_{name}_{index}".ToLower()).ToList();
                 var hash = new ConsistentHash(tableNames, tableNames.Count * 10);
-                this.ShardingFunc = actorId => hash.GetNode(actorId);
+                this.shardingFunc = actorId => hash.GetNode(actorId);
             }
         }
 
-        public string OptionName { get; init; }
-
         public string Name { get; init; }
 
-        public Func<string, string> ShardingFunc { get; init; }
+        public override string GetOptionName(string actorId)
+        {
+            return this.optionName;
+        }
+
+        public override string GetTableName(string actorId)
+        {
+            return this.shardingFunc(actorId);
+        }
     }
 }
diff --git a/src/Storage/Vertex.Storage.Linq2db/Core/TxEventStorageBaseAttribute.cs b/src/Storage/Vertex.Storage.Linq2db/Core/TxEventStorageBaseAttribute.cs
@@ -0,0 +1,12 @@
+﻿using System;
+
+namespace Vertex.Storage.Linq2db.Core
+{
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+    public abstract class TxEventStorageBaseAttribute : Attribute
+    {
+        public abstract string GetTableName(string actorId);
+
+        public abstract string GetOptionName(string actorId);
+    }
+}
diff --git a/src/Storage/Vertex.Storage.Linq2db/Storage/EventStorage.cs b/src/Storage/Vertex.Storage.Linq2db/Storage/EventStorage.cs
@@ -1,7 +1,6 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using LinqToDB;
 using LinqToDB.Data;
diff --git a/src/Storage/Vertex.Storage.Linq2db/Storage/Factory/EventStorageFactory.cs b/src/Storage/Vertex.Storage.Linq2db/Storage/Factory/EventStorageFactory.cs
@@ -16,8 +16,8 @@ namespace Vertex.Storage.Linq2db.Storage
 {
     public class EventStorageFactory : IEventStorageFactory
     {
-        private readonly ConcurrentDictionary<Type, EventStorageAttribute> typeAttributes = new ConcurrentDictionary<Type, EventStorageAttribute>();
-        private readonly ConcurrentDictionary<string, Lazy<Task<object>>> eventStorageDict = new ConcurrentDictionary<string, Lazy<Task<object>>>();
+        private readonly ConcurrentDictionary<Type, EventStorageBaseAttribute> typeAttributes = new();
+        private readonly ConcurrentDictionary<string, Lazy<Task<object>>> eventStorageDict = new();
         private readonly DbFactory dbFactory;
         private readonly IGrainFactory grainFactory;
         private readonly IServiceProvider serviceProvider;
@@ -33,28 +33,31 @@ public async ValueTask<IEventStorage<TPrimaryKey>> Create<TPrimaryKey>(IActor<TP
         {
             var attribute = this.typeAttributes.GetOrAdd(actor.GetType(), key =>
             {
-                var attributes = key.GetCustomAttributes(typeof(EventStorageAttribute), false);
-                if (attributes.Length > 0)
+                var attributes = key.GetCustomAttributes(false);
+                var attribute = attributes.SingleOrDefault(att => typeof(EventStorageBaseAttribute).IsAssignableFrom(att.GetType()));
+                if (attribute != default)
                 {
-                    return attributes.First() as EventStorageAttribute;
+                    return attribute as EventStorageBaseAttribute;
                 }
                 else
                 {
-                    throw new MissingAttributeException($"{nameof(EventStorageAttribute)}=>{key.Name}");
+                    throw new MissingAttributeException($"{nameof(EventStorageBaseAttribute)}=>{key.Name}");
                 }
             });
-            var tableName = attribute.ShardingFunc(actor.ActorId.ToString());
-            var storage = await this.eventStorageDict.GetOrAdd($"{attribute.OptionName}_{tableName}", key =>
+            var actorId = actor.ActorId.ToString();
+            var tableName = attribute.GetTableName(actorId);
+            var optionName = attribute.GetOptionName(actorId);
+            var storage = await this.eventStorageDict.GetOrAdd($"{optionName}_{tableName}", key =>
               new Lazy<Task<object>>(async () =>
               {
-                  using var db = this.dbFactory.GetEventDb(attribute.OptionName);
+                  using var db = this.dbFactory.GetEventDb(optionName);
                   await db.CreateTableIfNotExists<EventEntity<TPrimaryKey>>(this.grainFactory, key, tableName, async () =>
                   {
                       var indexGenerator = db.GetGenerator();
                       await indexGenerator.CreateUniqueIndexIfNotExists(db, tableName, $"{tableName}_event_unique", nameof(EventEntity<TPrimaryKey>.ActorId).ToLower(), nameof(EventEntity<TPrimaryKey>.Version).ToLower());
                       await indexGenerator.CreateUniqueIndexIfNotExists(db, tableName, $"{tableName}_event_flow_unique", nameof(EventEntity<TPrimaryKey>.ActorId).ToLower(), nameof(EventEntity<TPrimaryKey>.Name).ToLower(), nameof(EventEntity<TPrimaryKey>.FlowId).ToLower());
                   });
-                  return new EventStorage<TPrimaryKey>(this.serviceProvider, this.dbFactory, attribute.OptionName, tableName);
+                  return new EventStorage<TPrimaryKey>(this.serviceProvider, this.dbFactory, optionName, tableName);
               })).Value;
             return storage as IEventStorage<TPrimaryKey>;
         }
diff --git a/src/Storage/Vertex.Storage.Linq2db/Storage/Factory/SnapshotStorageFactory.cs b/src/Storage/Vertex.Storage.Linq2db/Storage/Factory/SnapshotStorageFactory.cs
@@ -14,8 +14,8 @@ namespace Vertex.Storage.Linq2db.Storage
 {
     public class SnapshotStorageFactory : ISnapshotStorageFactory
     {
-        private readonly ConcurrentDictionary<Type, SnapshotStorageAttribute> typeAttributes = new ConcurrentDictionary<Type, SnapshotStorageAttribute>();
-        private readonly ConcurrentDictionary<string, Lazy<Task<object>>> eventStorageDict = new ConcurrentDictionary<string, Lazy<Task<object>>>();
+        private readonly ConcurrentDictionary<Type, SnapshotStorageBaseAttribute> typeAttributes = new();
+        private readonly ConcurrentDictionary<string, Lazy<Task<object>>> eventStorageDict = new();
         private readonly DbFactory dbFactory;
         private readonly IGrainFactory grainFactory;
         private readonly IServiceProvider serviceProvider;
@@ -31,23 +31,26 @@ public async ValueTask<ISnapshotStorage<TPrimaryKey>> Create<TPrimaryKey>(IActor
         {
             var attribute = this.typeAttributes.GetOrAdd(actor.GetType(), key =>
             {
-                var attributes = key.GetCustomAttributes(typeof(SnapshotStorageAttribute), false);
-                if (attributes.Length > 0)
+                var attributes = key.GetCustomAttributes(false);
+                var attribute = attributes.SingleOrDefault(att => typeof(SnapshotStorageBaseAttribute).IsAssignableFrom(att.GetType()));
+                if (attribute != default)
                 {
-                    return attributes.First() as SnapshotStorageAttribute;
+                    return attribute as SnapshotStorageBaseAttribute;
                 }
                 else
                 {
-                    throw new MissingAttributeException($"{nameof(SnapshotStorageAttribute)}=>{key.Name}");
+                    throw new MissingAttributeException($"{nameof(SnapshotStorageBaseAttribute)}=>{key.Name}");
                 }
             });
-            var tableName = attribute.ShardingFunc(actor.ActorId.ToString());
-            var storage = await this.eventStorageDict.GetOrAdd($"{attribute.OptionName}_{tableName}", key =>
+            var actorId = actor.ActorId.ToString();
+            var tableName = attribute.GetTableName(actorId);
+            var optionName = attribute.GetOptionName(actorId);
+            var storage = await this.eventStorageDict.GetOrAdd($"{optionName}_{tableName}", key =>
             new Lazy<Task<object>>(async () =>
            {
-               using var db = this.dbFactory.GetEventDb(attribute.OptionName);
+               using var db = this.dbFactory.GetEventDb(optionName);
                await db.CreateTableIfNotExists<SnapshotEntity<TPrimaryKey>>(this.grainFactory, key, tableName);
-               return new SnapshotStorage<TPrimaryKey>(this.serviceProvider, this.dbFactory, attribute.OptionName, tableName);
+               return new SnapshotStorage<TPrimaryKey>(this.serviceProvider, this.dbFactory, optionName, tableName);
            })).Value;
 
             return storage as ISnapshotStorage<TPrimaryKey>;
diff --git a/src/Storage/Vertex.Storage.Linq2db/Storage/Factory/SubSnapshotStorageFactory.cs b/src/Storage/Vertex.Storage.Linq2db/Storage/Factory/SubSnapshotStorageFactory.cs
@@ -14,8 +14,8 @@ namespace Vertex.Storage.Linq2db.Storage
 {
     public class SubSnapshotStorageFactory : ISubSnapshotStorageFactory
     {
-        private readonly ConcurrentDictionary<Type, SnapshotStorageAttribute> typeAttributes = new ConcurrentDictionary<Type, SnapshotStorageAttribute>();
-        private readonly ConcurrentDictionary<string, Lazy<Task<object>>> eventStorageDict = new ConcurrentDictionary<string, Lazy<Task<object>>>();
+        private readonly ConcurrentDictionary<Type, SnapshotStorageBaseAttribute> typeAttributes = new();
+        private readonly ConcurrentDictionary<string, Lazy<Task<object>>> eventStorageDict = new();
         private readonly DbFactory dbFactory;
         private readonly IGrainFactory grainFactory;
         private readonly IServiceProvider serviceProvider;
@@ -31,23 +31,26 @@ public async ValueTask<ISubSnapshotStorage<TPrimaryKey>> Create<TPrimaryKey>(IAc
         {
             var attribute = this.typeAttributes.GetOrAdd(actor.GetType(), key =>
             {
-                var attributes = key.GetCustomAttributes(typeof(SnapshotStorageAttribute), false);
-                if (attributes.Length > 0)
+                var attributes = key.GetCustomAttributes(false);
+                var attribute = attributes.SingleOrDefault(att => typeof(SnapshotStorageBaseAttribute).IsAssignableFrom(att.GetType()));
+                if (attribute != default)
                 {
-                    return attributes.First() as SnapshotStorageAttribute;
+                    return attribute as SnapshotStorageBaseAttribute;
                 }
                 else
                 {
-                    throw new MissingAttributeException($"{nameof(SnapshotStorageAttribute)}=>{key.Name}");
+                    throw new MissingAttributeException($"{nameof(SnapshotStorageBaseAttribute)}=>{key.Name}");
                 }
             });
-            var tableName = attribute.ShardingFunc(actor.ActorId.ToString());
-            var storage = await this.eventStorageDict.GetOrAdd($"{attribute.OptionName}_{tableName}", key =>
+            var actorId = actor.ActorId.ToString();
+            var tableName = attribute.GetTableName(actorId);
+            var optionName = attribute.GetOptionName(actorId);
+            var storage = await this.eventStorageDict.GetOrAdd($"{optionName}_{tableName}", key =>
              new Lazy<Task<object>>(async () =>
              {
-                 using var db = this.dbFactory.GetEventDb(attribute.OptionName);
+                 using var db = this.dbFactory.GetEventDb(optionName);
                  await db.CreateTableIfNotExists<SubSnapshotEntity<TPrimaryKey>>(this.grainFactory, key, tableName);
-                 return new SubSnapshotStorage<TPrimaryKey>(this.serviceProvider, this.dbFactory, attribute.OptionName, tableName);
+                 return new SubSnapshotStorage<TPrimaryKey>(this.serviceProvider, this.dbFactory, optionName, tableName);
              })).Value;
 
             return storage as ISubSnapshotStorage<TPrimaryKey>;
diff --git a/src/Storage/Vertex.Storage.Linq2db/Storage/Factory/TxEventStorageFactory.cs b/src/Storage/Vertex.Storage.Linq2db/Storage/Factory/TxEventStorageFactory.cs
@@ -15,8 +15,8 @@ namespace Vertex.Storage.Linq2db.Storage
 {
     public class TxEventStorageFactory : ITxEventStorageFactory
     {
-        private readonly ConcurrentDictionary<Type, TxEventStorageAttribute> typeAttributes = new ConcurrentDictionary<Type, TxEventStorageAttribute>();
-        private readonly ConcurrentDictionary<string, Lazy<Task<object>>> eventStorageDict = new ConcurrentDictionary<string, Lazy<Task<object>>>();
+        private readonly ConcurrentDictionary<Type, TxEventStorageBaseAttribute> typeAttributes = new();
+        private readonly ConcurrentDictionary<string, Lazy<Task<object>>> eventStorageDict = new();
         private readonly DbFactory dbFactory;
         private readonly IGrainFactory grainFactory;
         private readonly IServiceProvider serviceProvider;
@@ -32,28 +32,31 @@ public async ValueTask<ITxEventStorage<TPrimaryKey>> Create<TPrimaryKey>(IActor<
         {
             var attribute = this.typeAttributes.GetOrAdd(actor.GetType(), key =>
             {
-                var attributes = key.GetCustomAttributes(typeof(TxEventStorageAttribute), false);
-                if (attributes.Length > 0)
+                var attributes = key.GetCustomAttributes(false);
+                var attribute = attributes.SingleOrDefault(att => typeof(TxEventStorageBaseAttribute).IsAssignableFrom(att.GetType()));
+                if (attribute != default)
                 {
-                    return attributes.First() as TxEventStorageAttribute;
+                    return attribute as TxEventStorageBaseAttribute;
                 }
                 else
                 {
-                    throw new MissingAttributeException($"{nameof(TxEventStorageAttribute)}=>{key.Name}");
+                    throw new MissingAttributeException($"{nameof(TxEventStorageBaseAttribute)}=>{key.Name}");
                 }
             });
-            var tableName = attribute.ShardingFunc(actor.ActorId.ToString());
-            var storage = await this.eventStorageDict.GetOrAdd($"{attribute.OptionName}_{tableName}", key =>
+            var actorId = actor.ActorId.ToString();
+            var tableName = attribute.GetTableName(actorId);
+            var optionName = attribute.GetOptionName(actorId);
+            var storage = await this.eventStorageDict.GetOrAdd($"{optionName}_{tableName}", key =>
             new Lazy<Task<object>>(async () =>
             {
-                using var db = this.dbFactory.GetEventDb(attribute.OptionName);
+                using var db = this.dbFactory.GetEventDb(optionName);
                 await db.CreateTableIfNotExists<EventEntity<TPrimaryKey>>(this.grainFactory, key, tableName, async () =>
                 {
                     var indexGenerator = db.GetGenerator();
                     await indexGenerator.CreateUniqueIndexIfNotExists(db, tableName, $"{tableName}_event_unique", nameof(EventEntity<TPrimaryKey>.ActorId).ToLower(), nameof(EventEntity<TPrimaryKey>.Version).ToLower());
                     await indexGenerator.CreateUniqueIndexIfNotExists(db, tableName, $"{tableName}_event_flow_unique", nameof(EventEntity<TPrimaryKey>.ActorId).ToLower(), nameof(EventEntity<TPrimaryKey>.Name).ToLower(), nameof(EventEntity<TPrimaryKey>.FlowId).ToLower());
                 });
-                return new TxEventStorage<TPrimaryKey>(this.serviceProvider, this.dbFactory, attribute.OptionName, tableName);
+                return new TxEventStorage<TPrimaryKey>(this.serviceProvider, this.dbFactory, optionName, tableName);
             })).Value;
 
             return storage as ITxEventStorage<TPrimaryKey>;
diff --git a/src/Vertex.Runtime/Snapshot/SnapshotHandlerBase.cs b/src/Vertex.Runtime/Snapshot/SnapshotHandlerBase.cs

Original file line number	Diff line number	Diff line change
`@@ -5,33 +5,42 @@`
`5`	`5`	`namespace Vertex.Storage.Linq2db.Core`
`6`	`6`	`{`
`7`	`7`	`[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]`
`8`		`- public class EventStorageAttribute : Attribute`
	`8`	`+ public class EventStorageAttribute : EventStorageBaseAttribute`
`9`	`9`	`{`
	`10`	`+ private readonly Func<string, string> shardingFunc;`
	`11`	`+ private readonly string optionName;`
	`12`	`+`
`10`	`13`	`public EventStorageAttribute(string optionName, string name, int sharding = 0)`
`11`	`14`	`{`
`12`	`15`	`this.Name = name;`
`13`		`- this.OptionName = optionName;`
	`16`	`+ this.optionName = optionName;`
`14`	`17`	`if (sharding < 0)`
`15`	`18`	`{`
`16`	`19`	`throw new ArgumentOutOfRangeException("sharding must be greater than 0");`
`17`	`20`	`}`
`18`	`21`
`19`	`22`	`if (sharding == 0)`
`20`	`23`	`{`
`21`		`- this.ShardingFunc = actorId => $"Vertex_Event_{name}".ToLower();`
	`24`	`+ this.shardingFunc = actorId => $"Vertex_Event_{name}".ToLower();`
`22`	`25`	`}`
`23`	`26`	`else`
`24`	`27`	`{`
`25`	`28`	`var tableNames = Enumerable.Range(0, sharding).Select(index => $"Vertex_Event_{name}_{index}".ToLower()).ToList();`
`26`	`29`	`var hash = new ConsistentHash(tableNames, tableNames.Count * 10);`
`27`		`- this.ShardingFunc = actorId => hash.GetNode(actorId);`
	`30`	`+ this.shardingFunc = actorId => hash.GetNode(actorId);`
`28`	`31`	`}`
`29`	`32`	`}`
`30`	`33`
`31`		`- public string OptionName { get; init; }`
`32`		`-`
`33`	`34`	`public string Name { get; init; }`
`34`	`35`
`35`		`- public Func<string, string> ShardingFunc { get; init; }`
	`36`	`+ public override string GetTableName(string actorId)`
	`37`	`+ {`
	`38`	`+ return this.shardingFunc(actorId);`
	`39`	`+ }`
	`40`	`+`
	`41`	`+ public override string GetOptionName(string actorId)`
	`42`	`+ {`
	`43`	`+ return this.optionName;`
	`44`	`+ }`
`36`	`45`	`}`
`37`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,8 +16,8 @@ namespace Vertex.Storage.Linq2db.Storage`
`16`	`16`	`{`
`17`	`17`	`public class EventStorageFactory : IEventStorageFactory`
`18`	`18`	`{`
`19`		`- private readonly ConcurrentDictionary<Type, EventStorageAttribute> typeAttributes = new ConcurrentDictionary<Type, EventStorageAttribute>();`
`20`		`- private readonly ConcurrentDictionary<string, Lazy<Task<object>>> eventStorageDict = new ConcurrentDictionary<string, Lazy<Task<object>>>();`
	`19`	`+ private readonly ConcurrentDictionary<Type, EventStorageBaseAttribute> typeAttributes = new();`
	`20`	`+ private readonly ConcurrentDictionary<string, Lazy<Task<object>>> eventStorageDict = new();`
`21`	`21`	`private readonly DbFactory dbFactory;`
`22`	`22`	`private readonly IGrainFactory grainFactory;`
`23`	`23`	`private readonly IServiceProvider serviceProvider;`
`@@ -33,28 +33,31 @@ public async ValueTask<IEventStorage<TPrimaryKey>> Create<TPrimaryKey>(IActor<TP`
`33`	`33`	`{`
`34`	`34`	`var attribute = this.typeAttributes.GetOrAdd(actor.GetType(), key =>`
`35`	`35`	`{`
`36`		`- var attributes = key.GetCustomAttributes(typeof(EventStorageAttribute), false);`
`37`		`- if (attributes.Length > 0)`
	`36`	`+ var attributes = key.GetCustomAttributes(false);`
	`37`	`+ var attribute = attributes.SingleOrDefault(att => typeof(EventStorageBaseAttribute).IsAssignableFrom(att.GetType()));`
	`38`	`+ if (attribute != default)`
`38`	`39`	`{`
`39`		`- return attributes.First() as EventStorageAttribute;`
	`40`	`+ return attribute as EventStorageBaseAttribute;`
`40`	`41`	`}`
`41`	`42`	`else`
`42`	`43`	`{`
`43`		`- throw new MissingAttributeException($"{nameof(EventStorageAttribute)}=>{key.Name}");`
	`44`	`+ throw new MissingAttributeException($"{nameof(EventStorageBaseAttribute)}=>{key.Name}");`
`44`	`45`	`}`
`45`	`46`	`});`
`46`		`- var tableName = attribute.ShardingFunc(actor.ActorId.ToString());`
`47`		`- var storage = await this.eventStorageDict.GetOrAdd($"{attribute.OptionName}_{tableName}", key =>`
	`47`	`+ var actorId = actor.ActorId.ToString();`
	`48`	`+ var tableName = attribute.GetTableName(actorId);`
	`49`	`+ var optionName = attribute.GetOptionName(actorId);`
	`50`	`+ var storage = await this.eventStorageDict.GetOrAdd($"{optionName}_{tableName}", key =>`
`48`	`51`	`new Lazy<Task<object>>(async () =>`
`49`	`52`	`{`
`50`		`- using var db = this.dbFactory.GetEventDb(attribute.OptionName);`
	`53`	`+ using var db = this.dbFactory.GetEventDb(optionName);`
`51`	`54`	`await db.CreateTableIfNotExists<EventEntity<TPrimaryKey>>(this.grainFactory, key, tableName, async () =>`
`52`	`55`	`{`
`53`	`56`	`var indexGenerator = db.GetGenerator();`
`54`	`57`	`await indexGenerator.CreateUniqueIndexIfNotExists(db, tableName, $"{tableName}_event_unique", nameof(EventEntity<TPrimaryKey>.ActorId).ToLower(), nameof(EventEntity<TPrimaryKey>.Version).ToLower());`
`55`	`58`	`await indexGenerator.CreateUniqueIndexIfNotExists(db, tableName, $"{tableName}_event_flow_unique", nameof(EventEntity<TPrimaryKey>.ActorId).ToLower(), nameof(EventEntity<TPrimaryKey>.Name).ToLower(), nameof(EventEntity<TPrimaryKey>.FlowId).ToLower());`
`56`	`59`	`});`
`57`		`- return new EventStorage<TPrimaryKey>(this.serviceProvider, this.dbFactory, attribute.OptionName, tableName);`
	`60`	`+ return new EventStorage<TPrimaryKey>(this.serviceProvider, this.dbFactory, optionName, tableName);`
`58`	`61`	`})).Value;`
`59`	`62`	`return storage as IEventStorage<TPrimaryKey>;`
`60`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,8 @@ namespace Vertex.Storage.Linq2db.Storage`
`14`	`14`	`{`
`15`	`15`	`public class SnapshotStorageFactory : ISnapshotStorageFactory`
`16`	`16`	`{`
`17`		`- private readonly ConcurrentDictionary<Type, SnapshotStorageAttribute> typeAttributes = new ConcurrentDictionary<Type, SnapshotStorageAttribute>();`
`18`		`- private readonly ConcurrentDictionary<string, Lazy<Task<object>>> eventStorageDict = new ConcurrentDictionary<string, Lazy<Task<object>>>();`
	`17`	`+ private readonly ConcurrentDictionary<Type, SnapshotStorageBaseAttribute> typeAttributes = new();`
	`18`	`+ private readonly ConcurrentDictionary<string, Lazy<Task<object>>> eventStorageDict = new();`
`19`	`19`	`private readonly DbFactory dbFactory;`
`20`	`20`	`private readonly IGrainFactory grainFactory;`
`21`	`21`	`private readonly IServiceProvider serviceProvider;`
`@@ -31,23 +31,26 @@ public async ValueTask<ISnapshotStorage<TPrimaryKey>> Create<TPrimaryKey>(IActor`
`31`	`31`	`{`
`32`	`32`	`var attribute = this.typeAttributes.GetOrAdd(actor.GetType(), key =>`
`33`	`33`	`{`
`34`		`- var attributes = key.GetCustomAttributes(typeof(SnapshotStorageAttribute), false);`
`35`		`- if (attributes.Length > 0)`
	`34`	`+ var attributes = key.GetCustomAttributes(false);`
	`35`	`+ var attribute = attributes.SingleOrDefault(att => typeof(SnapshotStorageBaseAttribute).IsAssignableFrom(att.GetType()));`
	`36`	`+ if (attribute != default)`
`36`	`37`	`{`
`37`		`- return attributes.First() as SnapshotStorageAttribute;`
	`38`	`+ return attribute as SnapshotStorageBaseAttribute;`
`38`	`39`	`}`
`39`	`40`	`else`
`40`	`41`	`{`
`41`		`- throw new MissingAttributeException($"{nameof(SnapshotStorageAttribute)}=>{key.Name}");`
	`42`	`+ throw new MissingAttributeException($"{nameof(SnapshotStorageBaseAttribute)}=>{key.Name}");`
`42`	`43`	`}`
`43`	`44`	`});`
`44`		`- var tableName = attribute.ShardingFunc(actor.ActorId.ToString());`
`45`		`- var storage = await this.eventStorageDict.GetOrAdd($"{attribute.OptionName}_{tableName}", key =>`
	`45`	`+ var actorId = actor.ActorId.ToString();`
	`46`	`+ var tableName = attribute.GetTableName(actorId);`
	`47`	`+ var optionName = attribute.GetOptionName(actorId);`
	`48`	`+ var storage = await this.eventStorageDict.GetOrAdd($"{optionName}_{tableName}", key =>`
`46`	`49`	`new Lazy<Task<object>>(async () =>`
`47`	`50`	`{`
`48`		`- using var db = this.dbFactory.GetEventDb(attribute.OptionName);`
	`51`	`+ using var db = this.dbFactory.GetEventDb(optionName);`
`49`	`52`	`await db.CreateTableIfNotExists<SnapshotEntity<TPrimaryKey>>(this.grainFactory, key, tableName);`
`50`		`- return new SnapshotStorage<TPrimaryKey>(this.serviceProvider, this.dbFactory, attribute.OptionName, tableName);`
	`53`	`+ return new SnapshotStorage<TPrimaryKey>(this.serviceProvider, this.dbFactory, optionName, tableName);`
`51`	`54`	`})).Value;`
`52`	`55`
`53`	`56`	`return storage as ISnapshotStorage<TPrimaryKey>;`