Autotest
/
sharding
mirror of https://gitee.com/dotnetchina/sharding-core.git
1
0
Fork 0
Code Issues Releases Wiki Activity

完成大部分重构

This commit is contained in:
xuejiaming 2022-07-01 17:46:49 +08:00
parent fea8e9a781
commit a288c517ba
45 changed files with 967 additions and 833 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/ShardingCore/Bootstrappers/EntityMetadataInitializer.cs
View File

@ -44,14 +44,16 @@ namespace ShardingCore.Bootstrappers
// private readonly string _virtualTableName; // private readonly string _virtualTableName;
// private readonly Expression<Func<TEntity,bool>> _queryFilterExpression; // private readonly Expression<Func<TEntity,bool>> _queryFilterExpression;
private readonly Type _shardingEntityType; private readonly Type _shardingEntityType;
private readonly IShardingEntityConfigOptions _shardingEntityConfigOptions; private readonly IShardingProvider _shardingProvider;
private readonly IShardingRouteConfigOptions _shardingRouteConfigOptions;
private readonly IVirtualDataSourceRouteManager _virtualDataSourceRouteManager; private readonly IVirtualDataSourceRouteManager _virtualDataSourceRouteManager;
private readonly ITableRouteManager _tableRouteManager; private readonly ITableRouteManager _tableRouteManager;
private readonly IEntityMetadataManager _entityMetadataManager; private readonly IEntityMetadataManager _entityMetadataManager;
private readonly IJobManager _jobManager; private readonly IJobManager _jobManager;
public EntityMetadataInitializer( public EntityMetadataInitializer(
IShardingEntityConfigOptions shardingEntityConfigOptions, IShardingProvider shardingProvider,
IShardingRouteConfigOptions shardingRouteConfigOptions,
IVirtualDataSourceRouteManager virtualDataSourceRouteManager, IVirtualDataSourceRouteManager virtualDataSourceRouteManager,
ITableRouteManager tableRouteManager, ITableRouteManager tableRouteManager,
IEntityMetadataManager entityMetadataManager, IEntityMetadataManager entityMetadataManager,
@ -62,7 +64,8 @@ namespace ShardingCore.Bootstrappers
// _entityType = entityMetadataEnsureParams.EntityType; // _entityType = entityMetadataEnsureParams.EntityType;
// _virtualTableName = entityMetadataEnsureParams.VirtualTableName; // _virtualTableName = entityMetadataEnsureParams.VirtualTableName;
// _queryFilterExpression = entityMetadataEnsureParams.EntityType.GetAnnotations().FirstOrDefault(o=>o.Name== QueryFilter)?.Value as Expression<Func<TEntity, bool>>; // _queryFilterExpression = entityMetadataEnsureParams.EntityType.GetAnnotations().FirstOrDefault(o=>o.Name== QueryFilter)?.Value as Expression<Func<TEntity, bool>>;
_shardingEntityConfigOptions = shardingEntityConfigOptions; _shardingProvider = shardingProvider;
_shardingRouteConfigOptions = shardingRouteConfigOptions;
_virtualDataSourceRouteManager = virtualDataSourceRouteManager; _virtualDataSourceRouteManager = virtualDataSourceRouteManager;
_tableRouteManager = tableRouteManager; _tableRouteManager = tableRouteManager;
_entityMetadataManager = entityMetadataManager; _entityMetadataManager = entityMetadataManager;
@ -81,7 +84,7 @@ namespace ShardingCore.Bootstrappers
if (!_entityMetadataManager.AddEntityMetadata(entityMetadata)) if (!_entityMetadataManager.AddEntityMetadata(entityMetadata))
throw new ShardingCoreInvalidOperationException($"repeat add entity metadata {_shardingEntityType.FullName}"); throw new ShardingCoreInvalidOperationException($"repeat add entity metadata {_shardingEntityType.FullName}");
//设置标签 //设置标签
if (_shardingEntityConfigOptions.TryGetVirtualDataSourceRoute<TEntity>(out var virtualDataSourceRouteType)) if (_shardingRouteConfigOptions.TryGetVirtualDataSourceRoute<TEntity>(out var virtualDataSourceRouteType))
{ {
var creatEntityMetadataDataSourceBuilder = EntityMetadataDataSourceBuilder<TEntity>.CreateEntityMetadataDataSourceBuilder(entityMetadata); var creatEntityMetadataDataSourceBuilder = EntityMetadataDataSourceBuilder<TEntity>.CreateEntityMetadataDataSourceBuilder(entityMetadata);
//配置属性分库信息 //配置属性分库信息
@ -89,7 +92,7 @@ namespace ShardingCore.Bootstrappers
var dataSourceRoute = CreateVirtualDataSourceRoute(virtualDataSourceRouteType); var dataSourceRoute = CreateVirtualDataSourceRoute(virtualDataSourceRouteType);
if (dataSourceRoute is IEntityMetadataAutoBindInitializer entityMetadataAutoBindInitializer) if (dataSourceRoute is IEntityMetadataAutoBindInitializer entityMetadataAutoBindInitializer)
{ {
entityMetadataAutoBindInitializer.Initialize(entityMetadata); entityMetadataAutoBindInitializer.Initialize(entityMetadata,_shardingProvider);
} }
//配置分库信息 //配置分库信息
if(dataSourceRoute is IEntityMetadataDataSourceConfiguration<TEntity> entityMetadataDataSourceConfiguration) if(dataSourceRoute is IEntityMetadataDataSourceConfiguration<TEntity> entityMetadataDataSourceConfiguration)
@ -100,7 +103,7 @@ namespace ShardingCore.Bootstrappers
entityMetadata.CheckShardingDataSourceMetadata(); entityMetadata.CheckShardingDataSourceMetadata();
} }
if (_shardingEntityConfigOptions.TryGetVirtualTableRoute<TEntity>(out var virtualTableRouteType)) if (_shardingRouteConfigOptions.TryGetVirtualTableRoute<TEntity>(out var virtualTableRouteType))
{ {
if (!typeof(TShardingDbContext).IsShardingTableDbContext()) if (!typeof(TShardingDbContext).IsShardingTableDbContext())
throw new ShardingCoreInvalidOperationException( throw new ShardingCoreInvalidOperationException(
@ -112,7 +115,7 @@ namespace ShardingCore.Bootstrappers
var virtualTableRoute = CreateVirtualTableRoute(virtualTableRouteType); var virtualTableRoute = CreateVirtualTableRoute(virtualTableRouteType);
if (virtualTableRoute is IEntityMetadataAutoBindInitializer entityMetadataAutoBindInitializer) if (virtualTableRoute is IEntityMetadataAutoBindInitializer entityMetadataAutoBindInitializer)
{ {
entityMetadataAutoBindInitializer.Initialize(entityMetadata); entityMetadataAutoBindInitializer.Initialize(entityMetadata,_shardingProvider);
} }
//配置分表信息 //配置分表信息
if (virtualTableRoute is IEntityMetadataTableConfiguration<TEntity> createEntityMetadataTableConfiguration) if (virtualTableRoute is IEntityMetadataTableConfiguration<TEntity> createEntityMetadataTableConfiguration)
@ -135,14 +138,14 @@ namespace ShardingCore.Bootstrappers
private IVirtualDataSourceRoute<TEntity> CreateVirtualDataSourceRoute(Type virtualRouteType) private IVirtualDataSourceRoute<TEntity> CreateVirtualDataSourceRoute(Type virtualRouteType)
{ {
var instance = ShardingRuntimeContext.GetInstance().CreateInstance(virtualRouteType); var instance = _shardingProvider.CreateInstance(virtualRouteType);
return (IVirtualDataSourceRoute<TEntity>)instance; return (IVirtualDataSourceRoute<TEntity>)instance;
} }
private IVirtualTableRoute<TEntity> CreateVirtualTableRoute(Type virtualRouteType) private IVirtualTableRoute<TEntity> CreateVirtualTableRoute(Type virtualRouteType)
{ {
var instance = ShardingRuntimeContext.GetInstance().CreateInstance(virtualRouteType); var instance = _shardingProvider.CreateInstance(virtualRouteType);
return (IVirtualTableRoute<TEntity>)instance; return (IVirtualTableRoute<TEntity>)instance;
} }
} }

16
src/ShardingCore/Bootstrappers/ShardingBootstrapper.cs
View File

@ -3,6 +3,7 @@ using System.Collections.Generic;
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using ShardingCore.Core;
using ShardingCore.Extensions; using ShardingCore.Extensions;
using ShardingCore.Jobs; using ShardingCore.Jobs;
using ShardingCore.Jobs.Abstaractions; using ShardingCore.Jobs.Abstaractions;
@ -20,15 +21,15 @@ namespace ShardingCore.Bootstrappers
public class ShardingBootstrapper : IShardingBootstrapper public class ShardingBootstrapper : IShardingBootstrapper
{ {
private readonly ILogger<ShardingBootstrapper> _logger; private readonly ILogger<ShardingBootstrapper> _logger;
private readonly IServiceProvider _internalServiceProvider; private readonly IShardingProvider _shardingProvider;
private readonly IDbContextTypeCollector _dbContextTypeCollector; private readonly IDbContextTypeCollector _dbContextTypeCollector;
private readonly IJobManager _jobManager; private readonly IJobManager _jobManager;
private readonly DoOnlyOnce _doOnlyOnce = new DoOnlyOnce(); private readonly DoOnlyOnce _doOnlyOnce = new DoOnlyOnce();
public ShardingBootstrapper(IServiceProvider internalServiceProvider,IDbContextTypeCollector dbContextTypeCollector,IJobManager jobManager) public ShardingBootstrapper(IShardingProvider shardingProvider,IDbContextTypeCollector dbContextTypeCollector,IJobManager jobManager)
{ {
_logger = InternalLoggerFactory.DefaultFactory .CreateLogger<ShardingBootstrapper>(); _logger = InternalLoggerFactory.DefaultFactory.CreateLogger<ShardingBootstrapper>();
_internalServiceProvider = internalServiceProvider; _shardingProvider = shardingProvider;
_dbContextTypeCollector = dbContextTypeCollector; _dbContextTypeCollector = dbContextTypeCollector;
_jobManager = jobManager; _jobManager = jobManager;
} }
@ -40,8 +41,9 @@ namespace ShardingCore.Bootstrappers
if (!_doOnlyOnce.IsUnDo()) if (!_doOnlyOnce.IsUnDo())
return; return;
_logger.LogDebug("sharding core starting......"); _logger.LogDebug("sharding core starting......");
var instance = (IShardingDbContextBootstrapper)ActivatorUtilities.CreateInstance(_internalServiceProvider,typeof(ShardingDbContextBootstrapper<>).GetGenericType0(_dbContextTypeCollector.ShardingDbContextType)); var instanceType = typeof(ShardingDbContextBootstrapper<>).GetGenericType0(_dbContextTypeCollector.ShardingDbContextType);
var instance = (IShardingDbContextBootstrapper)_shardingProvider.CreateInstance(instanceType);
_logger.LogDebug($"{_dbContextTypeCollector.ShardingDbContextType} start init......"); _logger.LogDebug($"{_dbContextTypeCollector.ShardingDbContextType} start init......");
instance.Initialize(); instance.Initialize();
_logger.LogDebug($"{_dbContextTypeCollector.ShardingDbContextType} complete init"); _logger.LogDebug($"{_dbContextTypeCollector.ShardingDbContextType} complete init");
@ -50,7 +52,7 @@ namespace ShardingCore.Bootstrappers
{ {
Task.Factory.StartNew(async () => Task.Factory.StartNew(async () =>
{ {
await _internalServiceProvider.GetRequiredService<JobRunnerService>().StartAsync(); await _shardingProvider.GetRequiredService<JobRunnerService>().StartAsync();
}, TaskCreationOptions.LongRunning); }, TaskCreationOptions.LongRunning);
} }
} }

26
src/ShardingCore/Bootstrappers/ShardingDbContextBootstrapper.cs
View File

@ -38,30 +38,27 @@ namespace ShardingCore.Bootstrappers
public class ShardingDbContextBootstrapper<TShardingDbContext> : IShardingDbContextBootstrapper public class ShardingDbContextBootstrapper<TShardingDbContext> : IShardingDbContextBootstrapper
where TShardingDbContext : DbContext, IShardingDbContext where TShardingDbContext : DbContext, IShardingDbContext
{ {
private readonly IServiceProvider _internalServiceProvider; private readonly IShardingProvider _shardingProvider;
private readonly IShardingEntityConfigOptions _entityConfigOptions; private readonly IShardingRouteConfigOptions _routeConfigOptions;
private readonly IEntityMetadataManager _entityMetadataManager; private readonly IEntityMetadataManager _entityMetadataManager;
private readonly IParallelTableManager _parallelTableManager; private readonly IParallelTableManager _parallelTableManager;
private readonly IVirtualDataSource _virtualDataSource;
// private readonly ITrackerManager<TShardingDbContext> _trackerManager; // private readonly ITrackerManager<TShardingDbContext> _trackerManager;
private readonly Type _shardingDbContextType; private readonly Type _shardingDbContextType;
public ShardingDbContextBootstrapper( public ShardingDbContextBootstrapper(
IServiceProvider internalServiceProvider, IShardingProvider shardingProvider,
IShardingEntityConfigOptions entityConfigOptions, IShardingRouteConfigOptions routeConfigOptions,
IEntityMetadataManager entityMetadataManager, IEntityMetadataManager entityMetadataManager,
IParallelTableManager parallelTableManager, IParallelTableManager parallelTableManager
IVirtualDataSource virtualDataSource
) )
{ {
_shardingDbContextType = typeof(TShardingDbContext); _shardingDbContextType = typeof(TShardingDbContext);
_internalServiceProvider = internalServiceProvider; _shardingProvider = shardingProvider;
_entityConfigOptions = entityConfigOptions; _routeConfigOptions = routeConfigOptions;
_entityMetadataManager = entityMetadataManager; _entityMetadataManager = entityMetadataManager;
_parallelTableManager = parallelTableManager; _parallelTableManager = parallelTableManager;
_virtualDataSource = virtualDataSource;
} }
/// <summary> /// <summary>
@ -76,15 +73,14 @@ namespace ShardingCore.Bootstrappers
private void InitializeEntityMetadata() private void InitializeEntityMetadata()
{ {
var shardingEntities = _entityConfigOptions.GetShardingTableRouteTypes() var shardingEntities = _routeConfigOptions.GetShardingTableRouteTypes()
.Concat(_entityConfigOptions.GetShardingDataSourceRouteTypes()).ToHashSet(); .Concat(_routeConfigOptions.GetShardingDataSourceRouteTypes()).ToHashSet();
foreach (var entityType in shardingEntities) foreach (var entityType in shardingEntities)
{ {
var entityMetadataInitializerType = var entityMetadataInitializerType =
typeof(EntityMetadataInitializer<,>).GetGenericType1(_shardingDbContextType, entityType); typeof(EntityMetadataInitializer<,>).GetGenericType1(_shardingDbContextType, entityType);
var entityMetadataInitializer = var entityMetadataInitializer =(IEntityMetadataInitializer)_shardingProvider.CreateInstance(entityMetadataInitializerType);
(IEntityMetadataInitializer)ActivatorUtilities.CreateInstance(_internalServiceProvider,entityMetadataInitializerType);
entityMetadataInitializer.Initialize(); entityMetadataInitializer.Initialize();
} }
@ -92,7 +88,7 @@ namespace ShardingCore.Bootstrappers
private void InitializeParallelTables() private void InitializeParallelTables()
{ {
foreach (var parallelTableGroupNode in _entityConfigOptions.GetParallelTableGroupNodes()) foreach (var parallelTableGroupNode in _routeConfigOptions.GetParallelTableGroupNodes())
{ {
var parallelTableComparerType = parallelTableGroupNode.GetEntities() var parallelTableComparerType = parallelTableGroupNode.GetEntities()
.FirstOrDefault(o => !_entityMetadataManager.IsShardingTable(o.Type)); .FirstOrDefault(o => !_entityMetadataManager.IsShardingTable(o.Type));

11
src/ShardingCore/Core/EntityMetadatas/DefaultEntityMetadataManager.cs
View File

@ -4,6 +4,7 @@ using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;
using ShardingCore.Extensions; using ShardingCore.Extensions;
using ShardingCore.Sharding.Abstractions; using ShardingCore.Sharding.Abstractions;
@ -78,5 +79,15 @@ namespace ShardingCore.Core.EntityMetadatas
{ {
return _caches.Keys.ToList(); return _caches.Keys.ToList();
} }
public bool TryInitModel(IEntityType efEntityType)
{
if (_caches.TryGetValue(efEntityType.ClrType,out var metadata))
{
metadata.SetEntityModel(efEntityType);
return true;
}
return false;
}
} }
} }

4
src/ShardingCore/Core/EntityMetadatas/IEntityMetadataAutoBindInitializer.cs
View File

@ -5,10 +5,12 @@
/// </summary> /// </summary>
public interface IEntityMetadataAutoBindInitializer public interface IEntityMetadataAutoBindInitializer
{ {
IShardingProvider RouteShardingProvider { get; }
/// <summary> /// <summary>
/// 初始化 在启动时会被调用并且将对象元数据绑定到对应的路由上面 /// 初始化 在启动时会被调用并且将对象元数据绑定到对应的路由上面
/// </summary> /// </summary>
/// <param name="entityMetadata"></param> /// <param name="entityMetadata"></param>
void Initialize(EntityMetadata entityMetadata); /// <param name="shardingProvider"></param>
void Initialize(EntityMetadata entityMetadata,IShardingProvider shardingProvider);
} }
} }

3
src/ShardingCore/Core/EntityMetadatas/IEntityMetadataManager.cs
View File

@ -1,6 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;
using ShardingCore.Sharding.Abstractions; using ShardingCore.Sharding.Abstractions;
namespace ShardingCore.Core.EntityMetadatas namespace ShardingCore.Core.EntityMetadatas
@ -44,5 +45,7 @@ namespace ShardingCore.Core.EntityMetadatas
bool IsSharding(Type entityType); bool IsSharding(Type entityType);
List<Type> GetAllShardingEntities(); List<Type> GetAllShardingEntities();
bool TryInitModel(IEntityType efEntityType);
} }
} }

10
src/ShardingCore/Core/IShardingProvider.cs Normal file
View File

@ -0,0 +1,10 @@
using System;
namespace ShardingCore.Core
{
public interface IShardingProvider
{
object GetService(Type serviceType);
}
}

4
src/ShardingCore/Core/IShardingRuntimeContext.cs
View File

@ -38,9 +38,11 @@ namespace ShardingCore.Core
void UseLogfactory(ILoggerFactory loggerFactory); void UseLogfactory(ILoggerFactory loggerFactory);
void WithApplicationServiceProvider(IServiceProvider applicationServiceProvider); void UseApplicationServiceProvider(IServiceProvider applicationServiceProvider);
void Initialize(); void Initialize();
object GetService(Type serviceType); object GetService(Type serviceType);
TService GetService<TService>(); TService GetService<TService>();
object GetRequiredService(Type serviceType);
TService GetRequiredService<TService>();
} }
} }

24
src/ShardingCore/Core/ShardingConfigurations/Abstractions/IShardingConfigurationOptions.cs
View File

@ -1,12 +1,12 @@
using Microsoft.EntityFrameworkCore; // using Microsoft.EntityFrameworkCore;
using ShardingCore.Sharding.Abstractions; // using ShardingCore.Sharding.Abstractions;
//
namespace ShardingCore.Core.ShardingConfigurations.Abstractions // namespace ShardingCore.Core.ShardingConfigurations.Abstractions
{ // {
public interface IShardingConfigurationOptions // public interface IShardingConfigurationOptions
{ // {
public void AddShardingGlobalConfigOptions(ShardingConfigOptions shardingConfigOptions); // public void AddShardingGlobalConfigOptions(ShardingConfigOptions shardingConfigOptions);
//
public ShardingConfigOptions[] GetAllShardingGlobalConfigOptions(); // public ShardingConfigOptions[] GetAllShardingGlobalConfigOptions();
} // }
} // }

121
src/ShardingCore/Core/ShardingConfigurations/Abstractions/IShardingEntityConfigOptions.cs
View File

@ -1,121 +0,0 @@
using Microsoft.EntityFrameworkCore;
using ShardingCore.Core.VirtualRoutes.DataSourceRoutes;
using ShardingCore.Core.VirtualRoutes.TableRoutes;
using ShardingCore.Sharding.ParallelTables;
using System;
using System.Collections.Generic;
using System.Data.Common;
namespace ShardingCore.Core.ShardingConfigurations.Abstractions
{
public interface IShardingEntityConfigOptions
{
/// <summary>
/// 如果数据库不存在就创建并且创建表除了分表的
/// </summary>
bool EnsureCreatedWithOutShardingTable { get; set; }
/// <summary>
/// 是否需要在启动时创建分表
/// </summary>
bool? CreateShardingTableOnStart { get; set; }
/// <summary>
/// 是否在启动时创建数据库
/// </summary>
public bool? CreateDataBaseOnlyOnStart { get; set; }
/// <summary>
/// 当查询遇到没有路由被命中时是否抛出错误
/// </summary>
bool ThrowIfQueryRouteNotMatch { get; set; }
/// <summary>
/// 忽略建表时的错误
/// </summary>
bool? IgnoreCreateTableError { get; set; }
///// <summary>
///// 是否启用分表路由编译缓存(默认只缓存单个操作的也就是<![CDATA[=,>,>=,<,<=]]>)
///// default cache single filter route expression, <![CDATA[=,>,>=,<,<=]]> with sharding property
///// </summary>
//bool? EnableTableRouteCompileCache { get; set; }
///// <summary>
///// 是否启用分库路由编译缓存(默认只缓存单个操作的也就是<![CDATA[=,>,>=,<,<=]]>)
///// default cache single filter route expression, <![CDATA[=,>,>=,<,<=]]> with sharding property
///// </summary>
//bool? EnableDataSourceRouteCompileCache { get; set; }
/// <summary>
/// 添加分库路由
/// </summary>
/// <param name="routeType"></param>
void AddShardingDataSourceRoute(Type routeType);
/// <summary>
/// 添加分表路由
/// </summary>
/// <param name="routeType"></param>
void AddShardingTableRoute(Type routeType);
/// <summary>
/// 是否有虚拟表路由
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
bool HasVirtualTableRoute(Type entityType);
/// <summary>
/// 获取虚拟表路由
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
Type GetVirtualTableRouteType(Type entityType);
/// <summary>
/// 是否有虚拟库路由
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
bool HasVirtualDataSourceRoute(Type entityType);
/// <summary>
/// 获取虚拟库路由
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
Type GetVirtualDataSourceRouteType(Type entityType);
/// <summary>
/// 获取所有的分表路由类型
/// </summary>
/// <returns></returns>
ISet<Type> GetShardingTableRouteTypes();
/// <summary>
/// 获取所有的分库路由类型
/// </summary>
/// <returns></returns>
ISet<Type> GetShardingDataSourceRouteTypes();
/// <summary>
/// 平行表
/// </summary>
bool AddParallelTableGroupNode(ParallelTableGroupNode parallelTableGroupNode);
/// <summary>
/// 获取平行表
/// </summary>
/// <returns></returns>
ISet<ParallelTableGroupNode> GetParallelTableGroupNodes();
/// <summary>
/// DbContext如何通过现有connection创建
/// </summary>
Action<DbConnection, DbContextOptionsBuilder> ConnectionConfigure { get; }
/// <summary>
/// DbContext如何通过连接字符串创建
/// </summary>
Action<string, DbContextOptionsBuilder> ConnectionStringConfigure { get; }
Action<DbContextOptionsBuilder> ExecutorDbContextConfigure { get; }
Action<DbContextOptionsBuilder> ShellDbContextConfigure { get; }
/// <summary>
/// DbContext如何通过连接字符串创建
/// </summary>
public void UseShardingQuery(Action<string, DbContextOptionsBuilder> queryConfigure);
/// <summary>
/// DbContext如何通过现有connection创建
/// </summary>
public void UseShardingTransaction(Action<DbConnection, DbContextOptionsBuilder> transactionConfigure);
void UseExecutorDbContextConfigure(Action<DbContextOptionsBuilder> executorDbContextConfigure);
void UseShellDbContextConfigure(Action<DbContextOptionsBuilder> shellDbContextConfigure);
}
}

112
src/ShardingCore/Core/ShardingConfigurations/Abstractions/IShardingRouteConfigOptions.cs Normal file
View File

@ -0,0 +1,112 @@
using Microsoft.EntityFrameworkCore;
using ShardingCore.Core.VirtualRoutes.DataSourceRoutes;
using ShardingCore.Core.VirtualRoutes.TableRoutes;
using ShardingCore.Sharding.ParallelTables;
using System;
using System.Collections.Generic;
using System.Data.Common;
namespace ShardingCore.Core.ShardingConfigurations.Abstractions
{
public interface IShardingRouteConfigOptions
{
/// <summary>
/// 当查询遇到没有路由被命中时是否抛出错误
/// </summary>
bool ThrowIfQueryRouteNotMatch { get; set; }
// /// <summary>
// /// 如果数据库不存在就创建并且创建表除了分表的
// /// </summary>
// bool EnsureCreatedWithOutShardingTable { get; set; }
//
// /// <summary>
// /// 是否需要在启动时创建分表
// /// </summary>
// bool? CreateShardingTableOnStart { get; set; }
// /// <summary>
// /// 是否在启动时创建数据库
// /// </summary>
// public bool? CreateDataBaseOnlyOnStart { get; set; }
/// <summary>
/// 忽略建表时的错误
/// </summary>
bool? IgnoreCreateTableError { get; set; }
// ///// <summary>
// ///// 是否启用分表路由编译缓存(默认只缓存单个操作的也就是<![CDATA[=,>,>=,<,<=]]>)
// ///// default cache single filter route expression, <![CDATA[=,>,>=,<,<=]]> with sharding property
// ///// </summary>
// //bool? EnableTableRouteCompileCache { get; set; }
// ///// <summary>
// ///// 是否启用分库路由编译缓存(默认只缓存单个操作的也就是<![CDATA[=,>,>=,<,<=]]>)
// ///// default cache single filter route expression, <![CDATA[=,>,>=,<,<=]]> with sharding property
// ///// </summary>
// //bool? EnableDataSourceRouteCompileCache { get; set; }
/// <summary>
/// 添加分库路由
/// </summary>
/// <param name="routeType"></param>
void AddShardingDataSourceRoute(Type routeType);
/// <summary>
/// 添加分表路由
/// </summary>
/// <param name="routeType"></param>
void AddShardingTableRoute(Type routeType);
/// <summary>
/// 是否有虚拟表路由
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
bool HasVirtualTableRoute(Type entityType);
/// <summary>
/// 获取虚拟表路由
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
Type GetVirtualTableRouteType(Type entityType);
/// <summary>
/// 是否有虚拟库路由
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
bool HasVirtualDataSourceRoute(Type entityType);
/// <summary>
/// 获取虚拟库路由
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
Type GetVirtualDataSourceRouteType(Type entityType);
/// <summary>
/// 获取所有的分表路由类型
/// </summary>
/// <returns></returns>
ISet<Type> GetShardingTableRouteTypes();
/// <summary>
/// 获取所有的分库路由类型
/// </summary>
/// <returns></returns>
ISet<Type> GetShardingDataSourceRouteTypes();
/// <summary>
/// 平行表
/// </summary>
bool AddParallelTableGroupNode(ParallelTableGroupNode parallelTableGroupNode);
/// <summary>
/// 获取平行表
/// </summary>
/// <returns></returns>
ISet<ParallelTableGroupNode> GetParallelTableGroupNodes();
// /// <summary>
// /// DbContext如何通过现有connection创建
// /// </summary>
// Action<DbConnection, DbContextOptionsBuilder> ConnectionConfigure { get; }
// /// <summary>
// /// DbContext如何通过连接字符串创建
// /// </summary>
// Action<string, DbContextOptionsBuilder> ConnectionStringConfigure { get; }
// Action<DbContextOptionsBuilder> ExecutorDbContextConfigure { get; }
// Action<DbContextOptionsBuilder> ShellDbContextConfigure { get; }
//
// void UseExecutorDbContextConfigure(Action<DbContextOptionsBuilder> executorDbContextConfigure);
// void UseShellDbContextConfigure(Action<DbContextOptionsBuilder> shellDbContextConfigure);
}
}

324
src/ShardingCore/Core/ShardingConfigurations/ConfigBuilders/ShardingConfigBuilder.cs
View File

@ -1,164 +1,160 @@
using System; // using System;
using System.Collections.Generic; // using System.Collections.Generic;
using System.Linq; // using System.Linq;
using System.Text; // using System.Text;
using System.Threading.Tasks; // using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore; // using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection; // using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions; // using Microsoft.Extensions.DependencyInjection.Extensions;
using ShardingCore.Core.ShardingConfigurations.Abstractions; // using ShardingCore.Core.ShardingConfigurations.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Common; // using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Common;
using ShardingCore.DIExtensions; // using ShardingCore.DIExtensions;
using ShardingCore.Exceptions; // using ShardingCore.Exceptions;
using ShardingCore.Extensions; // using ShardingCore.Extensions;
using ShardingCore.Sharding; // using ShardingCore.Sharding;
using ShardingCore.Sharding.Abstractions; // using ShardingCore.Sharding.Abstractions;
using ShardingCore.Sharding.ReadWriteConfigurations; // using ShardingCore.Sharding.ReadWriteConfigurations;
using ShardingCore.Sharding.ReadWriteConfigurations.Abstractions; // using ShardingCore.Sharding.ReadWriteConfigurations.Abstractions;
using ShardingCore.Sharding.ShardingComparision.Abstractions; // using ShardingCore.Sharding.ShardingComparision.Abstractions;
//
namespace ShardingCore.Core.ShardingConfigurations.ConfigBuilders // namespace ShardingCore.Core.ShardingConfigurations.ConfigBuilders
{ // {
public class ShardingConfigBuilder<TShardingDbContext> where TShardingDbContext:DbContext,IShardingDbContext // public class ShardingConfigBuilder<TShardingDbContext> where TShardingDbContext:DbContext,IShardingDbContext
{ // {
public ShardingCoreConfigBuilder<TShardingDbContext> ShardingCoreConfigBuilder { get; } // public ShardingCoreConfigBuilder<TShardingDbContext> ShardingCoreConfigBuilder { get; }
//
public ShardingConfigBuilder(ShardingCoreConfigBuilder<TShardingDbContext> shardingCoreConfigBuilder) // public ShardingConfigBuilder(ShardingCoreConfigBuilder<TShardingDbContext> shardingCoreConfigBuilder)
{ // {
ShardingCoreConfigBuilder = shardingCoreConfigBuilder; // ShardingCoreConfigBuilder = shardingCoreConfigBuilder;
} // }
/// <summary> // /// <summary>
/// 添加一个分片配置 必填<code>ConfigId</code>和<code>AddDefaultDataSource(string dataSourceName, string connectionString)</code> // /// 添加一个分片配置 必填<code>ConfigId</code>和<code>AddDefaultDataSource(string dataSourceName, string connectionString)</code>
/// 如果全局未配置 必须配置<code>UseShardingQuery</code>和<code>UseShardingQuery</code> // /// 如果全局未配置 必须配置<code>UseShardingQuery</code>和<code>UseShardingQuery</code>
/// </summary> // /// </summary>
/// <param name="shardingGlobalConfigOptionsConfigure"></param> // /// <param name="shardingGlobalConfigOptionsConfigure"></param>
/// <returns></returns> // /// <returns></returns>
/// <exception cref="ArgumentNullException"></exception> // /// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ShardingCoreConfigException"></exception> // /// <exception cref="ShardingCoreConfigException"></exception>
/// <exception cref="ArgumentException"></exception> // /// <exception cref="ArgumentException"></exception>
public ShardingConfigBuilder<TShardingDbContext> AddConfig(Action<ShardingConfigOptions> shardingGlobalConfigOptionsConfigure) // public ShardingConfigBuilder<TShardingDbContext> AddConfig(Action<ShardingConfigOptions> shardingGlobalConfigOptionsConfigure)
{ // {
var shardingGlobalConfigOptions = new ShardingConfigOptions(); // var shardingGlobalConfigOptions = new ShardingConfigOptions();
shardingGlobalConfigOptionsConfigure?.Invoke(shardingGlobalConfigOptions); // shardingGlobalConfigOptionsConfigure?.Invoke(shardingGlobalConfigOptions);
if (string.IsNullOrWhiteSpace(shardingGlobalConfigOptions.ConfigId)) // if (string.IsNullOrWhiteSpace(shardingGlobalConfigOptions.ConfigId))
throw new ArgumentNullException(nameof(shardingGlobalConfigOptions.ConfigId)); // throw new ArgumentNullException(nameof(shardingGlobalConfigOptions.ConfigId));
if (string.IsNullOrWhiteSpace(shardingGlobalConfigOptions.DefaultDataSourceName)) // if (string.IsNullOrWhiteSpace(shardingGlobalConfigOptions.DefaultDataSourceName))
throw new ArgumentNullException( // throw new ArgumentNullException(
$"{nameof(shardingGlobalConfigOptions.DefaultDataSourceName)} plz call {nameof(ShardingConfigOptions.AddDefaultDataSource)}"); // $"{nameof(shardingGlobalConfigOptions.DefaultDataSourceName)} plz call {nameof(ShardingConfigOptions.AddDefaultDataSource)}");
//
if (string.IsNullOrWhiteSpace(shardingGlobalConfigOptions.DefaultConnectionString)) // if (string.IsNullOrWhiteSpace(shardingGlobalConfigOptions.DefaultConnectionString))
throw new ArgumentNullException( // throw new ArgumentNullException(
$"{nameof(shardingGlobalConfigOptions.DefaultConnectionString)} plz call {nameof(ShardingConfigOptions.AddDefaultDataSource)}"); // $"{nameof(shardingGlobalConfigOptions.DefaultConnectionString)} plz call {nameof(ShardingConfigOptions.AddDefaultDataSource)}");
//
if (shardingGlobalConfigOptions.ConnectionStringConfigure is null&& ShardingCoreConfigBuilder.ShardingEntityConfigOptions.ConnectionStringConfigure is null) // if (shardingGlobalConfigOptions.ConnectionStringConfigure is null&& ShardingCoreConfigBuilder.ShardingRouteConfigOptions.ConnectionStringConfigure is null)
throw new ArgumentNullException($"plz call {nameof(shardingGlobalConfigOptions.UseShardingQuery)}"); // throw new ArgumentNullException($"plz call {nameof(shardingGlobalConfigOptions.UseShardingQuery)}");
if (shardingGlobalConfigOptions.ConnectionConfigure is null && ShardingCoreConfigBuilder.ShardingEntityConfigOptions.ConnectionConfigure is null) // if (shardingGlobalConfigOptions.ConnectionConfigure is null && ShardingCoreConfigBuilder.ShardingRouteConfigOptions.ConnectionConfigure is null)
throw new ArgumentNullException( // throw new ArgumentNullException(
$"plz call {nameof(shardingGlobalConfigOptions.UseShardingTransaction)}"); // $"plz call {nameof(shardingGlobalConfigOptions.UseShardingTransaction)}");
//
if (shardingGlobalConfigOptions.ReplaceShardingComparerFactory == null) // if (shardingGlobalConfigOptions.MaxQueryConnectionsLimit <= 0)
{ // throw new ArgumentException(
throw new ShardingCoreConfigException($"{nameof(shardingGlobalConfigOptions.ReplaceShardingComparerFactory)} is null"); // $"{nameof(shardingGlobalConfigOptions.MaxQueryConnectionsLimit)} should greater than and equal 1");
} // ShardingCoreConfigBuilder.ShardingConfigOptions.Add(shardingGlobalConfigOptions);
if (shardingGlobalConfigOptions.MaxQueryConnectionsLimit <= 0) // return this;
throw new ArgumentException( // }
$"{nameof(shardingGlobalConfigOptions.MaxQueryConnectionsLimit)} should greater than and equal 1"); // /// <summary>
ShardingCoreConfigBuilder.ShardingConfigOptions.Add(shardingGlobalConfigOptions); // /// 单配置确认
return this; // /// </summary>
} // /// <param name="configurationStrategy"></param>
/// <summary> // /// <returns></returns>
/// 单配置确认 // public IServiceCollection EnsureConfig(ShardingConfigurationStrategyEnum configurationStrategy = ShardingConfigurationStrategyEnum.ThrowIfNull)
/// </summary> // {
/// <param name="configurationStrategy"></param> // return DoEnsureConfig(false,false, configurationStrategy);
/// <returns></returns> // }
public IServiceCollection EnsureConfig(ShardingConfigurationStrategyEnum configurationStrategy = ShardingConfigurationStrategyEnum.ThrowIfNull) // /// <summary>
{ // /// 单配置确认 自动初始化不需要在手动<code>IShardingBootstrapper.Start()</code>
return DoEnsureConfig(false,false, configurationStrategy); // /// </summary>
} // /// <param name="configurationStrategy"></param>
/// <summary> // /// <returns></returns>
/// 单配置确认 自动初始化不需要在手动<code>IShardingBootstrapper.Start()</code> // public IServiceCollection EnsureConfigWithAutoStart(ShardingConfigurationStrategyEnum configurationStrategy = ShardingConfigurationStrategyEnum.ThrowIfNull)
/// </summary> // {
/// <param name="configurationStrategy"></param> // return DoEnsureConfig(false,true, configurationStrategy);
/// <returns></returns> // }
public IServiceCollection EnsureConfigWithAutoStart(ShardingConfigurationStrategyEnum configurationStrategy = ShardingConfigurationStrategyEnum.ThrowIfNull) // /// <summary>
{ // /// 多配置确认
return DoEnsureConfig(false,true, configurationStrategy); // /// </summary>
} // /// <param name="configurationStrategy"></param>
/// <summary> // /// <returns></returns>
/// 多配置确认 // public IServiceCollection EnsureMultiConfig(ShardingConfigurationStrategyEnum configurationStrategy= ShardingConfigurationStrategyEnum.ThrowIfNull)
/// </summary> // {
/// <param name="configurationStrategy"></param> // return DoEnsureConfig(true,false, configurationStrategy);
/// <returns></returns> // }
public IServiceCollection EnsureMultiConfig(ShardingConfigurationStrategyEnum configurationStrategy= ShardingConfigurationStrategyEnum.ThrowIfNull) // /// <summary>
{ // /// 多配置确认 自动初始化不需要在手动<code>IShardingBootstrapper.Start()</code>
return DoEnsureConfig(true,false, configurationStrategy); // /// </summary>
} // /// <param name="configurationStrategy"></param>
/// <summary> // /// <returns></returns>
/// 多配置确认 自动初始化不需要在手动<code>IShardingBootstrapper.Start()</code> // public IServiceCollection EnsureMultiConfigWithAutoStart(ShardingConfigurationStrategyEnum configurationStrategy= ShardingConfigurationStrategyEnum.ThrowIfNull)
/// </summary> // {
/// <param name="configurationStrategy"></param> // return DoEnsureConfig(true,true, configurationStrategy);
/// <returns></returns> // }
public IServiceCollection EnsureMultiConfigWithAutoStart(ShardingConfigurationStrategyEnum configurationStrategy= ShardingConfigurationStrategyEnum.ThrowIfNull) //
{ // private IServiceCollection DoEnsureConfig(bool isMultiConfig,
return DoEnsureConfig(true,true, configurationStrategy); // bool autoStart,
} // ShardingConfigurationStrategyEnum configurationStrategy)
// {
private IServiceCollection DoEnsureConfig(bool isMultiConfig, // if (ShardingCoreConfigBuilder.ShardingConfigOptions.IsEmpty())
bool autoStart, // throw new ArgumentException($"plz call {nameof(AddConfig)} at least once ");
ShardingConfigurationStrategyEnum configurationStrategy) // if (!isMultiConfig)
{ // {
if (ShardingCoreConfigBuilder.ShardingConfigOptions.IsEmpty()) // if (ShardingCoreConfigBuilder.ShardingConfigOptions.Count > 1)
throw new ArgumentException($"plz call {nameof(AddConfig)} at least once "); // {
if (!isMultiConfig) // throw new ArgumentException($"plz call {nameof(AddConfig)} at most once ");
{ // }
if (ShardingCoreConfigBuilder.ShardingConfigOptions.Count > 1) // }
{ //
throw new ArgumentException($"plz call {nameof(AddConfig)} at most once "); // var services = ShardingCoreConfigBuilder.Services;
} // services.AddSingleton<IDbContextTypeCollector>(sp => new DbContextTypeCollector<TShardingDbContext>());
} // services.AddSingleton<IShardingRouteConfigOptions>(sp => ShardingCoreConfigBuilder.ShardingRouteConfigOptions);
// services.AddSingleton(sp => ShardingCoreConfigBuilder.ShardingRouteConfigOptions);
var services = ShardingCoreConfigBuilder.Services; //
services.AddSingleton<IDbContextTypeCollector>(sp => new DbContextTypeCollector<TShardingDbContext>()); // services.AddSingleton(sp => CreateShardingConfigurationOptions(isMultiConfig, configurationStrategy));
services.AddSingleton<IShardingEntityConfigOptions>(sp => ShardingCoreConfigBuilder.ShardingEntityConfigOptions); // services.AddSingleton<IShardingReadWriteAccessor, ShardingReadWriteAccessor<TShardingDbContext>>();
services.AddSingleton(sp => ShardingCoreConfigBuilder.ShardingEntityConfigOptions); // if (autoStart)
// {
services.AddSingleton(sp => CreateShardingConfigurationOptions(isMultiConfig, configurationStrategy)); //
services.AddSingleton<IShardingReadWriteAccessor, ShardingReadWriteAccessor<TShardingDbContext>>(); // }
if (autoStart) //
{ // services.AddInternalShardingCore<TShardingDbContext>();
// return services;
} // }
//
services.AddInternalShardingCore<TShardingDbContext>(); // private IShardingConfigurationOptions CreateShardingConfigurationOptions(bool isMultiConfig,
return services; // ShardingConfigurationStrategyEnum configurationStrategy)
} // {
// IShardingConfigurationOptions shardingConfigurationOptions;
private IShardingConfigurationOptions CreateShardingConfigurationOptions(bool isMultiConfig, // if (!isMultiConfig)
ShardingConfigurationStrategyEnum configurationStrategy) // {
{ // shardingConfigurationOptions = new ShardingSingleConfigurationOptions
IShardingConfigurationOptions shardingConfigurationOptions; // {
if (!isMultiConfig) // ShardingConfigurationStrategy = configurationStrategy
{ // };
shardingConfigurationOptions = new ShardingSingleConfigurationOptions // }
{ // else
ShardingConfigurationStrategy = configurationStrategy // {
}; // shardingConfigurationOptions = new ShardingMultiConfigurationOptions
} // {
else // ShardingConfigurationStrategy = configurationStrategy
{ // };
shardingConfigurationOptions = new ShardingMultiConfigurationOptions // }
{ //
ShardingConfigurationStrategy = configurationStrategy // foreach (var configOptions in ShardingCoreConfigBuilder
}; // .ShardingConfigOptions)
} // {
// shardingConfigurationOptions.AddShardingGlobalConfigOptions(configOptions);
foreach (var configOptions in ShardingCoreConfigBuilder // }
.ShardingConfigOptions) //
{ // return shardingConfigurationOptions;
shardingConfigurationOptions.AddShardingGlobalConfigOptions(configOptions); // }
} // }
// }
return shardingConfigurationOptions;
}
}
}

264
src/ShardingCore/Core/ShardingConfigurations/ConfigBuilders/ShardingCoreConfigBuilder.cs
View File

@ -1,132 +1,132 @@
using System; // using System;
using System.Collections.Generic; // using System.Collections.Generic;
using System.Linq; // using System.Linq;
using Microsoft.EntityFrameworkCore; // using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection; // using Microsoft.Extensions.DependencyInjection;
using ShardingCore.Core; // using ShardingCore.Core;
using ShardingCore.Core.ShardingConfigurations; // using ShardingCore.Core.ShardingConfigurations;
using ShardingCore.Core.ShardingConfigurations.ConfigBuilders; // using ShardingCore.Core.ShardingConfigurations.ConfigBuilders;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources; // using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
using ShardingCore.Exceptions; // using ShardingCore.Exceptions;
using ShardingCore.Sharding.Abstractions; // using ShardingCore.Sharding.Abstractions;
using ShardingCore.Sharding.ParallelTables; // using ShardingCore.Sharding.ParallelTables;
//
namespace ShardingCore.DIExtensions // namespace ShardingCore.DIExtensions
{ // {
/* // /*
* @Author: xjm // * @Author: xjm
* @Description: // * @Description:
* @Date: 2021/9/19 20:49:03 // * @Date: 2021/9/19 20:49:03
* @Ver: 1.0 // * @Ver: 1.0
* @Email: 326308290@qq.com // * @Email: 326308290@qq.com
*/ // */
public class ShardingCoreConfigBuilder<TShardingDbContext> where TShardingDbContext:DbContext,IShardingDbContext // public class ShardingCoreConfigBuilder<TShardingDbContext> where TShardingDbContext:DbContext,IShardingDbContext
{ // {
public IServiceCollection Services { get; } // public IServiceCollection Services { get; }
//
//
public List<ShardingConfigOptions> ShardingConfigOptions { get; } // public List<ShardingConfigOptions> ShardingConfigOptions { get; }
public ShardingEntityConfigOptions ShardingEntityConfigOptions { get; } // public ShardingRouteConfigOptions ShardingRouteConfigOptions { get; }
//
//
public ShardingCoreConfigBuilder(IServiceCollection services) // public ShardingCoreConfigBuilder(IServiceCollection services)
{ // {
Services = services; // Services = services;
ShardingConfigOptions = new List<ShardingConfigOptions>(); // ShardingConfigOptions = new List<ShardingConfigOptions>();
ShardingEntityConfigOptions = new ShardingEntityConfigOptions(); // ShardingRouteConfigOptions = new ShardingRouteConfigOptions();
} // }
//
public ShardingConfigBuilder<TShardingDbContext> AddEntityConfig(Action<ShardingEntityConfigOptions> entityConfigure) // public ShardingConfigBuilder<TShardingDbContext> AddEntityConfig(Action<ShardingRouteConfigOptions> entityConfigure)
{ // {
entityConfigure?.Invoke(ShardingEntityConfigOptions); // entityConfigure?.Invoke(ShardingRouteConfigOptions);
return new ShardingConfigBuilder<TShardingDbContext>(this); // return new ShardingConfigBuilder<TShardingDbContext>(this);
} // }
//public ShardingCoreConfigBuilder<TShardingDbContext, TActualDbContext> AddDefaultDataSource(string dataSourceName, string connectionString) // //public ShardingCoreConfigBuilder<TShardingDbContext, TActualDbContext> AddDefaultDataSource(string dataSourceName, string connectionString)
//{ // //{
// if (!string.IsNullOrWhiteSpace(defaultDataSourceName) || !string.IsNullOrWhiteSpace(defaultConnectionString)) // // if (!string.IsNullOrWhiteSpace(defaultDataSourceName) || !string.IsNullOrWhiteSpace(defaultConnectionString))
// throw new ShardingCoreInvalidOperationException($"{nameof(AddDefaultDataSource)}-{dataSourceName}"); // // throw new ShardingCoreInvalidOperationException($"{nameof(AddDefaultDataSource)}-{dataSourceName}");
// this.defaultDataSourceName = dataSourceName; // // this.defaultDataSourceName = dataSourceName;
// this.defaultConnectionString = connectionString; // // this.defaultConnectionString = connectionString;
// return this; // // return this;
//} // //}
//
//public ShardingCoreConfigBuilder<TShardingDbContext, TActualDbContext> AddDataSource(string dataSourceName, string connectionString) // //public ShardingCoreConfigBuilder<TShardingDbContext, TActualDbContext> AddDataSource(string dataSourceName, string connectionString)
//{ // //{
// if (_dataSources.ContainsKey(dataSourceName)) // // if (_dataSources.ContainsKey(dataSourceName))
// throw new ShardingCoreInvalidOperationException($"{nameof(AddDataSource)}-{dataSourceName} repeat"); // // throw new ShardingCoreInvalidOperationException($"{nameof(AddDataSource)}-{dataSourceName} repeat");
// _dataSources.Add(dataSourceName, connectionString); // // _dataSources.Add(dataSourceName, connectionString);
// return this; // // return this;
//} // //}
} // }
//
public class ShardingCoreBeginOptions // public class ShardingCoreBeginOptions
{ // {
/// <summary> // /// <summary>
/// 配置id // /// 配置id
/// </summary> // /// </summary>
public string ConfigId { get; set; } // public string ConfigId { get; set; }
/// <summary> // /// <summary>
/// 优先级 // /// 优先级
/// </summary> // /// </summary>
public int Priority { get; set; } // public int Priority { get; set; }
/// <summary> // /// <summary>
/// 如果数据库不存在就创建并且创建表除了分表的 // /// 如果数据库不存在就创建并且创建表除了分表的
/// </summary> // /// </summary>
public bool EnsureCreatedWithOutShardingTable { get; set; } // public bool EnsureCreatedWithOutShardingTable { get; set; }
//
/// <summary> // /// <summary>
/// 是否需要在启动时创建分表 // /// 是否需要在启动时创建分表
/// </summary> // /// </summary>
public bool? CreateShardingTableOnStart { get; set; } // public bool? CreateShardingTableOnStart { get; set; }
///// <summary> // ///// <summary>
///// 是否自动追踪实体 // ///// 是否自动追踪实体
///// 譬如本次查询涉及到a1,a2,a3这三张表，会创建3个dbcontext进行查询，如果AutoTrackEntity=false那么针对被创建的dbcontext不会有任何变化，还是以追踪的形式查询 // ///// 譬如本次查询涉及到a1,a2,a3这三张表，会创建3个dbcontext进行查询，如果AutoTrackEntity=false那么针对被创建的dbcontext不会有任何变化，还是以追踪的形式查询
///// 因为会同时创建3个dbcontext所以针对跨表查询完成后dbcontext会被回收，但是查询还是按原先的行为查询，所以如果不启用建议在查询的时候使用notracking // ///// 因为会同时创建3个dbcontext所以针对跨表查询完成后dbcontext会被回收，但是查询还是按原先的行为查询，所以如果不启用建议在查询的时候使用notracking
///// 如果AutoTrackEntity=true，那么被创建的三个dbcontext还是以原先的表现行为进行查询，在查询完成后会再次各自创建对应的dbcontext进行对象的追踪 // ///// 如果AutoTrackEntity=true，那么被创建的三个dbcontext还是以原先的表现行为进行查询，在查询完成后会再次各自创建对应的dbcontext进行对象的追踪
///// </summary> // ///// </summary>
//public bool AutoTrackEntity { get; set; } // //public bool AutoTrackEntity { get; set; }
/// <summary> // /// <summary>
/// 当查询遇到没有路由被命中时是否抛出错误 // /// 当查询遇到没有路由被命中时是否抛出错误
/// </summary> // /// </summary>
public bool ThrowIfQueryRouteNotMatch { get; set; } = true; // public bool ThrowIfQueryRouteNotMatch { get; set; } = true;
//
/// <summary> // /// <summary>
/// 忽略建表时的错误 // /// 忽略建表时的错误
/// </summary> // /// </summary>
public bool? IgnoreCreateTableError { get; set; } = true; // public bool? IgnoreCreateTableError { get; set; } = true;
public int MaxQueryConnectionsLimit { get; set; } = Environment.ProcessorCount; // public int MaxQueryConnectionsLimit { get; set; } = Environment.ProcessorCount;
public ConnectionModeEnum ConnectionMode { get; set; } = ConnectionModeEnum.SYSTEM_AUTO; // public ConnectionModeEnum ConnectionMode { get; set; } = ConnectionModeEnum.SYSTEM_AUTO;
public bool? EnableTableRouteCompileCache { get; set; } // public bool? EnableTableRouteCompileCache { get; set; }
public bool? EnableDataSourceRouteCompileCache { get; set; } // public bool? EnableDataSourceRouteCompileCache { get; set; }
//
private readonly ISet<Type> _createTableEntities = new HashSet<Type>(); // private readonly ISet<Type> _createTableEntities = new HashSet<Type>();
//
public void AddEntitiesTryCreateTable(params Type[] entityTypes) // public void AddEntitiesTryCreateTable(params Type[] entityTypes)
{ // {
foreach (var entityType in entityTypes) // foreach (var entityType in entityTypes)
{ // {
_createTableEntities.Add(entityType); // _createTableEntities.Add(entityType);
} // }
//
} // }
//
public ISet<Type> GetCreateTableEntities() // public ISet<Type> GetCreateTableEntities()
{ // {
return _createTableEntities; // return _createTableEntities;
} // }
//
public readonly ISet<ParallelTableGroupNode> _parallelTables = new HashSet<ParallelTableGroupNode>(); // public readonly ISet<ParallelTableGroupNode> _parallelTables = new HashSet<ParallelTableGroupNode>();
//
public bool AddParallelTables(params Type[] types) // public bool AddParallelTables(params Type[] types)
{ // {
if (types.Length <= 0) // if (types.Length <= 0)
throw new ShardingCoreInvalidOperationException( // throw new ShardingCoreInvalidOperationException(
$"{nameof(AddParallelTables)} args :[{string.Join(",", types.Select(o => o.Name))}] should more than one length"); // $"{nameof(AddParallelTables)} args :[{string.Join(",", types.Select(o => o.Name))}] should more than one length");
return _parallelTables.Add(new ParallelTableGroupNode(types.Select(o => new ParallelTableComparerType(o)))); // return _parallelTables.Add(new ParallelTableGroupNode(types.Select(o => new ParallelTableComparerType(o))));
} // }
public ISet<ParallelTableGroupNode> GetParallelTableGroupNodes() // public ISet<ParallelTableGroupNode> GetParallelTableGroupNodes()
{ // {
return _parallelTables; // return _parallelTables;
} // }
} // }
} // }

28
src/ShardingCore/Core/ShardingConfigurations/ShardingConfigOptions.cs
View File

@ -1,7 +1,5 @@
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using ShardingCore.Sharding.ReadWriteConfigurations; using ShardingCore.Sharding.ReadWriteConfigurations;
using ShardingCore.Sharding.ShardingComparision;
using ShardingCore.Sharding.ShardingComparision.Abstractions;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Data.Common; using System.Data.Common;
@ -10,14 +8,6 @@ namespace ShardingCore.Core.ShardingConfigurations
{ {
public class ShardingConfigOptions public class ShardingConfigOptions
{ {
/// <summary>
/// 配置id,如果是单配置可以用guid代替,如果是多配置该属性表示每个配置的id
/// </summary>
public string ConfigId { get; set; }
/// <summary>
/// 优先级多个配置之间的优先级
/// </summary>
public int Priority { get; set; }
/// <summary> /// <summary>
/// 全局配置最大的查询连接数限制,默认系统逻辑处理器<code>Environment.ProcessorCount</code> /// 全局配置最大的查询连接数限制,默认系统逻辑处理器<code>Environment.ProcessorCount</code>
/// </summary> /// </summary>
@ -49,13 +39,13 @@ namespace ShardingCore.Core.ShardingConfigurations
DefaultDataSourceName= dataSourceName?? throw new ArgumentNullException(nameof(dataSourceName)); DefaultDataSourceName= dataSourceName?? throw new ArgumentNullException(nameof(dataSourceName));
DefaultConnectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString)); DefaultConnectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString));
} }
public Func<IServiceProvider, IDictionary<string, string>> DataSourcesConfigure { get; private set; } public Func<IShardingProvider, IDictionary<string, string>> DataSourcesConfigure { get; private set; }
/// <summary> /// <summary>
/// 添加额外数据源 /// 添加额外数据源
/// </summary> /// </summary>
/// <param name="extraDataSourceConfigure"></param> /// <param name="extraDataSourceConfigure"></param>
/// <exception cref="ArgumentNullException"></exception> /// <exception cref="ArgumentNullException"></exception>
public void AddExtraDataSource(Func<IServiceProvider, IDictionary<string, string>> extraDataSourceConfigure) public void AddExtraDataSource(Func<IShardingProvider, IDictionary<string, string>> extraDataSourceConfigure)
{ {
DataSourcesConfigure= extraDataSourceConfigure ?? throw new ArgumentNullException(nameof(extraDataSourceConfigure)); DataSourcesConfigure= extraDataSourceConfigure ?? throw new ArgumentNullException(nameof(extraDataSourceConfigure));
} }
@ -69,7 +59,7 @@ namespace ShardingCore.Core.ShardingConfigurations
/// <param name="readConnStringGetStrategy">LatestFirstTime:DbContext缓存,LatestEveryTime:每次都是最新</param> /// <param name="readConnStringGetStrategy">LatestFirstTime:DbContext缓存,LatestEveryTime:每次都是最新</param>
/// <exception cref="ArgumentNullException"></exception> /// <exception cref="ArgumentNullException"></exception>
public void AddReadWriteSeparation( public void AddReadWriteSeparation(
Func<IServiceProvider, IDictionary<string, IEnumerable<string>>> readWriteSeparationConfigure, Func<IShardingProvider, IDictionary<string, IEnumerable<string>>> readWriteSeparationConfigure,
ReadStrategyEnum readStrategyEnum, ReadStrategyEnum readStrategyEnum,
bool defaultEnable = false, bool defaultEnable = false,
int defaultPriority = 10, int defaultPriority = 10,
@ -83,7 +73,7 @@ namespace ShardingCore.Core.ShardingConfigurations
ShardingReadWriteSeparationOptions.ReadConnStringGetStrategy= readConnStringGetStrategy; ShardingReadWriteSeparationOptions.ReadConnStringGetStrategy= readConnStringGetStrategy;
} }
public void AddReadWriteNodeSeparation( public void AddReadWriteNodeSeparation(
Func<IServiceProvider, IDictionary<string, IEnumerable<ReadNode>>> readWriteNodeSeparationConfigure, Func<IShardingProvider, IDictionary<string, IEnumerable<ReadNode>>> readWriteNodeSeparationConfigure,
ReadStrategyEnum readStrategyEnum, ReadStrategyEnum readStrategyEnum,
bool defaultEnable = false, bool defaultEnable = false,
int defaultPriority = 10, int defaultPriority = 10,
@ -150,16 +140,6 @@ namespace ShardingCore.Core.ShardingConfigurations
{ {
ShellDbContextConfigure = shellDbContextConfigure ?? throw new ArgumentNullException(nameof(shellDbContextConfigure)); ShellDbContextConfigure = shellDbContextConfigure ?? throw new ArgumentNullException(nameof(shellDbContextConfigure));
} }
public Func<IServiceProvider, IShardingComparer> ReplaceShardingComparerFactory { get; private set; } = sp => new CSharpLanguageShardingComparer();
/// <summary>
/// 替换默认的比较器
/// </summary>
/// <param name="newShardingComparerFactory"></param>
/// <exception cref="ArgumentNullException"></exception>
public void ReplaceShardingComparer(Func<IServiceProvider, IShardingComparer> newShardingComparerFactory)
{
ReplaceShardingComparerFactory = newShardingComparerFactory ?? throw new ArgumentNullException(nameof(newShardingComparerFactory));
}
// public Func<IServiceProvider, ITableEnsureManager<TShardingDbContext>> TableEnsureManagerFactory = // public Func<IServiceProvider, ITableEnsureManager<TShardingDbContext>> TableEnsureManagerFactory =
// sp => new EmptyTableEnsureManager<TShardingDbContext>(); // sp => new EmptyTableEnsureManager<TShardingDbContext>();

64
src/ShardingCore/Core/ShardingConfigurations/ShardingMultiConfigurationOptions.cs
View File

@ -1,32 +1,32 @@
using Microsoft.EntityFrameworkCore; // using Microsoft.EntityFrameworkCore;
using ShardingCore.Core.ShardingConfigurations.Abstractions; // using ShardingCore.Core.ShardingConfigurations.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Common; // using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Common;
using ShardingCore.Exceptions; // using ShardingCore.Exceptions;
using ShardingCore.Sharding.Abstractions; // using ShardingCore.Sharding.Abstractions;
using System.Collections.Generic; // using System.Collections.Generic;
using System.Linq; // using System.Linq;
//
namespace ShardingCore.Core.ShardingConfigurations // namespace ShardingCore.Core.ShardingConfigurations
{ // {
public class ShardingMultiConfigurationOptions : IShardingConfigurationOptions // public class ShardingMultiConfigurationOptions : IShardingConfigurationOptions
{ // {
public ShardingConfigurationStrategyEnum ShardingConfigurationStrategy { get; set; } = // public ShardingConfigurationStrategyEnum ShardingConfigurationStrategy { get; set; } =
ShardingConfigurationStrategyEnum.ThrowIfNull; // ShardingConfigurationStrategyEnum.ThrowIfNull;
//
private Dictionary<string, ShardingConfigOptions> _shardingGlobalConfigOptions = new (); // private Dictionary<string, ShardingConfigOptions> _shardingGlobalConfigOptions = new ();
//
public void AddShardingGlobalConfigOptions(ShardingConfigOptions shardingConfigOptions) // public void AddShardingGlobalConfigOptions(ShardingConfigOptions shardingConfigOptions)
{ // {
if (_shardingGlobalConfigOptions.ContainsKey(shardingConfigOptions.ConfigId)) // if (_shardingGlobalConfigOptions.ContainsKey(shardingConfigOptions.ConfigId))
throw new ShardingCoreInvalidOperationException($"repeat add config id:[{shardingConfigOptions.ConfigId}]"); // throw new ShardingCoreInvalidOperationException($"repeat add config id:[{shardingConfigOptions.ConfigId}]");
//
_shardingGlobalConfigOptions.Add(shardingConfigOptions.ConfigId, shardingConfigOptions); // _shardingGlobalConfigOptions.Add(shardingConfigOptions.ConfigId, shardingConfigOptions);
} // }
//
public ShardingConfigOptions[] GetAllShardingGlobalConfigOptions() // public ShardingConfigOptions[] GetAllShardingGlobalConfigOptions()
{ // {
return _shardingGlobalConfigOptions.Values.ToArray(); // return _shardingGlobalConfigOptions.Values.ToArray();
} // }
//
} // }
} // }

4
src/ShardingCore/Core/ShardingConfigurations/ShardingReadWriteSeparationOptions.cs
View File

@ -6,8 +6,8 @@ namespace ShardingCore.Core.ShardingConfigurations
{ {
public class ShardingReadWriteSeparationOptions public class ShardingReadWriteSeparationOptions
{ {
public Func<IServiceProvider, IDictionary<string, IEnumerable<string>>> ReadWriteSeparationConfigure { get; set; } public Func<IShardingProvider, IDictionary<string, IEnumerable<string>>> ReadWriteSeparationConfigure { get; set; }
public Func<IServiceProvider, IDictionary<string, IEnumerable<ReadNode>>> ReadWriteNodeSeparationConfigure { get; set; } public Func<IShardingProvider, IDictionary<string, IEnumerable<ReadNode>>> ReadWriteNodeSeparationConfigure { get; set; }
public ReadStrategyEnum ReadStrategy { get; set; } = ReadStrategyEnum.Loop; public ReadStrategyEnum ReadStrategy { get; set; } = ReadStrategyEnum.Loop;
public bool DefaultEnable { get; set; } = false; public bool DefaultEnable { get; set; } = false;

118
src/ShardingCore/Core/ShardingConfigurations/ShardingEntityConfigOptions.cs → src/ShardingCore/Core/ShardingConfigurations/ShardingRouteConfigOptions.cs
View File

@ -15,37 +15,37 @@ using ShardingCore.Sharding.ParallelTables;
namespace ShardingCore.Core.ShardingConfigurations namespace ShardingCore.Core.ShardingConfigurations
{ {
public class ShardingEntityConfigOptions : IShardingEntityConfigOptions public class ShardingRouteConfigOptions : IShardingRouteConfigOptions
{ {
private readonly IDictionary<Type, Type> _virtualDataSourceRoutes = new Dictionary<Type, Type>(); private readonly IDictionary<Type, Type> _virtualDataSourceRoutes = new Dictionary<Type, Type>();
private readonly IDictionary<Type, Type> _virtualTableRoutes = new Dictionary<Type, Type>(); private readonly IDictionary<Type, Type> _virtualTableRoutes = new Dictionary<Type, Type>();
private readonly ISet<ParallelTableGroupNode> _parallelTables = new HashSet<ParallelTableGroupNode>(); private readonly ISet<ParallelTableGroupNode> _parallelTables = new HashSet<ParallelTableGroupNode>();
/// <summary> // /// <summary>
/// 如果数据库不存在就创建并且创建表除了分表的 // /// 如果数据库不存在就创建并且创建表除了分表的
/// </summary> // /// </summary>
public bool EnsureCreatedWithOutShardingTable { get; set; } // public bool EnsureCreatedWithOutShardingTable { get; set; }
//
/// <summary> // /// <summary>
/// 是否需要在启动时创建分表 // /// 是否需要在启动时创建分表
/// </summary> // /// </summary>
public bool? CreateShardingTableOnStart { get; set; } // public bool? CreateShardingTableOnStart { get; set; }
/// <summary> // /// <summary>
/// 是否在启动时创建数据库 // /// 是否在启动时创建数据库
/// </summary> // /// </summary>
public bool? CreateDataBaseOnlyOnStart { get; set; } // public bool? CreateDataBaseOnlyOnStart { get; set; }
/// <summary> // /// <summary>
/// 当查询遇到没有路由被命中时是否抛出错误 // /// 当查询遇到没有路由被命中时是否抛出错误
/// </summary> // /// </summary>
public bool ThrowIfQueryRouteNotMatch { get; set; } = true; // public bool ThrowIfQueryRouteNotMatch { get; set; } = true;
///// <summary> // ///// <summary>
///// 全局启用分表路由表达式缓存,仅缓存单个表达式 // ///// 全局启用分表路由表达式缓存,仅缓存单个表达式
///// </summary> // ///// </summary>
//public bool? EnableTableRouteCompileCache { get; set; } // //public bool? EnableTableRouteCompileCache { get; set; }
///// <summary> // ///// <summary>
///// 全局启用分库路由表达式缓存,仅缓存单个表达式 // ///// 全局启用分库路由表达式缓存,仅缓存单个表达式
///// </summary> // ///// </summary>
//public bool? EnableDataSourceRouteCompileCache { get; set; } // //public bool? EnableDataSourceRouteCompileCache { get; set; }
/// <summary> /// <summary>
/// 忽略建表时的错误 /// 忽略建表时的错误
/// </summary> /// </summary>
@ -59,6 +59,9 @@ namespace ShardingCore.Core.ShardingConfigurations
var routeType = typeof(TRoute); var routeType = typeof(TRoute);
AddShardingDataSourceRoute(routeType); AddShardingDataSourceRoute(routeType);
} }
public bool ThrowIfQueryRouteNotMatch { get; set; } = true;
public void AddShardingDataSourceRoute(Type routeType) public void AddShardingDataSourceRoute(Type routeType)
{ {
if (!routeType.IsVirtualDataSourceRoute()) if (!routeType.IsVirtualDataSourceRoute())
@ -151,48 +154,25 @@ namespace ShardingCore.Core.ShardingConfigurations
{ {
return _parallelTables; return _parallelTables;
} }
/// <summary> // /// <summary>
/// 多个DbContext事务传播委托 // /// 仅内部DbContext生效的配置委托
/// </summary> // /// </summary>
public Action<DbConnection, DbContextOptionsBuilder> ConnectionConfigure { get; private set; } // public Action<DbContextOptionsBuilder> ExecutorDbContextConfigure { get; private set; }
/// <summary> // public Action<DbContextOptionsBuilder> ShellDbContextConfigure { get; private set; }
/// 初始DbContext的创建委托 //
/// </summary> // /// <summary>
public Action<string, DbContextOptionsBuilder> ConnectionStringConfigure { get; private set; } // /// 仅内部真实DbContext配置的方法
/// <summary> // /// </summary>
/// 仅内部DbContext生效的配置委托 // /// <param name="executorDbContextConfigure"></param>
/// </summary> // /// <exception cref="ArgumentNullException"></exception>
public Action<DbContextOptionsBuilder> ExecutorDbContextConfigure { get; private set; } // public void UseExecutorDbContextConfigure(Action<DbContextOptionsBuilder> executorDbContextConfigure)
public Action<DbContextOptionsBuilder> ShellDbContextConfigure { get; private set; } // {
// ExecutorDbContextConfigure = executorDbContextConfigure ?? throw new ArgumentNullException(nameof(executorDbContextConfigure));
// }
/// <summary> //
/// 如何使用字符串创建DbContext // public void UseShellDbContextConfigure(Action<DbContextOptionsBuilder> shellDbContextConfigure)
/// </summary> // {
public void UseShardingQuery(Action<string, DbContextOptionsBuilder> queryConfigure) // ShellDbContextConfigure = shellDbContextConfigure ?? throw new ArgumentNullException(nameof(shellDbContextConfigure));
{ // }
ConnectionStringConfigure = queryConfigure ?? throw new ArgumentNullException(nameof(queryConfigure));
}
/// <summary>
/// 如何传递事务到其他DbContext
/// </summary>
public void UseShardingTransaction(Action<DbConnection, DbContextOptionsBuilder> transactionConfigure)
{
ConnectionConfigure = transactionConfigure ?? throw new ArgumentNullException(nameof(transactionConfigure));
}
/// <summary>
/// 仅内部真实DbContext配置的方法
/// </summary>
/// <param name="executorDbContextConfigure"></param>
/// <exception cref="ArgumentNullException"></exception>
public void UseExecutorDbContextConfigure(Action<DbContextOptionsBuilder> executorDbContextConfigure)
{
ExecutorDbContextConfigure = executorDbContextConfigure ?? throw new ArgumentNullException(nameof(executorDbContextConfigure));
}
public void UseShellDbContextConfigure(Action<DbContextOptionsBuilder> shellDbContextConfigure)
{
ShellDbContextConfigure = shellDbContextConfigure ?? throw new ArgumentNullException(nameof(shellDbContextConfigure));
}
} }
} }

56
src/ShardingCore/Core/ShardingConfigurations/ShardingSingleConfigurationOptions.cs
View File

@ -1,28 +1,28 @@
using Microsoft.EntityFrameworkCore; // using Microsoft.EntityFrameworkCore;
using ShardingCore.Core.ShardingConfigurations.Abstractions; // using ShardingCore.Core.ShardingConfigurations.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Common; // using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Common;
using ShardingCore.Exceptions; // using ShardingCore.Exceptions;
using ShardingCore.Sharding.Abstractions; // using ShardingCore.Sharding.Abstractions;
//
namespace ShardingCore.Core.ShardingConfigurations // namespace ShardingCore.Core.ShardingConfigurations
{ // {
public class ShardingSingleConfigurationOptions : IShardingConfigurationOptions // public class ShardingSingleConfigurationOptions : IShardingConfigurationOptions
{ // {
//
private ShardingConfigOptions _shardingConfigOptions; // private ShardingConfigOptions _shardingConfigOptions;
public ShardingConfigurationStrategyEnum ShardingConfigurationStrategy { get; set; } = // public ShardingConfigurationStrategyEnum ShardingConfigurationStrategy { get; set; } =
ShardingConfigurationStrategyEnum.ThrowIfNull; // ShardingConfigurationStrategyEnum.ThrowIfNull;
//
public void AddShardingGlobalConfigOptions(ShardingConfigOptions shardingConfigOptions) // public void AddShardingGlobalConfigOptions(ShardingConfigOptions shardingConfigOptions)
{ // {
if (_shardingConfigOptions != null) // if (_shardingConfigOptions != null)
throw new ShardingCoreInvalidOperationException($"repeat add {nameof(ShardingConfigOptions)}"); // throw new ShardingCoreInvalidOperationException($"repeat add {nameof(ShardingConfigOptions)}");
_shardingConfigOptions= shardingConfigOptions; // _shardingConfigOptions= shardingConfigOptions;
} // }
//
public ShardingConfigOptions[] GetAllShardingGlobalConfigOptions() // public ShardingConfigOptions[] GetAllShardingGlobalConfigOptions()
{ // {
return new[] { _shardingConfigOptions }; // return new[] { _shardingConfigOptions };
} // }
} // }
} // }

33
src/ShardingCore/Core/ShardingProvider.cs Normal file
View File

@ -0,0 +1,33 @@
using System;
using ShardingCore.Core;
using ShardingCore.Exceptions;
namespace ShardingCore.Core
{
public class ShardingProvider:IShardingProvider
{
private readonly IServiceProvider _internalServiceProvider;
private readonly IServiceProvider _applicationServiceProvider;
public ShardingProvider(IServiceProvider internalServiceProvider,IServiceProvider applicationServiceProvider)
{
_internalServiceProvider = internalServiceProvider;
_applicationServiceProvider = applicationServiceProvider;
}
public object GetService(Type serviceType)
{
var service = _internalServiceProvider?.GetService(serviceType);
if (service == null)
{
service= _applicationServiceProvider?.GetService(serviceType);
}
if (service == null)
{
throw new ShardingCoreInvalidOperationException($"cant unable resolve service:[{serviceType}]");
}
return service;
}
}
}

161
src/ShardingCore/Core/ShardingRuntimeContext.cs
View File

@ -6,36 +6,39 @@ using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using ShardingCore.Bootstrappers; using ShardingCore.Bootstrappers;
using ShardingCore.Core.DbContextCreator;
using ShardingCore.Core.EntityMetadatas;
using ShardingCore.Core.QueryRouteManagers.Abstractions; using ShardingCore.Core.QueryRouteManagers.Abstractions;
using ShardingCore.Core.QueryTrackers;
using ShardingCore.Core.ShardingConfigurations.Abstractions; using ShardingCore.Core.ShardingConfigurations.Abstractions;
using ShardingCore.Core.ShardingPage.Abstractions;
using ShardingCore.Core.TrackerManagers;
using ShardingCore.Core.UnionAllMergeShardingProviders.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
using ShardingCore.Core.VirtualRoutes.Abstractions;
using ShardingCore.Core.VirtualRoutes.TableRoutes.RouteTails.Abstractions;
using ShardingCore.Exceptions; using ShardingCore.Exceptions;
using ShardingCore.Extensions; using ShardingCore.Extensions;
using ShardingCore.Logger; using ShardingCore.Logger;
using ShardingCore.Sharding.Abstractions; using ShardingCore.Sharding.Abstractions;
using ShardingCore.Sharding.MergeEngines.ParallelControl; using ShardingCore.Sharding.MergeEngines.ParallelControl;
using ShardingCore.Sharding.ParallelTables;
using ShardingCore.Sharding.ReadWriteConfigurations.Abstractions;
namespace ShardingCore.Core namespace ShardingCore.Core
{ {
public sealed class ShardingRuntimeContext public sealed class ShardingRuntimeContext:IShardingRuntimeContext
{ {
private bool isInited = false; private bool isInited = false;
private object INIT_LOCK = new object(); private object INIT_LOCK = new object();
private bool isInitModeled = false;
private object INIT_MODEL = new object();
private IServiceCollection _serviceMap = new ServiceCollection(); private IServiceCollection _serviceMap = new ServiceCollection();
private IServiceProvider _serviceProvider; private IServiceProvider _serviceProvider;
private IServiceProvider _applicationServiceProvider; private IServiceProvider _applicationServiceProvider;
private ShardingRuntimeContext()
{
_serviceProvider = _serviceMap.BuildServiceProvider();
}
private static readonly ShardingRuntimeContext _instance = new ShardingRuntimeContext();
public static ShardingRuntimeContext GetInstance() => _instance;
public void AddServiceConfig(Action<IServiceCollection> configure) public void AddServiceConfig(Action<IServiceCollection> configure)
{ {
CheckIfBuild(); CheckIfBuild();
@ -45,28 +48,99 @@ namespace ShardingCore.Core
public void Initialize() public void Initialize()
{ {
if (isInited) if (isInited)
{
return; return;
}
lock (INIT_LOCK) lock (INIT_LOCK)
{ {
if (isInited) if (isInited)
{
return; return;
}
_serviceProvider = _serviceMap.BuildServiceProvider(); _serviceProvider = _serviceMap.BuildServiceProvider();
_serviceProvider.GetRequiredService<IShardingBootstrapper>().Start(); _serviceProvider.GetRequiredService<IShardingBootstrapper>().Start();
isInited = true; isInited = true;
} }
} }
public IShardingCompilerExecutor GetShardingCompilerExecutor()
{
return GetRequiredService<IShardingCompilerExecutor>();
}
public IShardingReadWriteManager GetShardingReadWriteManager()
{
return GetRequiredService<IShardingReadWriteManager>();
}
public ITrackerManager GetTrackerManager()
{
return GetRequiredService<ITrackerManager>();
}
public IParallelTableManager GetParallelTableManager()
{
return GetRequiredService<IParallelTableManager>();
}
public IDbContextCreator GetDbContextCreator()
{
return GetRequiredService<IDbContextCreator>();
}
public IEntityMetadataManager GetEntityMetadataManager()
{
return GetRequiredService<IEntityMetadataManager>();
}
public IVirtualDataSource GetVirtualDataSource()
{
return GetRequiredService<IVirtualDataSource>();
}
public ITableRouteManager GetTableRouteManager()
{
return GetRequiredService<ITableRouteManager>();
}
public IRouteTailFactory GetRouteTailFactory()
{
return GetRequiredService<IRouteTailFactory>();
}
public IQueryTracker GetQueryTracker()
{
return GetRequiredService<IQueryTracker>();
}
public IUnionAllMergeManager GetUnionAllMergeManager()
{
return GetRequiredService<IUnionAllMergeManager>();
}
public IShardingPageManager GetShardingPageManager()
{
return GetRequiredService<IShardingPageManager>();
}
public void GetOrCreateShardingRuntimeModel(DbContext dbContext)
{
if (isInitModeled) return;
lock (INIT_MODEL)
{
if(isInitModeled) return;
var entityMetadataManager = GetService<IEntityMetadataManager>();
var entityTypes = dbContext.Model.GetEntityTypes();
foreach (var entityType in entityTypes)
{
entityMetadataManager.TryInitModel(entityType);
}
}
}
public void UseLogfactory(ILoggerFactory loggerFactory) public void UseLogfactory(ILoggerFactory loggerFactory)
{ {
InternalLoggerFactory.DefaultFactory = loggerFactory; InternalLoggerFactory.DefaultFactory = loggerFactory;
} }
public void WithApplicationServiceProvider(IServiceProvider applicationServiceProvider) public void UseApplicationServiceProvider(IServiceProvider applicationServiceProvider)
{ {
_applicationServiceProvider = applicationServiceProvider; _applicationServiceProvider = applicationServiceProvider;
} }
@ -82,30 +156,6 @@ namespace ShardingCore.Core
throw new InvalidOperationException("sharding runtime not init"); throw new InvalidOperationException("sharding runtime not init");
} }
/// <summary>
/// 创建一个没有依赖注入的对象,但是对象的构造函数参数是已经可以通过依赖注入获取的
/// </summary>
/// <param name="serviceType"></param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
public object CreateInstance(Type serviceType)
{
var constructors
= serviceType.GetTypeInfo().DeclaredConstructors
.Where(c => !c.IsStatic && c.IsPublic)
.ToArray();
if (constructors.Length != 1)
{
throw new ArgumentException(
$"type :[{serviceType}] found more than one declared constructor ");
}
var @params = constructors[0].GetParameters().Select(x => GetRequiredService(x.ParameterType))
.ToArray();
return Activator.CreateInstance(serviceType, @params);
}
public object GetService(Type serviceType) public object GetService(Type serviceType)
{ {
CheckIfNotBuild(); CheckIfNotBuild();
@ -117,34 +167,31 @@ namespace ShardingCore.Core
CheckIfNotBuild(); CheckIfNotBuild();
return _serviceProvider.GetService<TService>(); return _serviceProvider.GetService<TService>();
} }
private object GetRequiredService(Type serviceType)
{
var service = _serviceProvider?.GetService(serviceType);
if (service == null)
{
service= _applicationServiceProvider?.GetService(serviceType);
}
if (service == null) public object GetRequiredService(Type serviceType)
{ {
throw new ShardingCoreInvalidOperationException($"cant unable resolve service:[{serviceType}]"); CheckIfNotBuild();
} return _serviceProvider.GetRequiredService(serviceType);
return service;
} }
public TService GetRequiredService<TService>()
{
CheckIfNotBuild();
return _serviceProvider.GetRequiredService<TService>();
}
public IShardingRouteManager GetShardingRouteManager() public IShardingRouteManager GetShardingRouteManager()
{ {
return GetService<IShardingRouteManager>(); return GetRequiredService<IShardingRouteManager>();
} }
// //
// public IShardingEntityConfigOptions<TShardingDbContext> GetRequiredShardingEntityConfigOption<TShardingDbContext>() // public IShardingRouteConfigOptions<TShardingDbContext> GetRequiredShardingEntityConfigOption<TShardingDbContext>()
// where TShardingDbContext : DbContext, IShardingDbContext // where TShardingDbContext : DbContext, IShardingDbContext
// { // {
// return (IShardingEntityConfigOptions<TShardingDbContext>)GetRequiredShardingEntityConfigOption(typeof(TShardingDbContext)); // return (IShardingRouteConfigOptions<TShardingDbContext>)GetRequiredShardingEntityConfigOption(typeof(TShardingDbContext));
// } // }
// public IShardingEntityConfigOptions GetRequiredShardingEntityConfigOption(Type shardingDbContextType) // public IShardingRouteConfigOptions GetRequiredShardingEntityConfigOption(Type shardingDbContextType)
// { // {
// return (IShardingEntityConfigOptions)GetService(typeof(IShardingEntityConfigOptions<>).GetGenericType0(shardingDbContextType)); // return (IShardingRouteConfigOptions)GetService(typeof(IShardingRouteConfigOptions<>).GetGenericType0(shardingDbContextType));
// } // }
} }
} }

3
src/ShardingCore/Core/VirtualDatabase/VirtualDataSources/Abstractions/AbstractVirtualDataSourceConfigurationParams.cs
View File

@ -14,8 +14,6 @@ namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions
{ {
public abstract class AbstractVirtualDataSourceConfigurationParams:IVirtualDataSourceConfigurationParams public abstract class AbstractVirtualDataSourceConfigurationParams:IVirtualDataSourceConfigurationParams
{ {
public abstract string ConfigId { get; }
public abstract int Priority { get; }
public virtual int MaxQueryConnectionsLimit { get; } = Environment.ProcessorCount; public virtual int MaxQueryConnectionsLimit { get; } = Environment.ProcessorCount;
public virtual ConnectionModeEnum ConnectionMode { get; } = ConnectionModeEnum.SYSTEM_AUTO; public virtual ConnectionModeEnum ConnectionMode { get; } = ConnectionModeEnum.SYSTEM_AUTO;
public abstract string DefaultDataSourceName { get; } public abstract string DefaultDataSourceName { get; }
@ -26,7 +24,6 @@ namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions
public virtual bool? ReadWriteDefaultEnable { get; } public virtual bool? ReadWriteDefaultEnable { get; }
public virtual int? ReadWriteDefaultPriority { get; } public virtual int? ReadWriteDefaultPriority { get; }
public virtual ReadConnStringGetStrategyEnum? ReadConnStringGetStrategy { get; } public virtual ReadConnStringGetStrategyEnum? ReadConnStringGetStrategy { get; }
public virtual IShardingComparer ShardingComparer { get; } = new CSharpLanguageShardingComparer();
public abstract DbContextOptionsBuilder UseDbContextOptionsBuilder(string connectionString, public abstract DbContextOptionsBuilder UseDbContextOptionsBuilder(string connectionString,
DbContextOptionsBuilder dbContextOptionsBuilder); DbContextOptionsBuilder dbContextOptionsBuilder);

12
src/ShardingCore/Core/VirtualDatabase/VirtualDataSources/Abstractions/IVirtualDataSourceConfigurationParams.cs
View File

@ -9,14 +9,6 @@ namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions
{ {
public interface IVirtualDataSourceConfigurationParams public interface IVirtualDataSourceConfigurationParams
{ {
/// <summary>
/// 配置id
/// </summary>
string ConfigId { get; }
/// <summary>
/// 优先级
/// </summary>
int Priority { get; }
/// <summary> /// <summary>
/// 不能小于等于0 should greater than or equal zero /// 不能小于等于0 should greater than or equal zero
/// </summary> /// </summary>
@ -51,10 +43,6 @@ namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions
/// </summary> /// </summary>
ReadConnStringGetStrategyEnum? ReadConnStringGetStrategy { get; } ReadConnStringGetStrategyEnum? ReadConnStringGetStrategy { get; }
/// <summary> /// <summary>
/// 不能为空 should not null
/// </summary>
IShardingComparer ShardingComparer { get; }
/// <summary>
/// 如何根据connectionString 配置 DbContextOptionsBuilder /// 如何根据connectionString 配置 DbContextOptionsBuilder
/// </summary> /// </summary>
/// <param name="connectionString"></param> /// <param name="connectionString"></param>

8
src/ShardingCore/Core/VirtualDatabase/VirtualDataSources/IVirtualDataSource.cs
View File

@ -20,14 +20,6 @@ namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
public interface IVirtualDataSource public interface IVirtualDataSource
{ {
/// <summary>
/// 配置id
/// </summary>
string ConfigId { get; }
/// <summary>
/// 当前配置的优先级
/// </summary>
int Priority { get; }
/// <summary> /// <summary>
/// 数据源配置 /// 数据源配置
/// </summary> /// </summary>

62
src/ShardingCore/Core/VirtualDatabase/VirtualDataSources/SimpleVirtualDataSourceConfigurationParams.cs
View File

@ -17,9 +17,6 @@ namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
public class SimpleVirtualDataSourceConfigurationParams: AbstractVirtualDataSourceConfigurationParams public class SimpleVirtualDataSourceConfigurationParams: AbstractVirtualDataSourceConfigurationParams
{ {
private readonly ShardingConfigOptions _options; private readonly ShardingConfigOptions _options;
private readonly IShardingEntityConfigOptions _shardingEntityConfigOptions;
public override string ConfigId { get; }
public override int Priority { get; }
public override int MaxQueryConnectionsLimit { get; } public override int MaxQueryConnectionsLimit { get; }
public override ConnectionModeEnum ConnectionMode { get; } public override ConnectionModeEnum ConnectionMode { get; }
public override string DefaultDataSourceName { get; } public override string DefaultDataSourceName { get; }
@ -30,27 +27,22 @@ namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
public override bool? ReadWriteDefaultEnable { get; } public override bool? ReadWriteDefaultEnable { get; }
public override int? ReadWriteDefaultPriority { get; } public override int? ReadWriteDefaultPriority { get; }
public override ReadConnStringGetStrategyEnum? ReadConnStringGetStrategy { get; } public override ReadConnStringGetStrategyEnum? ReadConnStringGetStrategy { get; }
public override IShardingComparer ShardingComparer { get; }
public SimpleVirtualDataSourceConfigurationParams(IServiceProvider serviceProvider,ShardingConfigOptions options) public SimpleVirtualDataSourceConfigurationParams(IShardingProvider shardingProvider,ShardingConfigOptions options)
{ {
_shardingEntityConfigOptions = serviceProvider.GetService<IShardingEntityConfigOptions>();
_options = options; _options = options;
ConfigId = options.ConfigId;
Priority = options.Priority;
MaxQueryConnectionsLimit = options.MaxQueryConnectionsLimit; MaxQueryConnectionsLimit = options.MaxQueryConnectionsLimit;
ConnectionMode = options.ConnectionMode; ConnectionMode = options.ConnectionMode;
DefaultDataSourceName = options.DefaultDataSourceName; DefaultDataSourceName = options.DefaultDataSourceName;
DefaultConnectionString = options.DefaultConnectionString; DefaultConnectionString = options.DefaultConnectionString;
ExtraDataSources = options.DataSourcesConfigure?.Invoke(serviceProvider)??new ConcurrentDictionary<string, string>(); ExtraDataSources = options.DataSourcesConfigure?.Invoke(shardingProvider)??new ConcurrentDictionary<string, string>();
ShardingComparer = options.ReplaceShardingComparerFactory?.Invoke(serviceProvider) ??
new CSharpLanguageShardingComparer();
if (options.ShardingReadWriteSeparationOptions != null) if (options.ShardingReadWriteSeparationOptions != null)
{ {
if (options.ShardingReadWriteSeparationOptions.ReadWriteNodeSeparationConfigure != null) if (options.ShardingReadWriteSeparationOptions.ReadWriteNodeSeparationConfigure != null)
{ {
var readConfig = options.ShardingReadWriteSeparationOptions.ReadWriteNodeSeparationConfigure?.Invoke(serviceProvider); var readConfig = options.ShardingReadWriteSeparationOptions.ReadWriteNodeSeparationConfigure?.Invoke(shardingProvider);
if (readConfig != null) if (readConfig != null)
{ {
ReadWriteNodeSeparationConfigs = readConfig.ToDictionary(kv=>kv.Key,kv=>kv.Value.ToArray()); ReadWriteNodeSeparationConfigs = readConfig.ToDictionary(kv=>kv.Key,kv=>kv.Value.ToArray());
@ -58,7 +50,7 @@ namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
} }
else else
{ {
var nodeConfig = options.ShardingReadWriteSeparationOptions.ReadWriteSeparationConfigure?.Invoke(serviceProvider); var nodeConfig = options.ShardingReadWriteSeparationOptions.ReadWriteSeparationConfigure?.Invoke(shardingProvider);
if (nodeConfig != null) if (nodeConfig != null)
{ {
ReadWriteNodeSeparationConfigs = nodeConfig.ToDictionary(kv => kv.Key, ReadWriteNodeSeparationConfigs = nodeConfig.ToDictionary(kv => kv.Key,
@ -75,71 +67,43 @@ namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
public override DbContextOptionsBuilder UseDbContextOptionsBuilder(string connectionString, public override DbContextOptionsBuilder UseDbContextOptionsBuilder(string connectionString,
DbContextOptionsBuilder dbContextOptionsBuilder) DbContextOptionsBuilder dbContextOptionsBuilder)
{ {
if(_options.ConnectionStringConfigure==null&&_shardingEntityConfigOptions.ConnectionStringConfigure==null) if(_options.ConnectionStringConfigure==null)
{ {
throw new InvalidOperationException($"unknown {nameof(UseDbContextOptionsBuilder)} by connection string"); throw new InvalidOperationException($"unknown {nameof(UseDbContextOptionsBuilder)} by connection string");
} }
if (_options.ConnectionStringConfigure != null) _options.ConnectionStringConfigure.Invoke(connectionString, dbContextOptionsBuilder);
{
_options.ConnectionStringConfigure.Invoke(connectionString, dbContextOptionsBuilder);
}
else
{
_shardingEntityConfigOptions.ConnectionStringConfigure.Invoke(connectionString, dbContextOptionsBuilder);
}
return dbContextOptionsBuilder; return dbContextOptionsBuilder;
} }
public override DbContextOptionsBuilder UseDbContextOptionsBuilder(DbConnection dbConnection, public override DbContextOptionsBuilder UseDbContextOptionsBuilder(DbConnection dbConnection,
DbContextOptionsBuilder dbContextOptionsBuilder) DbContextOptionsBuilder dbContextOptionsBuilder)
{ {
if (_options.ConnectionConfigure == null && _shardingEntityConfigOptions.ConnectionConfigure == null) if (_options.ConnectionConfigure == null )
{ {
throw new InvalidOperationException($"unknown {nameof(UseDbContextOptionsBuilder)} by connection"); throw new InvalidOperationException($"unknown {nameof(UseDbContextOptionsBuilder)} by connection");
} }
if (_options.ConnectionConfigure != null) _options.ConnectionConfigure.Invoke(dbConnection, dbContextOptionsBuilder);
{
_options.ConnectionConfigure.Invoke(dbConnection, dbContextOptionsBuilder);
}
else
{
_shardingEntityConfigOptions.ConnectionConfigure.Invoke(dbConnection, dbContextOptionsBuilder);
}
return dbContextOptionsBuilder; return dbContextOptionsBuilder;
} }
public override void UseShellDbContextOptionBuilder(DbContextOptionsBuilder dbContextOptionsBuilder) public override void UseShellDbContextOptionBuilder(DbContextOptionsBuilder dbContextOptionsBuilder)
{ {
if (_options.ShellDbContextConfigure == null && _shardingEntityConfigOptions.ShellDbContextConfigure == null) if (_options.ShellDbContextConfigure == null)
{ {
return; return;
} }
if (_options.ShellDbContextConfigure != null) _options.ShellDbContextConfigure.Invoke(dbContextOptionsBuilder);
{
_options.ShellDbContextConfigure.Invoke(dbContextOptionsBuilder);
}
else
{
_shardingEntityConfigOptions.ShellDbContextConfigure?.Invoke(dbContextOptionsBuilder);
}
} }
public override void UseExecutorDbContextOptionBuilder(DbContextOptionsBuilder dbContextOptionsBuilder) public override void UseExecutorDbContextOptionBuilder(DbContextOptionsBuilder dbContextOptionsBuilder)
{ {
if (_options.ExecutorDbContextConfigure == null && _shardingEntityConfigOptions.ExecutorDbContextConfigure == null) if (_options.ExecutorDbContextConfigure == null )
{ {
return; return;
} }
if (_options.ExecutorDbContextConfigure != null) _options.ExecutorDbContextConfigure.Invoke(dbContextOptionsBuilder);
{
_options.ExecutorDbContextConfigure.Invoke(dbContextOptionsBuilder);
}
else
{
_shardingEntityConfigOptions.ExecutorDbContextConfigure?.Invoke(dbContextOptionsBuilder);
}
} }
} }
} }

4
src/ShardingCore/Core/VirtualDatabase/VirtualDataSources/VirtualDataSource.cs
View File

@ -37,9 +37,6 @@ namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
private readonly IVirtualDataSourceRouteManager _dataSourceRouteManager; private readonly IVirtualDataSourceRouteManager _dataSourceRouteManager;
private readonly IPhysicDataSourcePool _physicDataSourcePool; private readonly IPhysicDataSourcePool _physicDataSourcePool;
public string ConfigId => ConfigurationParams.ConfigId;
public int Priority => ConfigurationParams.Priority;
public string DefaultDataSourceName { get; private set; } public string DefaultDataSourceName { get; private set; }
public string DefaultConnectionString { get; private set; } public string DefaultConnectionString { get; private set; }
public bool UseReadWriteSeparation { get; } public bool UseReadWriteSeparation { get; }
@ -48,7 +45,6 @@ namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
{ {
Check.NotNull(configurationParams, nameof(configurationParams)); Check.NotNull(configurationParams, nameof(configurationParams));
Check.NotNull(configurationParams.ExtraDataSources, nameof(configurationParams.ExtraDataSources)); Check.NotNull(configurationParams.ExtraDataSources, nameof(configurationParams.ExtraDataSources));
Check.NotNull(configurationParams.ShardingComparer, nameof(configurationParams.ShardingComparer));
if(configurationParams.MaxQueryConnectionsLimit<=0) if(configurationParams.MaxQueryConnectionsLimit<=0)
throw new ArgumentOutOfRangeException(nameof(configurationParams.MaxQueryConnectionsLimit)); throw new ArgumentOutOfRangeException(nameof(configurationParams.MaxQueryConnectionsLimit));
ConfigurationParams = configurationParams; ConfigurationParams = configurationParams;

2
src/ShardingCore/Core/VirtualRoutes/DataSourceRoutes/Abstractions/AbstractShardingFilterVirtualDataSourceRoute.cs
View File

@ -22,7 +22,7 @@ namespace ShardingCore.Core.VirtualRoutes.DataSourceRoutes.Abstractions
public abstract class AbstractShardingFilterVirtualDataSourceRoute<TEntity, TKey> : AbstractVirtualDataSourceRoute<TEntity, TKey> where TEntity : class public abstract class AbstractShardingFilterVirtualDataSourceRoute<TEntity, TKey> : AbstractVirtualDataSourceRoute<TEntity, TKey> where TEntity : class
{ {
public ShardingRouteContext CurrentShardingRouteContext =>ShardingRuntimeContext.GetInstance().GetShardingRouteManager().Current; public ShardingRouteContext CurrentShardingRouteContext =>RouteShardingProvider.GetRequiredService<IShardingRouteManager>().Current;
/// <summary> /// <summary>
/// 启用提示路由 /// 启用提示路由
/// </summary> /// </summary>

2
src/ShardingCore/Core/VirtualRoutes/DataSourceRoutes/Abstractions/AbstractShardingRouteParseCompileCacheVirtualDataSourceRoute.cs
View File

@ -35,7 +35,7 @@
// { // {
// if (EnableRouteParseCompileCache.HasValue) // if (EnableRouteParseCompileCache.HasValue)
// return EnableRouteParseCompileCache.Value; // return EnableRouteParseCompileCache.Value;
// return EntityConfigOptions.EnableDataSourceRouteCompileCache.GetValueOrDefault(); // return RouteConfigOptions.EnableDataSourceRouteCompileCache.GetValueOrDefault();
// } // }
// /// <summary> // /// <summary>

27
src/ShardingCore/Core/VirtualRoutes/DataSourceRoutes/Abstractions/AbstractVirtualDataSourceRoute.cs
View File

@ -5,6 +5,7 @@ using ShardingCore.Sharding.MergeEngines.ParallelControl;
using ShardingCore.Sharding.PaginationConfigurations; using ShardingCore.Sharding.PaginationConfigurations;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using ShardingCore.Extensions;
using ShardingCore.Sharding.EntityQueryConfigurations; using ShardingCore.Sharding.EntityQueryConfigurations;
namespace ShardingCore.Core.VirtualRoutes.DataSourceRoutes.Abstractions namespace ShardingCore.Core.VirtualRoutes.DataSourceRoutes.Abstractions
@ -19,7 +20,7 @@ namespace ShardingCore.Core.VirtualRoutes.DataSourceRoutes.Abstractions
{ {
public EntityMetadata EntityMetadata { get; private set; } public EntityMetadata EntityMetadata { get; private set; }
private readonly DoOnlyOnce _doOnlyOnce = new DoOnlyOnce(); private readonly DoOnlyOnce _doOnlyOnce = new DoOnlyOnce();
public IShardingEntityConfigOptions EntityConfigOptions { get; private set; } // public IShardingRouteConfigOptions RouteConfigOptions { get; private set; }
public new PaginationMetadata PaginationMetadata { get; protected set; } public new PaginationMetadata PaginationMetadata { get; protected set; }
public bool EnablePagination => PaginationMetadata != null; public bool EnablePagination => PaginationMetadata != null;
@ -27,11 +28,15 @@ namespace ShardingCore.Core.VirtualRoutes.DataSourceRoutes.Abstractions
//public new EntityQueryMetadata EntityQueryMetadata { get; protected set; } //public new EntityQueryMetadata EntityQueryMetadata { get; protected set; }
//public bool EnableEntityQuery => EnableEntityQuery != null; //public bool EnableEntityQuery => EnableEntityQuery != null;
public void Initialize(EntityMetadata entityMetadata) public IShardingProvider RouteShardingProvider { get; private set;}
public void Initialize(EntityMetadata entityMetadata,IShardingProvider shardingProvider)
{ {
if (!_doOnlyOnce.IsUnDo()) if (!_doOnlyOnce.IsUnDo())
throw new ShardingCoreInvalidOperationException("already init"); throw new ShardingCoreInvalidOperationException("already init");
EntityMetadata = entityMetadata; EntityMetadata = entityMetadata;
// RouteConfigOptions = shardingProvider.GetService<IShardingRouteConfigOptions>();
var paginationConfiguration = CreatePaginationConfiguration(); var paginationConfiguration = CreatePaginationConfiguration();
if (paginationConfiguration != null) if (paginationConfiguration != null)
{ {
@ -39,17 +44,13 @@ namespace ShardingCore.Core.VirtualRoutes.DataSourceRoutes.Abstractions
var paginationBuilder = new PaginationBuilder<TEntity>(PaginationMetadata); var paginationBuilder = new PaginationBuilder<TEntity>(PaginationMetadata);
paginationConfiguration.Configure(paginationBuilder); paginationConfiguration.Configure(paginationBuilder);
} }
//var entityQueryConfiguration = CreateEntityQueryConfiguration(); // var entityQueryConfiguration = CreateEntityQueryConfiguration();
//if (entityQueryConfiguration != null) // if (entityQueryConfiguration != null)
//{ // {
// EntityQueryMetadata = new EntityQueryMetadata(); // EntityQueryMetadata = new EntityQueryMetadata();
// var entityQueryBuilder= new EntityQueryBuilder<TEntity>(EntityQueryMetadata); // var entityQueryBuilder= new EntityQueryBuilder<TEntity>(EntityQueryMetadata);
// entityQueryConfiguration.Configure(entityQueryBuilder); // entityQueryConfiguration.Configure(entityQueryBuilder);
//} // }
EntityConfigOptions =ShardingRuntimeContext.GetInstance().GetRequiredShardingEntityConfigOption(entityMetadata.ShardingDbContextType);
} }
public virtual IPaginationConfiguration<TEntity> CreatePaginationConfiguration() public virtual IPaginationConfiguration<TEntity> CreatePaginationConfiguration()
{ {

2
src/ShardingCore/Core/VirtualRoutes/TableRoutes/Abstractions/AbstractShardingFilterVirtualTableRoute.cs
View File

@ -23,7 +23,7 @@ namespace ShardingCore.Core.VirtualRoutes.TableRoutes.Abstractions
/// <typeparam name="TKey"></typeparam> /// <typeparam name="TKey"></typeparam>
public abstract class AbstractShardingFilterVirtualTableRoute<T, TKey> : AbstractVirtualTableRoute<T, TKey> where T : class public abstract class AbstractShardingFilterVirtualTableRoute<T, TKey> : AbstractVirtualTableRoute<T, TKey> where T : class
{ {
public ShardingRouteContext CurrentShardingRouteContext =>ShardingRuntimeContext.GetInstance().GetShardingRouteManager().Current; public ShardingRouteContext CurrentShardingRouteContext =>RouteShardingProvider.GetRequiredService<IShardingRouteManager>().Current;
/// <summary> /// <summary>
/// 启用提示路由 /// 启用提示路由
/// </summary> /// </summary>

2
src/ShardingCore/Core/VirtualRoutes/TableRoutes/Abstractions/AbstractShardingRouteParseCompileCacheVirtualTableRoute.cs
View File

@ -37,7 +37,7 @@
// { // {
// if (EnableRouteParseCompileCache.HasValue) // if (EnableRouteParseCompileCache.HasValue)
// return EnableRouteParseCompileCache.Value; // return EnableRouteParseCompileCache.Value;
// return EntityConfigOptions.EnableTableRouteCompileCache.GetValueOrDefault(); // return RouteConfigOptions.EnableTableRouteCompileCache.GetValueOrDefault();
// } // }
// /// <summary> // /// <summary>
// /// 对表达式进行缓存编译默认永久缓存单个参数表达式，且不包含orElse只包含单个AndAlso或者没有AndAlso的, // /// 对表达式进行缓存编译默认永久缓存单个参数表达式，且不包含orElse只包含单个AndAlso或者没有AndAlso的,

10
src/ShardingCore/Core/VirtualRoutes/TableRoutes/Abstractions/AbstractVirtualTableRoute.cs
View File

@ -6,6 +6,7 @@ using ShardingCore.Sharding.PaginationConfigurations;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using ShardingCore.Core.VirtualRoutes.DataSourceRoutes.RouteRuleEngine; using ShardingCore.Core.VirtualRoutes.DataSourceRoutes.RouteRuleEngine;
using ShardingCore.Extensions;
using ShardingCore.Sharding.EntityQueryConfigurations; using ShardingCore.Sharding.EntityQueryConfigurations;
using ShardingCore.Sharding.MergeEngines.Common.Abstractions; using ShardingCore.Sharding.MergeEngines.Common.Abstractions;
@ -21,16 +22,19 @@ namespace ShardingCore.Core.VirtualRoutes.TableRoutes.Abstractions
{ {
private readonly DoOnlyOnce _doOnlyOnce = new DoOnlyOnce(); private readonly DoOnlyOnce _doOnlyOnce = new DoOnlyOnce();
public IShardingEntityConfigOptions EntityConfigOptions { get; private set; } // public IShardingRouteConfigOptions RouteConfigOptions { get; private set; }
public PaginationMetadata PaginationMetadata { get; private set; } public PaginationMetadata PaginationMetadata { get; private set; }
public EntityQueryMetadata EntityQueryMetadata { get; private set; } public EntityQueryMetadata EntityQueryMetadata { get; private set; }
public virtual void Initialize(EntityMetadata entityMetadata) public IShardingProvider RouteShardingProvider { get; private set;}
public virtual void Initialize(EntityMetadata entityMetadata,IShardingProvider shardingProvider)
{ {
if (!_doOnlyOnce.IsUnDo()) if (!_doOnlyOnce.IsUnDo())
throw new ShardingCoreInvalidOperationException("already init"); throw new ShardingCoreInvalidOperationException("already init");
RouteShardingProvider = shardingProvider;
EntityMetadata = entityMetadata; EntityMetadata = entityMetadata;
EntityConfigOptions =ShardingRuntimeContext.GetInstance().GetRequiredShardingEntityConfigOption(entityMetadata.ShardingDbContextType); // RouteConfigOptions =shardingProvider.GetService<IShardingRouteConfigOptions>();
var paginationConfiguration = CreatePaginationConfiguration(); var paginationConfiguration = CreatePaginationConfiguration();
if (paginationConfiguration!=null) if (paginationConfiguration!=null)
{ {

15
src/ShardingCore/DIExtension.cs
View File

@ -38,6 +38,8 @@ using ShardingCore.Sharding.Parsers;
using ShardingCore.Sharding.Parsers.Abstractions; using ShardingCore.Sharding.Parsers.Abstractions;
using ShardingCore.Sharding.ReadWriteConfigurations; using ShardingCore.Sharding.ReadWriteConfigurations;
using ShardingCore.Sharding.ReadWriteConfigurations.Abstractions; using ShardingCore.Sharding.ReadWriteConfigurations.Abstractions;
using ShardingCore.Sharding.ShardingComparision;
using ShardingCore.Sharding.ShardingComparision.Abstractions;
using ShardingCore.Sharding.ShardingExecutors; using ShardingCore.Sharding.ShardingExecutors;
using ShardingCore.Sharding.ShardingExecutors.NativeTrackQueries; using ShardingCore.Sharding.ShardingExecutors.NativeTrackQueries;
@ -83,18 +85,15 @@ namespace ShardingCore
public static void UseDefaultSharding<TShardingDbContext>(IServiceProvider serviceProvider,DbContextOptionsBuilder dbContextOptionsBuilder) where TShardingDbContext : DbContext, IShardingDbContext public static void UseDefaultSharding<TShardingDbContext>(IServiceProvider serviceProvider,DbContextOptionsBuilder dbContextOptionsBuilder) where TShardingDbContext : DbContext, IShardingDbContext
{ {
var shardingRuntimeContext = serviceProvider.GetRequiredService<IShardingRuntimeContext>(); var shardingRuntimeContext = serviceProvider.GetRequiredService<IShardingRuntimeContext>();
shardingRuntimeContext.WithApplicationServiceProvider(serviceProvider); var virtualDataSource = shardingRuntimeContext.GetVirtualDataSource();
var virtualDataSource = serviceProvider.GetRequiredService<IVirtualDataSourceManager>().GetCurrentVirtualDataSource();
var connectionString = virtualDataSource.GetConnectionString(virtualDataSource.DefaultDataSourceName); var connectionString = virtualDataSource.GetConnectionString(virtualDataSource.DefaultDataSourceName);
var contextOptionsBuilder = virtualDataSource.ConfigurationParams.UseDbContextOptionsBuilder(connectionString, dbContextOptionsBuilder).UseSharding<TShardingDbContext>(); var contextOptionsBuilder = virtualDataSource.ConfigurationParams.UseDbContextOptionsBuilder(connectionString, dbContextOptionsBuilder).UseSharding<TShardingDbContext>(shardingRuntimeContext);
virtualDataSource.ConfigurationParams.UseShellDbContextOptionBuilder(contextOptionsBuilder); virtualDataSource.ConfigurationParams.UseShellDbContextOptionBuilder(contextOptionsBuilder);
} }
internal static IServiceCollection AddInternalShardingCore<TShardingDbContext>(this IServiceCollection services) where TShardingDbContext : DbContext, IShardingDbContext internal static IServiceCollection AddInternalShardingCore<TShardingDbContext>(this IServiceCollection services) where TShardingDbContext : DbContext, IShardingDbContext
{ {
//虚拟数据源管理者 services.TryAddSingleton<IVirtualDataSourceConfigurationParams, SimpleVirtualDataSourceConfigurationParams>();
services.TryAddSingleton<IVirtualDataSourceManager, VirtualDataSourceManager>();
services.TryAddSingleton<IVirtualDataSourceAccessor, VirtualDataSourceAccessor>();
//分表dbcontext创建 //分表dbcontext创建
services.TryAddSingleton<IDbContextCreator, ActivatorDbContextCreator<TShardingDbContext>>(); services.TryAddSingleton<IDbContextCreator, ActivatorDbContextCreator<TShardingDbContext>>();
@ -104,10 +103,12 @@ namespace ShardingCore
services.TryAddSingleton<IStreamMergeContextFactory<TShardingDbContext>, StreamMergeContextFactory<TShardingDbContext>>(); services.TryAddSingleton<IStreamMergeContextFactory<TShardingDbContext>, StreamMergeContextFactory<TShardingDbContext>>();
services.TryAddSingleton<IShardingTableCreator, ShardingTableCreator>(); services.TryAddSingleton<IShardingTableCreator, ShardingTableCreator>();
//虚拟数据源管理 //虚拟数据源管理
services.TryAddSingleton<IVirtualDataSource, VirtualDataSource>();
services.TryAddSingleton<IVirtualDataSourceRouteManager, VirtualDataSourceRouteManager>(); services.TryAddSingleton<IVirtualDataSourceRouteManager, VirtualDataSourceRouteManager>();
services.TryAddSingleton<IDataSourceRouteRuleEngine<TShardingDbContext>, DataSourceRouteRuleEngine<TShardingDbContext>>(); services.TryAddSingleton<IDataSourceRouteRuleEngine<TShardingDbContext>, DataSourceRouteRuleEngine<TShardingDbContext>>();
services.TryAddSingleton<IDataSourceRouteRuleEngineFactory<TShardingDbContext>, DataSourceRouteRuleEngineFactory<TShardingDbContext>>(); services.TryAddSingleton<IDataSourceRouteRuleEngineFactory<TShardingDbContext>, DataSourceRouteRuleEngineFactory<TShardingDbContext>>();
//读写分离链接创建工厂 //读写分离链接创建工厂
services.TryAddSingleton<IShardingReadWriteAccessor, ShardingReadWriteAccessor>();
services.TryAddSingleton<IReadWriteConnectorFactory, ReadWriteConnectorFactory>(); services.TryAddSingleton<IReadWriteConnectorFactory, ReadWriteConnectorFactory>();
//虚拟表管理 //虚拟表管理
@ -124,7 +125,6 @@ namespace ShardingCore
services.TryAddSingleton<IShardingCompilerExecutor, DefaultShardingCompilerExecutor>(); services.TryAddSingleton<IShardingCompilerExecutor, DefaultShardingCompilerExecutor>();
services.TryAddSingleton<IQueryCompilerContextFactory, QueryCompilerContextFactory>(); services.TryAddSingleton<IQueryCompilerContextFactory, QueryCompilerContextFactory>();
services.TryAddSingleton<IShardingQueryExecutor, DefaultShardingQueryExecutor>(); services.TryAddSingleton<IShardingQueryExecutor, DefaultShardingQueryExecutor>();
services.TryAddSingleton<IReadWriteConnectorFactory, ReadWriteConnectorFactory>();
// //
services.TryAddSingleton<IPrepareParser, DefaultPrepareParser>(); services.TryAddSingleton<IPrepareParser, DefaultPrepareParser>();
@ -147,6 +147,7 @@ namespace ShardingCore
services.TryAddSingleton<INativeTrackQueryExecutor, NativeTrackQueryExecutor>(); services.TryAddSingleton<INativeTrackQueryExecutor, NativeTrackQueryExecutor>();
//读写分离手动指定 //读写分离手动指定
services.TryAddSingleton<IShardingReadWriteManager, ShardingReadWriteManager>(); services.TryAddSingleton<IShardingReadWriteManager, ShardingReadWriteManager>();
services.TryAddSingleton<IShardingComparer, CSharpLanguageShardingComparer>();
services.TryAddShardingJob(); services.TryAddShardingJob();

12
src/ShardingCore/DynamicDataSources/DefaultDataSourceInitializer.cs
View File

@ -26,7 +26,7 @@
// private static readonly ILogger<DataSourceInitializer<TShardingDbContext>> _logger = // private static readonly ILogger<DataSourceInitializer<TShardingDbContext>> _logger =
// InternalLoggerFactory.CreateLogger<DataSourceInitializer<TShardingDbContext>>(); // InternalLoggerFactory.CreateLogger<DataSourceInitializer<TShardingDbContext>>();
// //
// private readonly IShardingEntityConfigOptions<TShardingDbContext> _entityConfigOptions; // private readonly IShardingRouteConfigOptions<TShardingDbContext> _routeConfigOptions;
// private readonly IVirtualDataSourceManager<TShardingDbContext> _virtualDataSourceManager; // private readonly IVirtualDataSourceManager<TShardingDbContext> _virtualDataSourceManager;
// private readonly IRouteTailFactory _routeTailFactory; // private readonly IRouteTailFactory _routeTailFactory;
// private readonly IVirtualTableManager<TShardingDbContext> _virtualTableManager; // private readonly IVirtualTableManager<TShardingDbContext> _virtualTableManager;
@ -34,13 +34,13 @@
// private readonly IShardingTableCreator<TShardingDbContext> _tableCreator; // private readonly IShardingTableCreator<TShardingDbContext> _tableCreator;
// //
// public DataSourceInitializer( // public DataSourceInitializer(
// IShardingEntityConfigOptions<TShardingDbContext> entityConfigOptions, // IShardingRouteConfigOptions<TShardingDbContext> routeConfigOptions,
// IVirtualDataSourceManager<TShardingDbContext> virtualDataSourceManager, // IVirtualDataSourceManager<TShardingDbContext> virtualDataSourceManager,
// IRouteTailFactory routeTailFactory, IVirtualTableManager<TShardingDbContext> virtualTableManager, // IRouteTailFactory routeTailFactory, IVirtualTableManager<TShardingDbContext> virtualTableManager,
// IEntityMetadataManager<TShardingDbContext> entityMetadataManager, // IEntityMetadataManager<TShardingDbContext> entityMetadataManager,
// IShardingTableCreator<TShardingDbContext> shardingTableCreator) // IShardingTableCreator<TShardingDbContext> shardingTableCreator)
// { // {
// _entityConfigOptions = entityConfigOptions; // _routeConfigOptions = routeConfigOptions;
// _virtualDataSourceManager = virtualDataSourceManager; // _virtualDataSourceManager = virtualDataSourceManager;
// _routeTailFactory = routeTailFactory; // _routeTailFactory = routeTailFactory;
// _virtualTableManager = virtualTableManager; // _virtualTableManager = virtualTableManager;
@ -54,9 +54,9 @@
// { // {
// // var createDatabase = !needCreateDatabase.HasValue || needCreateDatabase.Value; // // var createDatabase = !needCreateDatabase.HasValue || needCreateDatabase.Value;
// // // //
// // if ((_entityConfigOptions.EnsureCreatedWithOutShardingTable || !isOnStart)&&createDatabase) // // if ((_routeConfigOptions.EnsureCreatedWithOutShardingTable || !isOnStart)&&createDatabase)
// // EnsureCreated(virtualDataSource, context, dataSourceName); // // EnsureCreated(virtualDataSource, context, dataSourceName);
// // else if (_entityConfigOptions.CreateDataBaseOnlyOnStart.GetValueOrDefault()&& createDatabase) // // else if (_routeConfigOptions.CreateDataBaseOnlyOnStart.GetValueOrDefault()&& createDatabase)
// // { // // {
// // EnsureCreateDataBaseOnly(context, dataSourceName); // // EnsureCreateDataBaseOnly(context, dataSourceName);
// // } // // }
@ -131,7 +131,7 @@
// // } // // }
// // } // // }
// // // //
// // return _entityConfigOptions.CreateShardingTableOnStart.GetValueOrDefault(); // // return _routeConfigOptions.CreateShardingTableOnStart.GetValueOrDefault();
// // } // // }
// // // //
// // private void EnsureCreated(IVirtualDataSource<TShardingDbContext> virtualDataSource, DbContext context, // // private void EnsureCreated(IVirtualDataSource<TShardingDbContext> virtualDataSource, DbContext context,

42
src/ShardingCore/Extensions/ShardingCoreConfigBuilderExtension.cs
View File

@ -1,21 +1,21 @@
using System; // using System;
using System.Collections.Generic; // using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis; // using System.Diagnostics.CodeAnalysis;
using System.Linq; // using System.Linq;
using System.Text; // using System.Text;
using System.Threading.Tasks; // using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore; // using Microsoft.EntityFrameworkCore;
using ShardingCore.DIExtensions; // using ShardingCore.DIExtensions;
using ShardingCore.Sharding.Abstractions; // using ShardingCore.Sharding.Abstractions;
//
namespace ShardingCore.Extensions // namespace ShardingCore.Extensions
{ // {
public static class ShardingCoreConfigBuilderExtension // public static class ShardingCoreConfigBuilderExtension
{ // {
[ExcludeFromCodeCoverage] // [ExcludeFromCodeCoverage]
public static void AddEntityTryCreateTable<TEntity>(this ShardingCoreBeginOptions source) where TEntity:class // public static void AddEntityTryCreateTable<TEntity>(this ShardingCoreBeginOptions source) where TEntity:class
{ // {
source.AddEntitiesTryCreateTable(typeof(TEntity)); // source.AddEntitiesTryCreateTable(typeof(TEntity));
} // }
} // }
} // }

12
src/ShardingCore/Extensions/ShardingEntityConfigOptionExtension.cs
View File

@ -5,22 +5,22 @@ namespace ShardingCore.Extensions
{ {
public static class ShardingEntityConfigOptionExtension public static class ShardingEntityConfigOptionExtension
{ {
public static bool TryGetVirtualTableRoute<TEntity>(this IShardingEntityConfigOptions shardingEntityConfigOptions, out Type virtualTableRouteType) where TEntity:class public static bool TryGetVirtualTableRoute<TEntity>(this IShardingRouteConfigOptions shardingRouteConfigOptions, out Type virtualTableRouteType) where TEntity:class
{ {
if (shardingEntityConfigOptions.HasVirtualTableRoute(typeof(TEntity))) if (shardingRouteConfigOptions.HasVirtualTableRoute(typeof(TEntity)))
{ {
virtualTableRouteType = shardingEntityConfigOptions.GetVirtualTableRouteType(typeof(TEntity)); virtualTableRouteType = shardingRouteConfigOptions.GetVirtualTableRouteType(typeof(TEntity));
return virtualTableRouteType != null; return virtualTableRouteType != null;
} }
virtualTableRouteType = null; virtualTableRouteType = null;
return false; return false;
} }
public static bool TryGetVirtualDataSourceRoute<TEntity>(this IShardingEntityConfigOptions shardingEntityConfigOptions,out Type virtualDataSourceRouteType) where TEntity:class public static bool TryGetVirtualDataSourceRoute<TEntity>(this IShardingRouteConfigOptions shardingRouteConfigOptions,out Type virtualDataSourceRouteType) where TEntity:class
{ {
if (shardingEntityConfigOptions.HasVirtualDataSourceRoute(typeof(TEntity))) if (shardingRouteConfigOptions.HasVirtualDataSourceRoute(typeof(TEntity)))
{ {
virtualDataSourceRouteType = shardingEntityConfigOptions.GetVirtualDataSourceRouteType(typeof(TEntity)); virtualDataSourceRouteType = shardingRouteConfigOptions.GetVirtualDataSourceRouteType(typeof(TEntity));
return virtualDataSourceRouteType != null; return virtualDataSourceRouteType != null;
} }

57
src/ShardingCore/Extensions/ShardingProviderExtension.cs Normal file
View File

@ -0,0 +1,57 @@
using System;
using System.Linq;
using System.Reflection;
using Microsoft.Extensions.DependencyInjection;
using ShardingCore.Core;
namespace ShardingCore.Extensions
{
public static class ShardingProviderExtension
{
/// <summary>
/// 创建一个没有依赖注入的对象,但是对象的构造函数参数是已经可以通过依赖注入获取的
/// </summary>
/// <param name="shardingProvider"></param>
/// <param name="serviceType"></param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
public static object CreateInstance(this IShardingProvider shardingProvider,Type serviceType)
{
var constructors
= serviceType.GetTypeInfo().DeclaredConstructors
.Where(c => !c.IsStatic && c.IsPublic)
.ToArray();
if (constructors.Length != 1)
{
throw new ArgumentException(
$"type :[{serviceType}] found more than one declared constructor ");
}
var @params = constructors[0].GetParameters().Select(x => shardingProvider.GetService(x.ParameterType))
.ToArray();
return Activator.CreateInstance(serviceType, @params);
}
public static object GetRequiredService(this IShardingProvider shardingProvider,Type serviceType)
{
var service = shardingProvider.GetService(serviceType);
if (service == null)
{
throw new ArgumentNullException($"cant resolve {serviceType.FullName}");
}
return service;
}
public static TService GetService<TService>(this IShardingProvider shardingProvider)
{
return (TService)shardingProvider.GetService(typeof(TService));
}
public static TService GetRequiredService<TService>(this IShardingProvider shardingProvider)
{
return (TService)shardingProvider.GetRequiredService(typeof(TService));
}
}
}

2
src/ShardingCore/Sharding/Parsers/Visitors/ShardingQueryPrepareVisitor.cs
View File

@ -42,7 +42,7 @@ namespace ShardingCore.Sharding.Parsers.Visitors
public ShardingQueryPrepareVisitor(IShardingDbContext shardingDbContext) public ShardingQueryPrepareVisitor(IShardingDbContext shardingDbContext)
{ {
_shardingDbContext = shardingDbContext; _shardingDbContext = shardingDbContext;
_trackerManager = ((DbContext)shardingDbContext).GetRequireService<IShardingRuntimeContext>() _trackerManager =shardingDbContext.GetShardingRuntimeContext()
.GetTrackerManager(); .GetTrackerManager();
} }
public ShardingPrepareResult GetShardingPrepareResult() public ShardingPrepareResult GetShardingPrepareResult()

1
src/ShardingCore/Sharding/ReadWriteConfigurations/Abstractions/IShardingReadWriteAccessor.cs
View File

@ -13,7 +13,6 @@ namespace ShardingCore.Sharding.ReadWriteConfigurations.Abstractions
*/ */
public interface IShardingReadWriteAccessor public interface IShardingReadWriteAccessor
{ {
Type ShardingDbContextType { get;}
ShardingReadWriteContext ShardingReadWriteContext { get; set; } ShardingReadWriteContext ShardingReadWriteContext { get; set; }
} }
} }

3
src/ShardingCore/Sharding/ReadWriteConfigurations/ShardingReadWriteAccessor.cs
View File

@ -15,11 +15,10 @@ namespace ShardingCore.Sharding.ReadWriteConfigurations
* @Ver: 1.0 * @Ver: 1.0
* @Email: 326308290@qq.com * @Email: 326308290@qq.com
*/ */
public class ShardingReadWriteAccessor<TShardingDbContext>:IShardingReadWriteAccessor where TShardingDbContext:DbContext,IShardingDbContext public class ShardingReadWriteAccessor:IShardingReadWriteAccessor
{ {
private static AsyncLocal<ShardingReadWriteContext> _shardingReadWriteContext = new AsyncLocal<ShardingReadWriteContext>(); private static AsyncLocal<ShardingReadWriteContext> _shardingReadWriteContext = new AsyncLocal<ShardingReadWriteContext>();
public Type ShardingDbContextType => typeof(TShardingDbContext);
/// <summary> /// <summary>
/// ///

3
src/ShardingCore/Sharding/ShardingDbContextExecutors/ShardingDbContextExecutor.cs
View File

@ -61,8 +61,7 @@ namespace ShardingCore.Sharding.ShardingDbContextExecutors
//初始化 //初始化
var shardingRuntimeContext = shardingDbContext.GetRequireService<IShardingRuntimeContext>(); var shardingRuntimeContext = shardingDbContext.GetRequireService<IShardingRuntimeContext>();
shardingRuntimeContext.GetOrCreateShardingRuntimeModel(shardingDbContext); shardingRuntimeContext.GetOrCreateShardingRuntimeModel(shardingDbContext);
var virtualDataSourceManager = shardingRuntimeContext.GetVirtualDataSourceManager(); _virtualDataSource = shardingRuntimeContext.GetVirtualDataSource();
_virtualDataSource = virtualDataSourceManager.GetCurrentVirtualDataSource();
_tableRouteManager = shardingRuntimeContext.GetTableRouteManager(); _tableRouteManager = shardingRuntimeContext.GetTableRouteManager();
_dbContextCreator = shardingRuntimeContext.GetDbContextCreator(); _dbContextCreator = shardingRuntimeContext.GetDbContextCreator();
_entityMetadataManager = shardingRuntimeContext.GetEntityMetadataManager(); _entityMetadataManager = shardingRuntimeContext.GetEntityMetadataManager();

10
src/ShardingCore/Sharding/StreamMergeContext.cs
View File

@ -70,7 +70,7 @@ namespace ShardingCore.Sharding
public bool IsCrossTable => MergeQueryCompilerContext.IsCrossTable(); public bool IsCrossTable => MergeQueryCompilerContext.IsCrossTable();
private readonly ITrackerManager _trackerManager; private readonly ITrackerManager _trackerManager;
private readonly IShardingEntityConfigOptions _shardingEntityConfigOptions; private readonly IShardingRouteConfigOptions _shardingRouteConfigOptions;
private readonly ConcurrentDictionary<DbContext, object> _parallelDbContexts; private readonly ConcurrentDictionary<DbContext, object> _parallelDbContexts;
@ -84,7 +84,7 @@ namespace ShardingCore.Sharding
public StreamMergeContext(IMergeQueryCompilerContext mergeQueryCompilerContext,IParseResult parseResult,IQueryable rewriteQueryable,IOptimizeResult optimizeResult, public StreamMergeContext(IMergeQueryCompilerContext mergeQueryCompilerContext,IParseResult parseResult,IQueryable rewriteQueryable,IOptimizeResult optimizeResult,
IRouteTailFactory routeTailFactory,ITrackerManager trackerManager,IShardingEntityConfigOptions shardingEntityConfigOptions) IRouteTailFactory routeTailFactory,ITrackerManager trackerManager,IShardingRouteConfigOptions shardingRouteConfigOptions)
{ {
MergeQueryCompilerContext = mergeQueryCompilerContext; MergeQueryCompilerContext = mergeQueryCompilerContext;
ShardingRuntimeContext = ((DbContext)mergeQueryCompilerContext.GetShardingDbContext()) ShardingRuntimeContext = ((DbContext)mergeQueryCompilerContext.GetShardingDbContext())
@ -95,7 +95,7 @@ namespace ShardingCore.Sharding
_routeTailFactory = routeTailFactory; _routeTailFactory = routeTailFactory;
QueryEntities= MergeQueryCompilerContext.GetQueryEntities().Keys.ToHashSet(); QueryEntities= MergeQueryCompilerContext.GetQueryEntities().Keys.ToHashSet();
_trackerManager =trackerManager; _trackerManager =trackerManager;
_shardingEntityConfigOptions = shardingEntityConfigOptions; _shardingRouteConfigOptions = shardingRouteConfigOptions;
_parallelDbContexts = new ConcurrentDictionary<DbContext, object>(); _parallelDbContexts = new ConcurrentDictionary<DbContext, object>();
Orders = parseResult.GetOrderByContext().PropertyOrders.ToArray(); Orders = parseResult.GetOrderByContext().PropertyOrders.ToArray();
Skip = parseResult.GetPaginationContext().Skip; Skip = parseResult.GetPaginationContext().Skip;
@ -265,7 +265,7 @@ namespace ShardingCore.Sharding
public IShardingComparer GetShardingComparer() public IShardingComparer GetShardingComparer()
{ {
return GetShardingDbContext().GetVirtualDataSource().ConfigurationParams.ShardingComparer; return GetShardingDbContext().GetShardingRuntimeContext().GetRequiredService<IShardingComparer>();
} }
public TResult PreperExecute<TResult>(Func<TResult> emptyFunc) public TResult PreperExecute<TResult>(Func<TResult> emptyFunc)
@ -296,7 +296,7 @@ namespace ShardingCore.Sharding
private bool ThrowIfQueryRouteNotMatch() private bool ThrowIfQueryRouteNotMatch()
{ {
return _shardingEntityConfigOptions.ThrowIfQueryRouteNotMatch; return _shardingRouteConfigOptions.ThrowIfQueryRouteNotMatch;
} }
public bool UseUnionAllMerge() public bool UseUnionAllMerge()

8
src/ShardingCore/Sharding/StreamMergeContextFactory.cs
View File

@ -25,25 +25,25 @@ namespace ShardingCore.Sharding
private readonly IQueryableRewriteEngine _queryableRewriteEngine; private readonly IQueryableRewriteEngine _queryableRewriteEngine;
private readonly IQueryableOptimizeEngine _queryableOptimizeEngine; private readonly IQueryableOptimizeEngine _queryableOptimizeEngine;
private readonly ITrackerManager _trackerManager; private readonly ITrackerManager _trackerManager;
private readonly IShardingEntityConfigOptions _shardingEntityConfigOptions; private readonly IShardingRouteConfigOptions _shardingRouteConfigOptions;
public StreamMergeContextFactory(IRouteTailFactory routeTailFactory public StreamMergeContextFactory(IRouteTailFactory routeTailFactory
, IQueryableParseEngine queryableParseEngine, IQueryableRewriteEngine queryableRewriteEngine, IQueryableOptimizeEngine queryableOptimizeEngine, , IQueryableParseEngine queryableParseEngine, IQueryableRewriteEngine queryableRewriteEngine, IQueryableOptimizeEngine queryableOptimizeEngine,
ITrackerManager trackerManager,IShardingEntityConfigOptions shardingEntityConfigOptions) ITrackerManager trackerManager,IShardingRouteConfigOptions shardingRouteConfigOptions)
{ {
_routeTailFactory = routeTailFactory; _routeTailFactory = routeTailFactory;
_queryableParseEngine = queryableParseEngine; _queryableParseEngine = queryableParseEngine;
_queryableRewriteEngine = queryableRewriteEngine; _queryableRewriteEngine = queryableRewriteEngine;
_queryableOptimizeEngine = queryableOptimizeEngine; _queryableOptimizeEngine = queryableOptimizeEngine;
_trackerManager = trackerManager; _trackerManager = trackerManager;
_shardingEntityConfigOptions = shardingEntityConfigOptions; _shardingRouteConfigOptions = shardingRouteConfigOptions;
} }
public StreamMergeContext Create(IMergeQueryCompilerContext mergeQueryCompilerContext) public StreamMergeContext Create(IMergeQueryCompilerContext mergeQueryCompilerContext)
{ {
var parseResult = _queryableParseEngine.Parse(mergeQueryCompilerContext); var parseResult = _queryableParseEngine.Parse(mergeQueryCompilerContext);
var rewriteQueryable = _queryableRewriteEngine.GetRewriteQueryable(mergeQueryCompilerContext, parseResult); var rewriteQueryable = _queryableRewriteEngine.GetRewriteQueryable(mergeQueryCompilerContext, parseResult);
var optimizeResult = _queryableOptimizeEngine.Optimize(mergeQueryCompilerContext, parseResult, rewriteQueryable); var optimizeResult = _queryableOptimizeEngine.Optimize(mergeQueryCompilerContext, parseResult, rewriteQueryable);
return new StreamMergeContext(mergeQueryCompilerContext, parseResult, rewriteQueryable,optimizeResult, _routeTailFactory,_trackerManager,_shardingEntityConfigOptions); return new StreamMergeContext(mergeQueryCompilerContext, parseResult, rewriteQueryable,optimizeResult, _routeTailFactory,_trackerManager,_shardingRouteConfigOptions);
} }
} }
} }

8
src/ShardingCore/ShardingContainer.cs
View File

@ -141,14 +141,14 @@
// //{ // //{
// // return (IShardingConfigOption)ServiceProvider.GetService(typeof(IShardingConfigOption<>).GetGenericType0(shardingDbContextType)); // // return (IShardingConfigOption)ServiceProvider.GetService(typeof(IShardingConfigOption<>).GetGenericType0(shardingDbContextType));
// //} // //}
// public static IShardingEntityConfigOptions<TShardingDbContext> GetRequiredShardingEntityConfigOption<TShardingDbContext>() // public static IShardingRouteConfigOptions<TShardingDbContext> GetRequiredShardingEntityConfigOption<TShardingDbContext>()
// where TShardingDbContext : DbContext, IShardingDbContext // where TShardingDbContext : DbContext, IShardingDbContext
// { // {
// return (IShardingEntityConfigOptions<TShardingDbContext>)GetRequiredShardingEntityConfigOption(typeof(TShardingDbContext)); // return (IShardingRouteConfigOptions<TShardingDbContext>)GetRequiredShardingEntityConfigOption(typeof(TShardingDbContext));
// } // }
// public static IShardingEntityConfigOptions GetRequiredShardingEntityConfigOption(Type shardingDbContextType) // public static IShardingRouteConfigOptions GetRequiredShardingEntityConfigOption(Type shardingDbContextType)
// { // {
// return (IShardingEntityConfigOptions)ServiceProvider.GetService(typeof(IShardingEntityConfigOptions<>).GetGenericType0(shardingDbContextType)); // return (IShardingRouteConfigOptions)ServiceProvider.GetService(typeof(IShardingRouteConfigOptions<>).GetGenericType0(shardingDbContextType));
// } // }
// //
// public static IVirtualDataSourceManager<TShardingDbContext> GetRequiredVirtualDataSourceManager<TShardingDbContext>() // public static IVirtualDataSourceManager<TShardingDbContext> GetRequiredVirtualDataSourceManager<TShardingDbContext>()

81
src/ShardingCore/ShardingRuntimeBuilder.cs Normal file
View File

@ -0,0 +1,81 @@
using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using ShardingCore.Core;
using ShardingCore.Core.ShardingConfigurations;
using ShardingCore.Core.ShardingConfigurations.Abstractions;
using ShardingCore.Sharding.Abstractions;
namespace ShardingCore
{
public class ShardingRuntimeBuilder<TShardingDbContext> where TShardingDbContext : DbContext, IShardingDbContext
{
private IShardingRouteConfigOptions _shardingRouteConfigOptions = new ShardingRouteConfigOptions();
private ShardingConfigOptions _shardingConfigOptions = new ShardingConfigOptions();
public ShardingRuntimeBuilder()
{
}
public ShardingRuntimeBuilder<TShardingDbContext> UseRouteConfig(Action<IShardingRouteConfigOptions> configure)
{
if (configure == null)
throw new ArgumentNullException($"{nameof(configure)}");
configure.Invoke(_shardingRouteConfigOptions);
return this;
}
public ShardingRuntimeBuilder<TShardingDbContext> UseConfig(Action<ShardingConfigOptions> configure)
{
if (configure == null)
throw new ArgumentNullException($"{nameof(configure)}");
configure.Invoke(_shardingConfigOptions);
if (string.IsNullOrWhiteSpace(_shardingConfigOptions.DefaultDataSourceName))
throw new ArgumentNullException(
$"{nameof(_shardingConfigOptions.DefaultDataSourceName)} plz call {nameof(ShardingConfigOptions.AddDefaultDataSource)}");
if (string.IsNullOrWhiteSpace(_shardingConfigOptions.DefaultConnectionString))
throw new ArgumentNullException(
$"{nameof(_shardingConfigOptions.DefaultConnectionString)} plz call {nameof(ShardingConfigOptions.AddDefaultDataSource)}");
if (_shardingConfigOptions.ConnectionStringConfigure is null)
throw new ArgumentNullException($"plz call {nameof(_shardingConfigOptions.UseShardingQuery)}");
if (_shardingConfigOptions.ConnectionConfigure is null )
throw new ArgumentNullException(
$"plz call {nameof(_shardingConfigOptions.UseShardingTransaction)}");
if (_shardingConfigOptions.MaxQueryConnectionsLimit <= 0)
throw new ArgumentException(
$"{nameof(_shardingConfigOptions.MaxQueryConnectionsLimit)} should greater than and equal 1");
return this;
}
public IShardingRuntimeContext Build()
{
return Build(null);
}
public IShardingRuntimeContext Build(IServiceProvider appServiceProvider)
{
return Build(appServiceProvider, appServiceProvider?.GetService<ILoggerFactory>());
}
public IShardingRuntimeContext Build(IServiceProvider appServiceProvider, ILoggerFactory loggerFactory)
{
var shardingRuntimeContext = new ShardingRuntimeContext();
shardingRuntimeContext.UseApplicationServiceProvider(appServiceProvider);
shardingRuntimeContext.UseLogfactory(loggerFactory);
shardingRuntimeContext.AddServiceConfig(services =>
{
services.AddSingleton<IDbContextTypeCollector>(sp => new DbContextTypeCollector<TShardingDbContext>());
services.AddSingleton<IShardingRouteConfigOptions>(sp => _shardingRouteConfigOptions);
services.AddSingleton(sp => _shardingConfigOptions);
services.AddSingleton<IShardingProvider>(sp => new ShardingProvider(sp,appServiceProvider));
services.AddInternalShardingCore<TShardingDbContext>();
});
shardingRuntimeContext.Initialize();
return shardingRuntimeContext;
}
}
}

8
src/ShardingCore/TableCreator/ShardingTableCreator.cs
View File

@ -26,14 +26,14 @@ namespace ShardingCore.TableCreator
InternalLoggerFactory.CreateLogger<ShardingTableCreator>(); InternalLoggerFactory.CreateLogger<ShardingTableCreator>();
private readonly IServiceProvider _serviceProvider; private readonly IServiceProvider _serviceProvider;
private readonly IShardingEntityConfigOptions _entityConfigOptions; private readonly IShardingRouteConfigOptions _routeConfigOptions;
private readonly IRouteTailFactory _routeTailFactory; private readonly IRouteTailFactory _routeTailFactory;
public ShardingTableCreator(IServiceProvider serviceProvider, public ShardingTableCreator(IServiceProvider serviceProvider,
IShardingEntityConfigOptions entityConfigOptions, IRouteTailFactory routeTailFactory) IShardingRouteConfigOptions routeConfigOptions, IRouteTailFactory routeTailFactory)
{ {
_serviceProvider = serviceProvider; _serviceProvider = serviceProvider;
_entityConfigOptions = entityConfigOptions; _routeConfigOptions = routeConfigOptions;
_routeTailFactory = routeTailFactory; _routeTailFactory = routeTailFactory;
} }
@ -64,7 +64,7 @@ namespace ShardingCore.TableCreator
} }
catch (Exception ex) catch (Exception ex)
{ {
if (!_entityConfigOptions.IgnoreCreateTableError.GetValueOrDefault()) if (!_routeConfigOptions.IgnoreCreateTableError.GetValueOrDefault())
{ {
_logger.LogWarning(ex, _logger.LogWarning(ex,
$"create table error entity name:[{shardingEntityType.Name}]."); $"create table error entity name:[{shardingEntityType.Name}].");