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

移除datasourcemanager

This commit is contained in:
xuejiaming 2022-07-01 10:53:01 +08:00
parent 32ae409159
commit fea8e9a781
23 changed files with 890 additions and 956 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -21,15 +21,15 @@ namespace ShardingCore.Bootstrappers
{
private readonly ILogger<ShardingBootstrapper> _logger;
private readonly IServiceProvider _internalServiceProvider;
private readonly IEnumerable<IDbContextTypeCollector> _dbContextTypeCollectors;
private readonly IDbContextTypeCollector _dbContextTypeCollector;
private readonly IJobManager _jobManager;
private readonly DoOnlyOnce _doOnlyOnce = new DoOnlyOnce();
public ShardingBootstrapper(IServiceProvider internalServiceProvider,IEnumerable<IDbContextTypeCollector> dbContextTypeCollectors,IJobManager jobManager)
public ShardingBootstrapper(IServiceProvider internalServiceProvider,IDbContextTypeCollector dbContextTypeCollector,IJobManager jobManager)
{
_logger = InternalLoggerFactory.DefaultFactory .CreateLogger<ShardingBootstrapper>();
_internalServiceProvider = internalServiceProvider;
_dbContextTypeCollectors = dbContextTypeCollectors;
_dbContextTypeCollector = dbContextTypeCollector;
_jobManager = jobManager;
}
/// <summary>
@ -40,13 +40,11 @@ namespace ShardingCore.Bootstrappers
if (!_doOnlyOnce.IsUnDo())
return;
_logger.LogDebug("sharding core starting......");
foreach (var dbContextTypeCollector in _dbContextTypeCollectors)
{
var instance = (IShardingDbContextBootstrapper)ActivatorUtilities.CreateInstance(_internalServiceProvider,typeof(ShardingDbContextBootstrapper<>).GetGenericType0(dbContextTypeCollector.ShardingDbContextType));
_logger.LogDebug($"{dbContextTypeCollector.ShardingDbContextType} start init......");
instance.Initialize();
_logger.LogDebug($"{dbContextTypeCollector.ShardingDbContextType} complete init");
}
var instance = (IShardingDbContextBootstrapper)ActivatorUtilities.CreateInstance(_internalServiceProvider,typeof(ShardingDbContextBootstrapper<>).GetGenericType0(_dbContextTypeCollector.ShardingDbContextType));
_logger.LogDebug($"{_dbContextTypeCollector.ShardingDbContextType} start init......");
instance.Initialize();
_logger.LogDebug($"{_dbContextTypeCollector.ShardingDbContextType} complete init");
if (_jobManager != null && _jobManager.HasAnyJob())
{

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

@ -4,13 +4,9 @@ using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using ShardingCore.Core;
using ShardingCore.Core.EntityMetadatas;
using ShardingCore.Core.PhysicTables;
using ShardingCore.Core.ShardingConfigurations.Abstractions;
using ShardingCore.Core.TrackerManagers;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualTables;
using ShardingCore.Core.VirtualTables;
using ShardingCore.DynamicDataSources;
using ShardingCore.Exceptions;
using ShardingCore.Extensions;
using ShardingCore.Sharding.Abstractions;
@ -43,37 +39,29 @@ namespace ShardingCore.Bootstrappers
where TShardingDbContext : DbContext, IShardingDbContext
{
private readonly IServiceProvider _internalServiceProvider;
private readonly IVirtualDataSourceManager<TShardingDbContext> _virtualDataSourceManager;
private readonly IShardingEntityConfigOptions<TShardingDbContext> _entityConfigOptions;
private readonly IEntityMetadataManager<TShardingDbContext> _entityMetadataManager;
private readonly IParallelTableManager<TShardingDbContext> _parallelTableManager;
private readonly IVirtualTableManager<TShardingDbContext> _virtualTableManager;
private readonly IShardingEntityConfigOptions _entityConfigOptions;
private readonly IEntityMetadataManager _entityMetadataManager;
private readonly IParallelTableManager _parallelTableManager;
private readonly IVirtualDataSource _virtualDataSource;
private readonly IDataSourceInitializer<TShardingDbContext> _dataSourceInitializer;
// private readonly ITrackerManager<TShardingDbContext> _trackerManager;
private readonly Type _shardingDbContextType;
public ShardingDbContextBootstrapper(
IServiceProvider internalServiceProvider,
IVirtualDataSourceManager<TShardingDbContext> virtualDataSourceManager,
IShardingEntityConfigOptions<TShardingDbContext> entityConfigOptions,
IEntityMetadataManager<TShardingDbContext> entityMetadataManager,
IParallelTableManager<TShardingDbContext> parallelTableManager,
IVirtualTableManager<TShardingDbContext> virtualTableManager,
IDataSourceInitializer<TShardingDbContext> dataSourceInitializer
// ITrackerManager<TShardingDbContext> trackerManager
IShardingEntityConfigOptions entityConfigOptions,
IEntityMetadataManager entityMetadataManager,
IParallelTableManager parallelTableManager,
IVirtualDataSource virtualDataSource
)
{
_shardingDbContextType = typeof(TShardingDbContext);
_internalServiceProvider = internalServiceProvider;
_virtualDataSourceManager = virtualDataSourceManager;
_entityConfigOptions = entityConfigOptions;
_entityMetadataManager = entityMetadataManager;
_parallelTableManager = parallelTableManager;
_virtualTableManager = virtualTableManager;
_dataSourceInitializer = dataSourceInitializer;
// _trackerManager = trackerManager;
_virtualDataSource = virtualDataSource;
}
/// <summary>
@ -88,21 +76,17 @@ namespace ShardingCore.Bootstrappers
private void InitializeEntityMetadata()
{
var configId = _virtualDataSourceManager.GetAllVirtualDataSources().First().ConfigId;
using (_virtualDataSourceManager.CreateScope(configId))
var shardingEntities = _entityConfigOptions.GetShardingTableRouteTypes()
.Concat(_entityConfigOptions.GetShardingDataSourceRouteTypes()).ToHashSet();
foreach (var entityType in shardingEntities)
{
var shardingEntities = _entityConfigOptions.GetShardingTableRouteTypes()
.Concat(_entityConfigOptions.GetShardingDataSourceRouteTypes()).ToHashSet();
foreach (var entityType in shardingEntities)
{
var entityMetadataInitializerType =
typeof(EntityMetadataInitializer<,>).GetGenericType1(_shardingDbContextType, entityType);
var entityMetadataInitializerType =
typeof(EntityMetadataInitializer<,>).GetGenericType1(_shardingDbContextType, entityType);
var entityMetadataInitializer =
(IEntityMetadataInitializer)ActivatorUtilities.CreateInstance(_internalServiceProvider,entityMetadataInitializerType);
entityMetadataInitializer.Initialize();
var entityMetadataInitializer =
(IEntityMetadataInitializer)ActivatorUtilities.CreateInstance(_internalServiceProvider,entityMetadataInitializerType);
entityMetadataInitializer.Initialize();
}
}
}

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

@ -1,11 +1,13 @@
using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using ShardingCore.Core.DbContextCreator;
using ShardingCore.Core.EntityMetadatas;
using ShardingCore.Core.QueryTrackers;
using ShardingCore.Core.ShardingPage.Abstractions;
using ShardingCore.Core.TrackerManagers;
using ShardingCore.Core.UnionAllMergeShardingProviders.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
using ShardingCore.Core.VirtualRoutes.Abstractions;
using ShardingCore.Core.VirtualRoutes.TableRoutes.RouteTails.Abstractions;
@ -24,13 +26,20 @@ namespace ShardingCore.Core
IParallelTableManager GetParallelTableManager();
IDbContextCreator GetDbContextCreator();
IEntityMetadataManager GetEntityMetadataManager();
IVirtualDataSourceManager GetVirtualDataSourceManager();
// IVirtualDataSourceManager GetVirtualDataSourceManager();
IVirtualDataSource GetVirtualDataSource();
ITableRouteManager GetTableRouteManager();
IRouteTailFactory GetRouteTailFactory();
IQueryTracker GetQueryTracker();
IUnionAllMergeManager GetUnionAllMergeManager();
IShardingPageManager GetShardingPageManager();
void GetOrCreateShardingRuntimeModel(DbContext dbContext);
void UseLogfactory(ILoggerFactory loggerFactory);
void WithApplicationServiceProvider(IServiceProvider applicationServiceProvider);
void Initialize();
object GetService(Type serviceType);
TService GetService<TService>();
}

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

@ -119,7 +119,7 @@ namespace ShardingCore.Core.ShardingConfigurations.ConfigBuilders
var services = ShardingCoreConfigBuilder.Services;
services.AddSingleton<IDbContextTypeCollector>(sp => new DbContextTypeCollector<TShardingDbContext>());
services.AddSingleton<IShardingEntityConfigOptions<TShardingDbContext>>(sp => ShardingCoreConfigBuilder.ShardingEntityConfigOptions);
services.AddSingleton<IShardingEntityConfigOptions>(sp => ShardingCoreConfigBuilder.ShardingEntityConfigOptions);
services.AddSingleton(sp => ShardingCoreConfigBuilder.ShardingEntityConfigOptions);
services.AddSingleton(sp => CreateShardingConfigurationOptions(isMultiConfig, configurationStrategy));
@ -133,20 +133,20 @@ namespace ShardingCore.Core.ShardingConfigurations.ConfigBuilders
return services;
}
private IShardingConfigurationOptions<TShardingDbContext> CreateShardingConfigurationOptions(bool isMultiConfig,
private IShardingConfigurationOptions CreateShardingConfigurationOptions(bool isMultiConfig,
ShardingConfigurationStrategyEnum configurationStrategy)
{
IShardingConfigurationOptions<TShardingDbContext> shardingConfigurationOptions;
IShardingConfigurationOptions shardingConfigurationOptions;
if (!isMultiConfig)
{
shardingConfigurationOptions = new ShardingSingleConfigurationOptions<TShardingDbContext>
shardingConfigurationOptions = new ShardingSingleConfigurationOptions
{
ShardingConfigurationStrategy = configurationStrategy
};
}
else
{
shardingConfigurationOptions = new ShardingMultiConfigurationOptions<TShardingDbContext>
shardingConfigurationOptions = new ShardingMultiConfigurationOptions
{
ShardingConfigurationStrategy = configurationStrategy
};

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

@ -36,10 +36,10 @@ namespace ShardingCore.DIExtensions
ShardingEntityConfigOptions = new ShardingEntityConfigOptions();
}
public ShardingConfigBuilder AddEntityConfig(Action<ShardingEntityConfigOptions> entityConfigure)
public ShardingConfigBuilder<TShardingDbContext> AddEntityConfig(Action<ShardingEntityConfigOptions> entityConfigure)
{
entityConfigure?.Invoke(ShardingEntityConfigOptions);
return new ShardingConfigBuilder(this);
return new ShardingConfigBuilder<TShardingDbContext>(this);
}
//public ShardingCoreConfigBuilder<TShardingDbContext, TActualDbContext> AddDefaultDataSource(string dataSourceName, string connectionString)
//{

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

@ -1,10 +1,7 @@
using Microsoft.EntityFrameworkCore;
using ShardingCore.Sharding.Abstractions;
using ShardingCore.Sharding.ReadWriteConfigurations;
using ShardingCore.Sharding.ShardingComparision;
using ShardingCore.Sharding.ShardingComparision.Abstractions;
using ShardingCore.TableExists;
using ShardingCore.TableExists.Abstractions;
using System;
using System.Collections.Generic;
using System.Data.Common;
@ -164,15 +161,15 @@ namespace ShardingCore.Core.ShardingConfigurations
ReplaceShardingComparerFactory = newShardingComparerFactory ?? throw new ArgumentNullException(nameof(newShardingComparerFactory));
}
public Func<IServiceProvider, ITableEnsureManager<TShardingDbContext>> TableEnsureManagerFactory =
sp => new EmptyTableEnsureManager<TShardingDbContext>();
public void ReplaceTableEnsureManager(
Func<IServiceProvider, ITableEnsureManager<TShardingDbContext>> tableEnsureManagerConfigure)
{
TableEnsureManagerFactory = tableEnsureManagerConfigure ??
throw new ArgumentNullException(nameof(tableEnsureManagerConfigure));
}
// public Func<IServiceProvider, ITableEnsureManager<TShardingDbContext>> TableEnsureManagerFactory =
// sp => new EmptyTableEnsureManager<TShardingDbContext>();
//
// public void ReplaceTableEnsureManager(
// Func<IServiceProvider, ITableEnsureManager<TShardingDbContext>> tableEnsureManagerConfigure)
// {
// TableEnsureManagerFactory = tableEnsureManagerConfigure ??
// throw new ArgumentNullException(nameof(tableEnsureManagerConfigure));
// }
}

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

@ -1,6 +1,7 @@
using System;
using System.Linq;
using System.Reflection;
using System.Threading;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
@ -22,14 +23,13 @@ namespace ShardingCore.Core
private object INIT_LOCK = new object();
private IServiceCollection _serviceMap = new ServiceCollection();
private readonly IServiceProvider _serviceProvider;
private IServiceProvider _serviceProvider;
private IServiceProvider _applicationServiceProvider;
private ShardingRuntimeContext()
{
_serviceProvider = _serviceMap.BuildServiceProvider();
_serviceProvider.GetRequiredService<IShardingBootstrapper>().Start();
}
private static readonly ShardingRuntimeContext _instance = new ShardingRuntimeContext();
@ -44,36 +44,6 @@ namespace ShardingCore.Core
public void Initialize()
{
// var shardingRuntimeModelCacheFactory = _serviceProvider.GetRequiredService<IShardingRuntimeModelCacheFactory>();
// var cacheKey = shardingRuntimeModelCacheFactory.GetCacheKey(dbContext.GetType());
// var memoryCache = _serviceProvider.GetRequiredService<IMemoryCache>();
// if (!memoryCache.TryGetValue(cacheKey, out IShardingRuntimeModel model))
// {
//
// // Make sure OnModelCreating really only gets called once, since it may not be thread safe.
// var acquire = Monitor.TryEnter(INIT_LOCK, TimeSpan.FromSeconds(waitSeconds));
// if (!acquire)
// {
// throw new ShardingCoreInvalidOperationException("cache model timeout");
// }
// try
// {
// if (!cache.TryGetValue(cacheKey, out model))
// {
// model = CreateModel(
// context, modelCreationDependencies.ConventionSetBuilder, modelCreationDependencies.ModelDependencies);
//
// model = modelCreationDependencies.ModelRuntimeInitializer.Initialize(
// model, designTime, modelCreationDependencies.ValidationLogger);
//
// model = cache.Set(cacheKey, model, new MemoryCacheEntryOptions { Size = size, Priority = priority });
// }
// }
// finally
// {
// Monitor.Exit(_syncObject);
// }
// }
if (isInited)
{
return;
@ -81,11 +51,9 @@ namespace ShardingCore.Core
lock (INIT_LOCK)
{
if (isInited)
{
return;
}
_serviceProvider = _serviceMap.BuildServiceProvider();
_serviceProvider.GetRequiredService<IShardingBootstrapper>().Start();
@ -168,15 +136,15 @@ namespace ShardingCore.Core
{
return GetService<IShardingRouteManager>();
}
public IShardingEntityConfigOptions<TShardingDbContext> GetRequiredShardingEntityConfigOption<TShardingDbContext>()
where TShardingDbContext : DbContext, IShardingDbContext
{
return (IShardingEntityConfigOptions<TShardingDbContext>)GetRequiredShardingEntityConfigOption(typeof(TShardingDbContext));
}
public IShardingEntityConfigOptions GetRequiredShardingEntityConfigOption(Type shardingDbContextType)
{
return (IShardingEntityConfigOptions)GetService(typeof(IShardingEntityConfigOptions<>).GetGenericType0(shardingDbContextType));
}
//
// public IShardingEntityConfigOptions<TShardingDbContext> GetRequiredShardingEntityConfigOption<TShardingDbContext>()
// where TShardingDbContext : DbContext, IShardingDbContext
// {
// return (IShardingEntityConfigOptions<TShardingDbContext>)GetRequiredShardingEntityConfigOption(typeof(TShardingDbContext));
// }
// public IShardingEntityConfigOptions GetRequiredShardingEntityConfigOption(Type shardingDbContextType)
// {
// return (IShardingEntityConfigOptions)GetService(typeof(IShardingEntityConfigOptions<>).GetGenericType0(shardingDbContextType));
// }
}
}

26
src/ShardingCore/Core/VirtualDatabase/VirtualDataSources/Abstractions/IVirtualDataSourceAccessor.cs
View File

@ -1,13 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions
{
public interface IVirtualDataSourceAccessor
{
VirtualDataSourceContext DataSourceContext { get; set; }
}
}
// using System;
// using System.Collections.Generic;
// using System.Linq;
// using System.Text;
// using System.Threading.Tasks;
//
// namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions
// {
// public interface IVirtualDataSourceAccessor
// {
// VirtualDataSourceContext DataSourceContext { get; set; }
// }
// }

64
src/ShardingCore/Core/VirtualDatabase/VirtualDataSources/Abstractions/IVirtualDataSourceManager.cs
View File

@ -1,32 +1,32 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using ShardingCore.Core.ShardingConfigurations.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Common;
using ShardingCore.Sharding.Abstractions;
namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions
{
public interface IVirtualDataSourceManager
{
bool IsMultiShardingConfiguration { get; }
ShardingConfigurationStrategyEnum ShardingConfigurationStrategy { get; }
IVirtualDataSource GetCurrentVirtualDataSource();
IVirtualDataSource GetVirtualDataSource(string configId);
List<IVirtualDataSource> GetAllVirtualDataSources();
bool ContansConfigId(string configId);
/// <summary>
/// 创建分片配置scope
/// </summary>
/// <param name="configId"></param>
/// <returns></returns>
VirtualDataSourceScope CreateScope(string configId);
bool AddVirtualDataSource(IVirtualDataSourceConfigurationParams configurationParams);
void SetDefaultIfMultiConfiguration();
}
}
// using System;
// using System.Collections.Generic;
// using System.Linq;
// using System.Text;
// using System.Threading.Tasks;
// using Microsoft.EntityFrameworkCore;
// using ShardingCore.Core.ShardingConfigurations.Abstractions;
// using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Common;
// using ShardingCore.Sharding.Abstractions;
//
// namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions
// {
// public interface IVirtualDataSourceManager
// {
// bool IsMultiShardingConfiguration { get; }
// ShardingConfigurationStrategyEnum ShardingConfigurationStrategy { get; }
// IVirtualDataSource GetCurrentVirtualDataSource();
// IVirtualDataSource GetVirtualDataSource(string configId);
// List<IVirtualDataSource> GetAllVirtualDataSources();
// bool ContansConfigId(string configId);
//
// /// <summary>
// /// 创建分片配置scope
// /// </summary>
// /// <param name="configId"></param>
// /// <returns></returns>
// VirtualDataSourceScope CreateScope(string configId);
// bool AddVirtualDataSource(IVirtualDataSourceConfigurationParams configurationParams);
// void SetDefaultIfMultiConfiguration();
//
// }
// }

48
src/ShardingCore/Core/VirtualDatabase/VirtualDataSources/VirtualDataSourceAccessor.cs
View File

@ -1,24 +1,24 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
{
public class VirtualDataSourceAccessor: IVirtualDataSourceAccessor
{
private static AsyncLocal<VirtualDataSourceContext> _shardingConfigurationContext = new AsyncLocal<VirtualDataSourceContext>();
/// <summary>
/// sharding route context use in using code block
/// </summary>
public VirtualDataSourceContext DataSourceContext
{
get => _shardingConfigurationContext.Value;
set => _shardingConfigurationContext.Value = value;
}
}
}
// using System;
// using System.Collections.Generic;
// using System.Linq;
// using System.Text;
// using System.Threading;
// using System.Threading.Tasks;
// using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
//
// namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
// {
// public class VirtualDataSourceAccessor: IVirtualDataSourceAccessor
// {
// private static AsyncLocal<VirtualDataSourceContext> _shardingConfigurationContext = new AsyncLocal<VirtualDataSourceContext>();
//
// /// <summary>
// /// sharding route context use in using code block
// /// </summary>
// public VirtualDataSourceContext DataSourceContext
// {
// get => _shardingConfigurationContext.Value;
// set => _shardingConfigurationContext.Value = value;
// }
// }
// }

36
src/ShardingCore/Core/VirtualDatabase/VirtualDataSources/VirtualDataSourceContext.cs
View File

@ -1,18 +1,18 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
{
public class VirtualDataSourceContext
{
public string ConfigId { get; }
public VirtualDataSourceContext(string configId)
{
ConfigId = configId;
}
}
}
// using System;
// using System.Collections.Generic;
// using System.Linq;
// using System.Text;
// using System.Threading.Tasks;
//
// namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
// {
// public class VirtualDataSourceContext
// {
// public string ConfigId { get; }
//
// public VirtualDataSourceContext(string configId)
// {
// ConfigId = configId;
// }
// }
// }

312
src/ShardingCore/Core/VirtualDatabase/VirtualDataSources/VirtualDataSourceManager.cs
View File

@ -1,156 +1,156 @@
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using ShardingCore.Core.EntityMetadatas;
using ShardingCore.Core.ShardingConfigurations;
using ShardingCore.Core.ShardingConfigurations.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Common;
using ShardingCore.Exceptions;
using ShardingCore.Extensions;
using ShardingCore.Sharding.Abstractions;
using ShardingCore.Sharding.ReadWriteConfigurations.Abstractions;
namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
{
public class VirtualDataSourceManager : IVirtualDataSourceManager
{
private readonly IShardingConfigurationOptions _options;
private readonly IEntityMetadataManager _entityMetadataManager;
private readonly IVirtualDataSourceRouteManager _virtualDataSourceRouteManager;
private readonly IVirtualDataSourceAccessor _virtualDataSourceAccessor;
private readonly IReadWriteConnectorFactory _readWriteConnectorFactory;
private readonly ConcurrentDictionary<string, IVirtualDataSource> _virtualDataSources = new();
private string _defaultConfigId;
private IVirtualDataSource _defaultVirtualDataSource;
public VirtualDataSourceManager(IServiceProvider serviceProvider, IShardingConfigurationOptions options, IEntityMetadataManager entityMetadataManager, IVirtualDataSourceRouteManager virtualDataSourceRouteManager, IVirtualDataSourceAccessor virtualDataSourceAccessor,IReadWriteConnectorFactory readWriteConnectorFactory)
{
_options = options;
_entityMetadataManager = entityMetadataManager;
_virtualDataSourceRouteManager = virtualDataSourceRouteManager;
var allShardingGlobalConfigOptions = options.GetAllShardingGlobalConfigOptions();
if (allShardingGlobalConfigOptions.IsEmpty())
throw new ArgumentException($"sharding virtual data source is empty");
_virtualDataSourceAccessor = virtualDataSourceAccessor;
_readWriteConnectorFactory = readWriteConnectorFactory;
if (options is ShardingMultiConfigurationOptions shardingMultiConfigurationOptions)
{
IsMultiShardingConfiguration = true;
ShardingConfigurationStrategy = shardingMultiConfigurationOptions.ShardingConfigurationStrategy;
}
else if (options is ShardingSingleConfigurationOptions shardingSingleConfigurationOptions)
{
IsMultiShardingConfiguration = false;
ShardingConfigurationStrategy = shardingSingleConfigurationOptions.ShardingConfigurationStrategy;
}
foreach (var shardingGlobalConfigOption in allShardingGlobalConfigOptions)
{
var simpleVirtualDataSourceConfigurationParams = new SimpleVirtualDataSourceConfigurationParams(serviceProvider, shardingGlobalConfigOption);
AddVirtualDataSource(simpleVirtualDataSourceConfigurationParams);
}
if (!IsMultiShardingConfiguration)
{
if (_defaultVirtualDataSource != null || _defaultConfigId != null)
throw new ShardingCoreInvalidOperationException("set sharding configuration error");
_defaultConfigId = _virtualDataSources.First().Key;
_defaultVirtualDataSource = _virtualDataSources.First().Value;
}
else if (ShardingConfigurationStrategy == ShardingConfigurationStrategyEnum.ReturnHighPriority)
{
var maxShardingConfiguration = _virtualDataSources.Values.OrderByDescending(o => o.Priority).FirstOrDefault();
_defaultVirtualDataSource = maxShardingConfiguration;
_defaultConfigId = maxShardingConfiguration.ConfigId;
}
}
public bool IsMultiShardingConfiguration { get; }
public ShardingConfigurationStrategyEnum ShardingConfigurationStrategy { get; }
public IVirtualDataSource GetCurrentVirtualDataSource()
{
if (!IsMultiShardingConfiguration)
return _defaultVirtualDataSource;
var configId = _virtualDataSourceAccessor.DataSourceContext?.ConfigId;
if (!string.IsNullOrWhiteSpace(configId))
{
var hasValue = _virtualDataSources.TryGetValue(configId, out var virtualDataSource);
if (hasValue)
{
return virtualDataSource;
}
}
switch (ShardingConfigurationStrategy)
{
case ShardingConfigurationStrategyEnum.ReturnNull: return null;
case ShardingConfigurationStrategyEnum.ReturnHighPriority: return _defaultVirtualDataSource;
case ShardingConfigurationStrategyEnum.ThrowIfNull: throw new ShardingCoreNotFoundException($"no configuration,config id:[{configId}]");
default:
throw new ShardingCoreException(
$"unknown {nameof(ShardingConfigurationStrategyEnum)}:[{ShardingConfigurationStrategy}]");
}
}
public IVirtualDataSource GetVirtualDataSource(string configId)
{
var hasValue = _virtualDataSources.TryGetValue(configId, out var virtualDataSource);
if (hasValue)
{
return virtualDataSource;
}
switch (ShardingConfigurationStrategy)
{
case ShardingConfigurationStrategyEnum.ReturnNull: return null;
case ShardingConfigurationStrategyEnum.ReturnHighPriority: return _defaultVirtualDataSource;
case ShardingConfigurationStrategyEnum.ThrowIfNull: throw new ShardingCoreNotFoundException($"no configuration,config id:[{configId}]");
default:
throw new ShardingCoreException(
$"unknown {nameof(ShardingConfigurationStrategyEnum)}:[{ShardingConfigurationStrategy}]");
}
}
public bool ContansConfigId(string configId)
{
return _virtualDataSources.ContainsKey(configId);
}
public bool AddVirtualDataSource(IVirtualDataSourceConfigurationParams configurationParams)
{
if (!IsMultiShardingConfiguration&&_virtualDataSources.IsNotEmpty())
throw new NotSupportedException("not support multi sharding configuration");
var dataSource = new VirtualDataSource(_entityMetadataManager, _virtualDataSourceRouteManager, configurationParams,_readWriteConnectorFactory);
dataSource.CheckVirtualDataSource();
return _virtualDataSources.TryAdd(dataSource.ConfigId, dataSource);
}
public void SetDefaultIfMultiConfiguration()
{
if (IsMultiShardingConfiguration && ShardingConfigurationStrategy == ShardingConfigurationStrategyEnum.ReturnHighPriority)
{
var maxShardingConfiguration = _virtualDataSources.Values.OrderByDescending(o => o.Priority).FirstOrDefault();
if (maxShardingConfiguration.ConfigId != _defaultConfigId)
{
_defaultConfigId = maxShardingConfiguration.ConfigId;
_defaultVirtualDataSource = maxShardingConfiguration;
}
}
}
public List<IVirtualDataSource> GetAllVirtualDataSources()
{
if (!IsMultiShardingConfiguration)
return new List<IVirtualDataSource>(1) { _defaultVirtualDataSource };
return _virtualDataSources.Values.ToList();
}
public VirtualDataSourceScope CreateScope(string configId)
{
var virtualDataSourceScope = new VirtualDataSourceScope(_virtualDataSourceAccessor);
_virtualDataSourceAccessor.DataSourceContext = new VirtualDataSourceContext(configId);
return virtualDataSourceScope;
}
}
}
// using System;
// using System.Collections.Concurrent;
// using System.Collections.Generic;
// using System.Linq;
// using System.Text;
// using System.Threading.Tasks;
// using Microsoft.EntityFrameworkCore;
// using ShardingCore.Core.EntityMetadatas;
// using ShardingCore.Core.ShardingConfigurations;
// using ShardingCore.Core.ShardingConfigurations.Abstractions;
// using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
// using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Common;
// using ShardingCore.Exceptions;
// using ShardingCore.Extensions;
// using ShardingCore.Sharding.Abstractions;
// using ShardingCore.Sharding.ReadWriteConfigurations.Abstractions;
//
// namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
// {
// public class VirtualDataSourceManager : IVirtualDataSourceManager
// {
// private readonly IShardingConfigurationOptions _options;
// private readonly IEntityMetadataManager _entityMetadataManager;
// private readonly IVirtualDataSourceRouteManager _virtualDataSourceRouteManager;
// private readonly IVirtualDataSourceAccessor _virtualDataSourceAccessor;
// private readonly IReadWriteConnectorFactory _readWriteConnectorFactory;
//
// private readonly ConcurrentDictionary<string, IVirtualDataSource> _virtualDataSources = new();
//
// private string _defaultConfigId;
// private IVirtualDataSource _defaultVirtualDataSource;
// public VirtualDataSourceManager(IServiceProvider serviceProvider, IShardingConfigurationOptions options, IEntityMetadataManager entityMetadataManager, IVirtualDataSourceRouteManager virtualDataSourceRouteManager, IVirtualDataSourceAccessor virtualDataSourceAccessor,IReadWriteConnectorFactory readWriteConnectorFactory)
// {
//
// _options = options;
// _entityMetadataManager = entityMetadataManager;
// _virtualDataSourceRouteManager = virtualDataSourceRouteManager;
// var allShardingGlobalConfigOptions = options.GetAllShardingGlobalConfigOptions();
// if (allShardingGlobalConfigOptions.IsEmpty())
// throw new ArgumentException($"sharding virtual data source is empty");
// _virtualDataSourceAccessor = virtualDataSourceAccessor;
// _readWriteConnectorFactory = readWriteConnectorFactory;
// if (options is ShardingMultiConfigurationOptions shardingMultiConfigurationOptions)
// {
// IsMultiShardingConfiguration = true;
// ShardingConfigurationStrategy = shardingMultiConfigurationOptions.ShardingConfigurationStrategy;
// }
// else if (options is ShardingSingleConfigurationOptions shardingSingleConfigurationOptions)
// {
// IsMultiShardingConfiguration = false;
// ShardingConfigurationStrategy = shardingSingleConfigurationOptions.ShardingConfigurationStrategy;
// }
// foreach (var shardingGlobalConfigOption in allShardingGlobalConfigOptions)
// {
// var simpleVirtualDataSourceConfigurationParams = new SimpleVirtualDataSourceConfigurationParams(serviceProvider, shardingGlobalConfigOption);
// AddVirtualDataSource(simpleVirtualDataSourceConfigurationParams);
// }
// if (!IsMultiShardingConfiguration)
// {
// if (_defaultVirtualDataSource != null || _defaultConfigId != null)
// throw new ShardingCoreInvalidOperationException("set sharding configuration error");
// _defaultConfigId = _virtualDataSources.First().Key;
// _defaultVirtualDataSource = _virtualDataSources.First().Value;
// }
// else if (ShardingConfigurationStrategy == ShardingConfigurationStrategyEnum.ReturnHighPriority)
// {
// var maxShardingConfiguration = _virtualDataSources.Values.OrderByDescending(o => o.Priority).FirstOrDefault();
// _defaultVirtualDataSource = maxShardingConfiguration;
// _defaultConfigId = maxShardingConfiguration.ConfigId;
// }
// }
// public bool IsMultiShardingConfiguration { get; }
// public ShardingConfigurationStrategyEnum ShardingConfigurationStrategy { get; }
// public IVirtualDataSource GetCurrentVirtualDataSource()
// {
// if (!IsMultiShardingConfiguration)
// return _defaultVirtualDataSource;
// var configId = _virtualDataSourceAccessor.DataSourceContext?.ConfigId;
// if (!string.IsNullOrWhiteSpace(configId))
// {
// var hasValue = _virtualDataSources.TryGetValue(configId, out var virtualDataSource);
// if (hasValue)
// {
// return virtualDataSource;
// }
// }
//
// switch (ShardingConfigurationStrategy)
// {
// case ShardingConfigurationStrategyEnum.ReturnNull: return null;
// case ShardingConfigurationStrategyEnum.ReturnHighPriority: return _defaultVirtualDataSource;
// case ShardingConfigurationStrategyEnum.ThrowIfNull: throw new ShardingCoreNotFoundException($"no configuration,config id:[{configId}]");
// default:
// throw new ShardingCoreException(
// $"unknown {nameof(ShardingConfigurationStrategyEnum)}:[{ShardingConfigurationStrategy}]");
// }
// }
// public IVirtualDataSource GetVirtualDataSource(string configId)
// {
// var hasValue = _virtualDataSources.TryGetValue(configId, out var virtualDataSource);
// if (hasValue)
// {
// return virtualDataSource;
// }
// switch (ShardingConfigurationStrategy)
// {
// case ShardingConfigurationStrategyEnum.ReturnNull: return null;
// case ShardingConfigurationStrategyEnum.ReturnHighPriority: return _defaultVirtualDataSource;
// case ShardingConfigurationStrategyEnum.ThrowIfNull: throw new ShardingCoreNotFoundException($"no configuration,config id:[{configId}]");
// default:
// throw new ShardingCoreException(
// $"unknown {nameof(ShardingConfigurationStrategyEnum)}:[{ShardingConfigurationStrategy}]");
// }
// }
//
// public bool ContansConfigId(string configId)
// {
// return _virtualDataSources.ContainsKey(configId);
// }
//
// public bool AddVirtualDataSource(IVirtualDataSourceConfigurationParams configurationParams)
// {
// if (!IsMultiShardingConfiguration&&_virtualDataSources.IsNotEmpty())
// throw new NotSupportedException("not support multi sharding configuration");
// var dataSource = new VirtualDataSource(_entityMetadataManager, _virtualDataSourceRouteManager, configurationParams,_readWriteConnectorFactory);
// dataSource.CheckVirtualDataSource();
// return _virtualDataSources.TryAdd(dataSource.ConfigId, dataSource);
// }
//
// public void SetDefaultIfMultiConfiguration()
// {
// if (IsMultiShardingConfiguration && ShardingConfigurationStrategy == ShardingConfigurationStrategyEnum.ReturnHighPriority)
// {
// var maxShardingConfiguration = _virtualDataSources.Values.OrderByDescending(o => o.Priority).FirstOrDefault();
// if (maxShardingConfiguration.ConfigId != _defaultConfigId)
// {
// _defaultConfigId = maxShardingConfiguration.ConfigId;
// _defaultVirtualDataSource = maxShardingConfiguration;
// }
// }
// }
// public List<IVirtualDataSource> GetAllVirtualDataSources()
// {
// if (!IsMultiShardingConfiguration)
// return new List<IVirtualDataSource>(1) { _defaultVirtualDataSource };
// return _virtualDataSources.Values.ToList();
// }
//
// public VirtualDataSourceScope CreateScope(string configId)
// {
// var virtualDataSourceScope = new VirtualDataSourceScope(_virtualDataSourceAccessor);
// _virtualDataSourceAccessor.DataSourceContext = new VirtualDataSourceContext(configId);
// return virtualDataSourceScope;
// }
// }
// }

6
src/ShardingCore/Core/VirtualDatabase/VirtualDataSources/VirtualDataSourceRouteManager.cs
View File

@ -18,14 +18,8 @@ namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
{
public class VirtualDataSourceRouteManager : IVirtualDataSourceRouteManager
{
private readonly IEntityMetadataManager _entityMetadataManager;
private readonly ConcurrentDictionary<Type, IVirtualDataSourceRoute> _dataSourceVirtualRoutes = new ConcurrentDictionary<Type, IVirtualDataSourceRoute>();
public VirtualDataSourceRouteManager(IEntityMetadataManager entityMetadataManager)
{
_entityMetadataManager = entityMetadataManager;
}
public IVirtualDataSourceRoute<TEntity> GetRoute<TEntity>() where TEntity : class
{
return (IVirtualDataSourceRoute<TEntity>)GetRoute(typeof(TEntity));

68
src/ShardingCore/Core/VirtualDatabase/VirtualDataSources/VirtualDataSourceScope.cs
View File

@ -1,34 +1,34 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
{
public class VirtualDataSourceScope:IDisposable
{
/// <summary>
/// 分片配置访问器
/// </summary>
public IVirtualDataSourceAccessor VirtualDataSourceAccessor { get; }
/// <summary>
/// 构造函数
/// </summary>
/// <param name="virtualDataSourceAccessor"></param>
public VirtualDataSourceScope(IVirtualDataSourceAccessor virtualDataSourceAccessor)
{
VirtualDataSourceAccessor = virtualDataSourceAccessor;
}
/// <summary>
/// 回收
/// </summary>
public void Dispose()
{
VirtualDataSourceAccessor.DataSourceContext = null;
}
}
}
// using System;
// using System.Collections.Generic;
// using System.Linq;
// using System.Text;
// using System.Threading.Tasks;
// using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
//
// namespace ShardingCore.Core.VirtualDatabase.VirtualDataSources
// {
// public class VirtualDataSourceScope:IDisposable
// {
// /// <summary>
// /// 分片配置访问器
// /// </summary>
// public IVirtualDataSourceAccessor VirtualDataSourceAccessor { get; }
//
// /// <summary>
// /// 构造函数
// /// </summary>
// /// <param name="virtualDataSourceAccessor"></param>
// public VirtualDataSourceScope(IVirtualDataSourceAccessor virtualDataSourceAccessor)
// {
// VirtualDataSourceAccessor = virtualDataSourceAccessor;
// }
//
// /// <summary>
// /// 回收
// /// </summary>
// public void Dispose()
// {
// VirtualDataSourceAccessor.DataSourceContext = null;
// }
// }
// }

36
src/ShardingCore/DIExtension.cs
View File

@ -12,7 +12,6 @@ using ShardingCore.Core.ShardingPage;
using ShardingCore.Core.ShardingPage.Abstractions;
using ShardingCore.Core.TrackerManagers;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
using ShardingCore.Core.VirtualDatabase.VirtualTables;
using ShardingCore.Core.VirtualRoutes;
using ShardingCore.Core.VirtualRoutes.DataSourceRoutes.RouteRuleEngine;
using ShardingCore.Core.VirtualRoutes.TableRoutes.RouteTails.Abstractions;
@ -26,16 +25,13 @@ using ShardingCore.Sharding.Abstractions;
using ShardingCore.Sharding.ShardingQueryExecutors;
using ShardingCore.TableCreator;
using System;
using Microsoft.EntityFrameworkCore.Query;
using ShardingCore.Bootstrappers;
using ShardingCore.Core;
using ShardingCore.Core.DbContextCreator;
using ShardingCore.Core.QueryTrackers;
using ShardingCore.Core.ShardingConfigurations;
using ShardingCore.Core.UnionAllMergeShardingProviders;
using ShardingCore.Core.UnionAllMergeShardingProviders.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
using ShardingCore.DynamicDataSources;
using ShardingCore.Sharding.MergeContexts;
using ShardingCore.Sharding.ParallelTables;
using ShardingCore.Sharding.Parsers;
@ -44,7 +40,6 @@ using ShardingCore.Sharding.ReadWriteConfigurations;
using ShardingCore.Sharding.ReadWriteConfigurations.Abstractions;
using ShardingCore.Sharding.ShardingExecutors;
using ShardingCore.Sharding.ShardingExecutors.NativeTrackQueries;
using ShardingCore.TableExists;
namespace ShardingCore
{
@ -87,41 +82,44 @@ namespace ShardingCore
public static void UseDefaultSharding<TShardingDbContext>(IServiceProvider serviceProvider,DbContextOptionsBuilder dbContextOptionsBuilder) where TShardingDbContext : DbContext, IShardingDbContext
{
var virtualDataSource = serviceProvider.GetRequiredService<IVirtualDataSourceManager<TShardingDbContext>>().GetCurrentVirtualDataSource();
var shardingRuntimeContext = serviceProvider.GetRequiredService<IShardingRuntimeContext>();
shardingRuntimeContext.WithApplicationServiceProvider(serviceProvider);
var virtualDataSource = serviceProvider.GetRequiredService<IVirtualDataSourceManager>().GetCurrentVirtualDataSource();
var connectionString = virtualDataSource.GetConnectionString(virtualDataSource.DefaultDataSourceName);
var contextOptionsBuilder = virtualDataSource.ConfigurationParams.UseDbContextOptionsBuilder(connectionString, dbContextOptionsBuilder).UseSharding<TShardingDbContext>();
virtualDataSource.ConfigurationParams.UseShellDbContextOptionBuilder(contextOptionsBuilder);
}
internal static IServiceCollection AddInternalShardingCore<TShardingDbContext>(this IServiceCollection services) where TShardingDbContext : DbContext, IShardingDbContext
{
//虚拟数据源管理者
services.TryAddSingleton<IVirtualDataSourceManager<TShardingDbContext>, VirtualDataSourceManager<TShardingDbContext>>();
services.TryAddSingleton<IVirtualDataSourceManager, VirtualDataSourceManager>();
services.TryAddSingleton<IVirtualDataSourceAccessor, VirtualDataSourceAccessor>();
//分表dbcontext创建
services.TryAddSingleton<IDbContextCreator<TShardingDbContext>, ActivatorDbContextCreator<TShardingDbContext>>();
services.TryAddSingleton<IDbContextCreator, ActivatorDbContextCreator<TShardingDbContext>>();
services.TryAddSingleton<IDataSourceInitializer<TShardingDbContext>, DataSourceInitializer<TShardingDbContext>>();
services.TryAddSingleton<ITrackerManager<TShardingDbContext>, TrackerManager<TShardingDbContext>>();
// services.TryAddSingleton<IDataSourceInitializer<TShardingDbContext>, DataSourceInitializer<TShardingDbContext>>();
services.TryAddSingleton<ITrackerManager, TrackerManager>();
services.TryAddSingleton<IStreamMergeContextFactory<TShardingDbContext>, StreamMergeContextFactory<TShardingDbContext>>();
services.TryAddSingleton<IShardingTableCreator<TShardingDbContext>, ShardingTableCreator<TShardingDbContext>>();
services.TryAddSingleton<IShardingTableCreator, ShardingTableCreator>();
//虚拟数据源管理
services.TryAddSingleton<IVirtualDataSourceRouteManager<TShardingDbContext>, VirtualDataSourceRouteManager<TShardingDbContext>>();
services.TryAddSingleton<IVirtualDataSourceRouteManager, VirtualDataSourceRouteManager>();
services.TryAddSingleton<IDataSourceRouteRuleEngine<TShardingDbContext>, DataSourceRouteRuleEngine<TShardingDbContext>>();
services.TryAddSingleton<IDataSourceRouteRuleEngineFactory<TShardingDbContext>, DataSourceRouteRuleEngineFactory<TShardingDbContext>>();
//读写分离链接创建工厂
services.TryAddSingleton<IReadWriteConnectorFactory, ReadWriteConnectorFactory>();
//虚拟表管理
services.TryAddSingleton<IVirtualTableManager<TShardingDbContext>, VirtualTableManager<TShardingDbContext>>();
// services.TryAddSingleton<IVirtualTableManager<TShardingDbContext>, VirtualTableManager<TShardingDbContext>>();
//分表分库对象元信息管理
services.TryAddSingleton<IEntityMetadataManager<TShardingDbContext>, DefaultEntityMetadataManager<TShardingDbContext>>();
services.TryAddSingleton<IEntityMetadataManager, DefaultEntityMetadataManager>();
//分表引擎
services.TryAddSingleton<ITableRouteRuleEngineFactory<TShardingDbContext>, TableRouteRuleEngineFactory<TShardingDbContext>>();
services.TryAddSingleton<ITableRouteRuleEngine<TShardingDbContext>, TableRouteRuleEngine<TShardingDbContext>>();
services.TryAddSingleton<ITableRouteRuleEngineFactory, TableRouteRuleEngineFactory>();
services.TryAddSingleton<ITableRouteRuleEngine, TableRouteRuleEngine>();
//分表引擎工程
services.TryAddSingleton<IParallelTableManager<TShardingDbContext>, ParallelTableManager<TShardingDbContext>>();
services.TryAddSingleton<IParallelTableManager, ParallelTableManager>();
services.TryAddSingleton<IRouteTailFactory, RouteTailFactory>();
services.TryAddSingleton<IShardingCompilerExecutor, DefaultShardingCompilerExecutor>();
services.TryAddSingleton<IQueryCompilerContextFactory, QueryCompilerContextFactory>();
@ -154,9 +152,9 @@ namespace ShardingCore
services.TryAddShardingJob();
return services;
}
public static DbContextOptionsBuilder UseSharding<TShardingDbContext>(this DbContextOptionsBuilder optionsBuilder) where TShardingDbContext : DbContext, IShardingDbContext
public static DbContextOptionsBuilder UseSharding<TShardingDbContext>(this DbContextOptionsBuilder optionsBuilder,IShardingRuntimeContext shardingRuntimeContext) where TShardingDbContext : DbContext, IShardingDbContext
{
return optionsBuilder.UseShardingWrapMark()
return optionsBuilder.UseShardingWrapMark(shardingRuntimeContext)
.ReplaceService<IDbSetSource, ShardingDbSetSource>()
.ReplaceService<IQueryCompiler, ShardingQueryCompiler>()
.ReplaceService<IDbContextTransactionManager, ShardingRelationalTransactionManager<TShardingDbContext>>()

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

@ -1,175 +1,175 @@
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using ShardingCore.Core.EntityMetadatas;
using ShardingCore.Core.PhysicTables;
using ShardingCore.Core.ShardingConfigurations.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualTables;
using ShardingCore.Core.VirtualRoutes.TableRoutes.RouteTails.Abstractions;
using ShardingCore.Core.VirtualTables;
using ShardingCore.Exceptions;
using ShardingCore.Extensions;
using ShardingCore.Sharding.Abstractions;
using ShardingCore.TableCreator;
using System;
using System.Collections.Generic;
using System.Threading;
using ShardingCore.Logger;
namespace ShardingCore.DynamicDataSources
{
public class DataSourceInitializer<TShardingDbContext> : IDataSourceInitializer<TShardingDbContext>
where TShardingDbContext : DbContext, IShardingDbContext
{
private static readonly ILogger<DataSourceInitializer<TShardingDbContext>> _logger =
InternalLoggerFactory.CreateLogger<DataSourceInitializer<TShardingDbContext>>();
private readonly IShardingEntityConfigOptions<TShardingDbContext> _entityConfigOptions;
private readonly IVirtualDataSourceManager<TShardingDbContext> _virtualDataSourceManager;
private readonly IRouteTailFactory _routeTailFactory;
private readonly IVirtualTableManager<TShardingDbContext> _virtualTableManager;
private readonly IEntityMetadataManager<TShardingDbContext> _entityMetadataManager;
private readonly IShardingTableCreator<TShardingDbContext> _tableCreator;
public DataSourceInitializer(
IShardingEntityConfigOptions<TShardingDbContext> entityConfigOptions,
IVirtualDataSourceManager<TShardingDbContext> virtualDataSourceManager,
IRouteTailFactory routeTailFactory, IVirtualTableManager<TShardingDbContext> virtualTableManager,
IEntityMetadataManager<TShardingDbContext> entityMetadataManager,
IShardingTableCreator<TShardingDbContext> shardingTableCreator)
{
_entityConfigOptions = entityConfigOptions;
_virtualDataSourceManager = virtualDataSourceManager;
_routeTailFactory = routeTailFactory;
_virtualTableManager = virtualTableManager;
_entityMetadataManager = entityMetadataManager;
_tableCreator = shardingTableCreator;
}
public void InitConfigure(IVirtualDataSource<TShardingDbContext> virtualDataSource, string dataSourceName)
{
using (_virtualDataSourceManager.CreateScope(virtualDataSource.ConfigId))
{
// var createDatabase = !needCreateDatabase.HasValue || needCreateDatabase.Value;
//
// if ((_entityConfigOptions.EnsureCreatedWithOutShardingTable || !isOnStart)&&createDatabase)
// EnsureCreated(virtualDataSource, context, dataSourceName);
// else if (_entityConfigOptions.CreateDataBaseOnlyOnStart.GetValueOrDefault()&& createDatabase)
// {
// EnsureCreateDataBaseOnly(context, dataSourceName);
// }
// var tableEnsureManager = virtualDataSource.ConfigurationParams.TableEnsureManager;
// ////获取数据库存在的所有的表
// var existTables = tableEnsureManager?.GetExistTables(context, dataSourceName) ??
// new HashSet<string>();
var allShardingEntities = _entityMetadataManager.GetAllShardingEntities();
foreach (var entityType in allShardingEntities)
{
//如果是默认数据源
if (virtualDataSource.IsDefault(dataSourceName))
{
if (_entityMetadataManager.IsShardingTable(entityType))
{
var virtualTable = _virtualTableManager.GetVirtualTable(entityType);
InitVirtualTable(virtualTable);
}
}
else
{
//非默认数据源
if (_entityMetadataManager.IsShardingDataSource(entityType))
{
var virtualDataSourceRoute = virtualDataSource.GetRoute(entityType);
if (virtualDataSourceRoute.GetAllDataSourceNames().Contains(dataSourceName))
{
if (_entityMetadataManager.IsShardingTable(entityType))
{
var virtualTable = _virtualTableManager.GetVirtualTable(entityType);
//创建表
InitVirtualTable(virtualTable);
}
}
}
}
}
}
}
private void InitVirtualTable(IVirtualTable virtualTable)
{
foreach (var tail in virtualTable.GetVirtualRoute().GetTails())
{
var defaultPhysicTable = new DefaultPhysicTable(virtualTable, tail);
virtualTable.AddPhysicTable(defaultPhysicTable);
}
}
//
// private bool NeedCreateTable(EntityMetadata entityMetadata)
// {
// if (entityMetadata.AutoCreateTable.HasValue)
// {
// if (entityMetadata.AutoCreateTable.Value)
// return entityMetadata.AutoCreateTable.Value;
// else
// {
// if (entityMetadata.AutoCreateDataSourceTable.HasValue)
// return entityMetadata.AutoCreateDataSourceTable.Value;
// }
// }
//
// if (entityMetadata.AutoCreateDataSourceTable.HasValue)
// {
// if (entityMetadata.AutoCreateDataSourceTable.Value)
// return entityMetadata.AutoCreateDataSourceTable.Value;
// else
// {
// if (entityMetadata.AutoCreateTable.HasValue)
// return entityMetadata.AutoCreateTable.Value;
// }
// }
//
// return _entityConfigOptions.CreateShardingTableOnStart.GetValueOrDefault();
// }
//
// private void EnsureCreated(IVirtualDataSource<TShardingDbContext> virtualDataSource, DbContext context,
// string dataSourceName)
// {
// if (context is IShardingDbContext shardingDbContext)
// {
// using (var dbContext =
// shardingDbContext.GetDbContext(dataSourceName, false,
// _routeTailFactory.Create(string.Empty, false)))
// {
// var isDefault = virtualDataSource.IsDefault(dataSourceName);
//
// if (isDefault)
// {
// dbContext.RemoveDbContextRelationModelThatIsShardingTable();
// }
// else
// {
// dbContext.RemoveDbContextAllRelationModelThatIsNoSharding();
// }
//
// dbContext.Database.EnsureCreated();
// }
// }
// }
//
// private void EnsureCreateDataBaseOnly(DbContext context, string dataSourceName)
// {
// if (context is IShardingDbContext shardingDbContext)
// {
// using (var dbContext = shardingDbContext.GetDbContext(dataSourceName, false,
// _routeTailFactory.Create(string.Empty, false)))
// {
// dbContext.RemoveDbContextAllRelationModel();
// dbContext.Database.EnsureCreated();
// }
// }
// }
}
}
// using Microsoft.EntityFrameworkCore;
// using Microsoft.Extensions.DependencyInjection;
// using Microsoft.Extensions.Logging;
// using ShardingCore.Core.EntityMetadatas;
// using ShardingCore.Core.PhysicTables;
// using ShardingCore.Core.ShardingConfigurations.Abstractions;
// using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
// using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
// using ShardingCore.Core.VirtualDatabase.VirtualTables;
// using ShardingCore.Core.VirtualRoutes.TableRoutes.RouteTails.Abstractions;
// using ShardingCore.Core.VirtualTables;
// using ShardingCore.Exceptions;
// using ShardingCore.Extensions;
// using ShardingCore.Sharding.Abstractions;
// using ShardingCore.TableCreator;
// using System;
// using System.Collections.Generic;
// using System.Threading;
// using ShardingCore.Logger;
//
// namespace ShardingCore.DynamicDataSources
// {
// public class DataSourceInitializer<TShardingDbContext> : IDataSourceInitializer<TShardingDbContext>
// where TShardingDbContext : DbContext, IShardingDbContext
// {
// private static readonly ILogger<DataSourceInitializer<TShardingDbContext>> _logger =
// InternalLoggerFactory.CreateLogger<DataSourceInitializer<TShardingDbContext>>();
//
// private readonly IShardingEntityConfigOptions<TShardingDbContext> _entityConfigOptions;
// private readonly IVirtualDataSourceManager<TShardingDbContext> _virtualDataSourceManager;
// private readonly IRouteTailFactory _routeTailFactory;
// private readonly IVirtualTableManager<TShardingDbContext> _virtualTableManager;
// private readonly IEntityMetadataManager<TShardingDbContext> _entityMetadataManager;
// private readonly IShardingTableCreator<TShardingDbContext> _tableCreator;
//
// public DataSourceInitializer(
// IShardingEntityConfigOptions<TShardingDbContext> entityConfigOptions,
// IVirtualDataSourceManager<TShardingDbContext> virtualDataSourceManager,
// IRouteTailFactory routeTailFactory, IVirtualTableManager<TShardingDbContext> virtualTableManager,
// IEntityMetadataManager<TShardingDbContext> entityMetadataManager,
// IShardingTableCreator<TShardingDbContext> shardingTableCreator)
// {
// _entityConfigOptions = entityConfigOptions;
// _virtualDataSourceManager = virtualDataSourceManager;
// _routeTailFactory = routeTailFactory;
// _virtualTableManager = virtualTableManager;
// _entityMetadataManager = entityMetadataManager;
// _tableCreator = shardingTableCreator;
// }
//
// public void InitConfigure(IVirtualDataSource<TShardingDbContext> virtualDataSource, string dataSourceName)
// {
// using (_virtualDataSourceManager.CreateScope(virtualDataSource.ConfigId))
// {
// // var createDatabase = !needCreateDatabase.HasValue || needCreateDatabase.Value;
// //
// // if ((_entityConfigOptions.EnsureCreatedWithOutShardingTable || !isOnStart)&&createDatabase)
// // EnsureCreated(virtualDataSource, context, dataSourceName);
// // else if (_entityConfigOptions.CreateDataBaseOnlyOnStart.GetValueOrDefault()&& createDatabase)
// // {
// // EnsureCreateDataBaseOnly(context, dataSourceName);
// // }
//
// // var tableEnsureManager = virtualDataSource.ConfigurationParams.TableEnsureManager;
// // ////获取数据库存在的所有的表
// // var existTables = tableEnsureManager?.GetExistTables(context, dataSourceName) ??
// // new HashSet<string>();
// var allShardingEntities = _entityMetadataManager.GetAllShardingEntities();
// foreach (var entityType in allShardingEntities)
// {
// //如果是默认数据源
// if (virtualDataSource.IsDefault(dataSourceName))
// {
// if (_entityMetadataManager.IsShardingTable(entityType))
// {
// var virtualTable = _virtualTableManager.GetVirtualTable(entityType);
// InitVirtualTable(virtualTable);
// }
// }
// else
// {
// //非默认数据源
// if (_entityMetadataManager.IsShardingDataSource(entityType))
// {
// var virtualDataSourceRoute = virtualDataSource.GetRoute(entityType);
// if (virtualDataSourceRoute.GetAllDataSourceNames().Contains(dataSourceName))
// {
// if (_entityMetadataManager.IsShardingTable(entityType))
// {
// var virtualTable = _virtualTableManager.GetVirtualTable(entityType);
// //创建表
// InitVirtualTable(virtualTable);
// }
// }
// }
// }
// }
// }
// }
//
// private void InitVirtualTable(IVirtualTable virtualTable)
// {
// foreach (var tail in virtualTable.GetVirtualRoute().GetTails())
// {
// var defaultPhysicTable = new DefaultPhysicTable(virtualTable, tail);
// virtualTable.AddPhysicTable(defaultPhysicTable);
// }
// }
// //
// // private bool NeedCreateTable(EntityMetadata entityMetadata)
// // {
// // if (entityMetadata.AutoCreateTable.HasValue)
// // {
// // if (entityMetadata.AutoCreateTable.Value)
// // return entityMetadata.AutoCreateTable.Value;
// // else
// // {
// // if (entityMetadata.AutoCreateDataSourceTable.HasValue)
// // return entityMetadata.AutoCreateDataSourceTable.Value;
// // }
// // }
// //
// // if (entityMetadata.AutoCreateDataSourceTable.HasValue)
// // {
// // if (entityMetadata.AutoCreateDataSourceTable.Value)
// // return entityMetadata.AutoCreateDataSourceTable.Value;
// // else
// // {
// // if (entityMetadata.AutoCreateTable.HasValue)
// // return entityMetadata.AutoCreateTable.Value;
// // }
// // }
// //
// // return _entityConfigOptions.CreateShardingTableOnStart.GetValueOrDefault();
// // }
// //
// // private void EnsureCreated(IVirtualDataSource<TShardingDbContext> virtualDataSource, DbContext context,
// // string dataSourceName)
// // {
// // if (context is IShardingDbContext shardingDbContext)
// // {
// // using (var dbContext =
// // shardingDbContext.GetDbContext(dataSourceName, false,
// // _routeTailFactory.Create(string.Empty, false)))
// // {
// // var isDefault = virtualDataSource.IsDefault(dataSourceName);
// //
// // if (isDefault)
// // {
// // dbContext.RemoveDbContextRelationModelThatIsShardingTable();
// // }
// // else
// // {
// // dbContext.RemoveDbContextAllRelationModelThatIsNoSharding();
// // }
// //
// // dbContext.Database.EnsureCreated();
// // }
// // }
// // }
// //
// // private void EnsureCreateDataBaseOnly(DbContext context, string dataSourceName)
// // {
// // if (context is IShardingDbContext shardingDbContext)
// // {
// // using (var dbContext = shardingDbContext.GetDbContext(dataSourceName, false,
// // _routeTailFactory.Create(string.Empty, false)))
// // {
// // dbContext.RemoveDbContextAllRelationModel();
// // dbContext.Database.EnsureCreated();
// // }
// // }
// // }
// }
// }

190
src/ShardingCore/DynamicDataSources/DynamicDataSourceHelper.cs
View File

@ -1,95 +1,95 @@
using Microsoft.EntityFrameworkCore;
using ShardingCore.Sharding.Abstractions;
using System;
using System.Collections.Generic;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
using ShardingCore.Exceptions;
using ShardingCore.Sharding.ReadWriteConfigurations;
using ShardingCore.Sharding.ReadWriteConfigurations.Abstractions;
namespace ShardingCore.DynamicDataSources
{
[Obsolete("plz use DynamicShardingHelper")]
public class DynamicDataSourceHelper
{
private DynamicDataSourceHelper()
{
throw new InvalidOperationException($"{nameof(DynamicDataSourceHelper)} create instance");
}
public static void DynamicAppendDataSource<TShardingDbContext>(IVirtualDataSource<TShardingDbContext> virtualDataSource,string dataSourceName, string connectionString) where TShardingDbContext : DbContext, IShardingDbContext
{
var defaultDataSourceInitializer = ShardingContainer.GetService<IDataSourceInitializer<TShardingDbContext>>();
defaultDataSourceInitializer.InitConfigure(virtualDataSource,dataSourceName, connectionString, false);
}
public static void DynamicAppendDataSource<TShardingDbContext>(string configId,string dataSourceName, string connectionString) where TShardingDbContext : DbContext, IShardingDbContext
{
var defaultDataSourceInitializer = ShardingContainer.GetService<IDataSourceInitializer<TShardingDbContext>>();
var virtualDataSourceManager = ShardingContainer.GetService<IVirtualDataSourceManager<TShardingDbContext>>();
var virtualDataSource = virtualDataSourceManager.GetVirtualDataSource(configId);
defaultDataSourceInitializer.InitConfigure(virtualDataSource, dataSourceName, connectionString, false);
}
public static bool DynamicAppendVirtualDataSource<TShardingDbContext>(
IVirtualDataSourceConfigurationParams<TShardingDbContext> configurationParams)
where TShardingDbContext : DbContext, IShardingDbContext
{
var virtualDataSourceManager = ShardingContainer.GetRequiredVirtualDataSourceManager<TShardingDbContext>();
if (virtualDataSourceManager.AddVirtualDataSource(configurationParams))
{
virtualDataSourceManager.SetDefaultIfMultiConfiguration();
var dataSourceInitializer = ShardingContainer.GetService<IDataSourceInitializer<TShardingDbContext>>();
var virtualDataSource = virtualDataSourceManager.GetVirtualDataSource(configurationParams.ConfigId);
foreach (var dataSource in virtualDataSource.GetDataSources())
{
var dataSourceName = dataSource.Key;
var connectionString = dataSource.Value;
dataSourceInitializer.InitConfigure(virtualDataSource, dataSourceName, connectionString, false);
}
return true;
}
return false;
}
/// <summary>
/// 动态添加读写分离链接字符串
/// </summary>
/// <typeparam name="TShardingDbContext"></typeparam>
/// <param name="virtualDataSource"></param>
/// <param name="dataSourceName"></param>
/// <param name="connectionString"></param>
/// <param name="readNodeName"></param>
/// <exception cref="ShardingCoreInvalidOperationException"></exception>
public static void DynamicAppendReadWriteConnectionString<TShardingDbContext>(IVirtualDataSource<TShardingDbContext> virtualDataSource, string dataSourceName,
string connectionString,string readNodeName = null) where TShardingDbContext : DbContext, IShardingDbContext
{
if (virtualDataSource.ConnectionStringManager is IReadWriteConnectionStringManager
readWriteAppendConnectionString)
{
readWriteAppendConnectionString.AddReadConnectionString(dataSourceName, connectionString, readNodeName);
return;
}
throw new ShardingCoreInvalidOperationException(
$"{virtualDataSource.ConnectionStringManager.GetType()} cant support add read connection string");
}
/// <summary>
/// 动态添加读写分离链接字符串
/// </summary>
/// <typeparam name="TShardingDbContext"></typeparam>
/// <param name="configId"></param>
/// <param name="dataSourceName"></param>
/// <param name="connectionString"></param>
/// <param name="readNodeName"></param>
public static void DynamicAppendReadWriteConnectionString<TShardingDbContext>(string configId, string dataSourceName,
string connectionString, string readNodeName=null) where TShardingDbContext : DbContext, IShardingDbContext
{
var virtualDataSourceManager = ShardingContainer.GetRequiredVirtualDataSourceManager<TShardingDbContext>();
var virtualDataSource = virtualDataSourceManager.GetVirtualDataSource(configId);
DynamicAppendReadWriteConnectionString(virtualDataSource, dataSourceName, connectionString,readNodeName);
}
}
}
// using Microsoft.EntityFrameworkCore;
// using ShardingCore.Sharding.Abstractions;
// using System;
// using System.Collections.Generic;
// using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
// using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
// using ShardingCore.Exceptions;
// using ShardingCore.Sharding.ReadWriteConfigurations;
// using ShardingCore.Sharding.ReadWriteConfigurations.Abstractions;
//
// namespace ShardingCore.DynamicDataSources
// {
// [Obsolete("plz use DynamicShardingHelper")]
// public class DynamicDataSourceHelper
// {
// private DynamicDataSourceHelper()
// {
// throw new InvalidOperationException($"{nameof(DynamicDataSourceHelper)} create instance");
// }
//
// public static void DynamicAppendDataSource<TShardingDbContext>(IVirtualDataSource<TShardingDbContext> virtualDataSource,string dataSourceName, string connectionString) where TShardingDbContext : DbContext, IShardingDbContext
// {
// var defaultDataSourceInitializer = ShardingContainer.GetService<IDataSourceInitializer<TShardingDbContext>>();
// defaultDataSourceInitializer.InitConfigure(virtualDataSource,dataSourceName, connectionString, false);
// }
// public static void DynamicAppendDataSource<TShardingDbContext>(string configId,string dataSourceName, string connectionString) where TShardingDbContext : DbContext, IShardingDbContext
// {
// var defaultDataSourceInitializer = ShardingContainer.GetService<IDataSourceInitializer<TShardingDbContext>>();
// var virtualDataSourceManager = ShardingContainer.GetService<IVirtualDataSourceManager<TShardingDbContext>>();
//
// var virtualDataSource = virtualDataSourceManager.GetVirtualDataSource(configId);
// defaultDataSourceInitializer.InitConfigure(virtualDataSource, dataSourceName, connectionString, false);
// }
//
// public static bool DynamicAppendVirtualDataSource<TShardingDbContext>(
// IVirtualDataSourceConfigurationParams<TShardingDbContext> configurationParams)
// where TShardingDbContext : DbContext, IShardingDbContext
// {
// var virtualDataSourceManager = ShardingContainer.GetRequiredVirtualDataSourceManager<TShardingDbContext>();
// if (virtualDataSourceManager.AddVirtualDataSource(configurationParams))
// {
// virtualDataSourceManager.SetDefaultIfMultiConfiguration();
// var dataSourceInitializer = ShardingContainer.GetService<IDataSourceInitializer<TShardingDbContext>>();
// var virtualDataSource = virtualDataSourceManager.GetVirtualDataSource(configurationParams.ConfigId);
// foreach (var dataSource in virtualDataSource.GetDataSources())
// {
// var dataSourceName = dataSource.Key;
// var connectionString = dataSource.Value;
// dataSourceInitializer.InitConfigure(virtualDataSource, dataSourceName, connectionString, false);
// }
//
// return true;
// }
//
// return false;
// }
// /// <summary>
// /// 动态添加读写分离链接字符串
// /// </summary>
// /// <typeparam name="TShardingDbContext"></typeparam>
// /// <param name="virtualDataSource"></param>
// /// <param name="dataSourceName"></param>
// /// <param name="connectionString"></param>
// /// <param name="readNodeName"></param>
// /// <exception cref="ShardingCoreInvalidOperationException"></exception>
// public static void DynamicAppendReadWriteConnectionString<TShardingDbContext>(IVirtualDataSource<TShardingDbContext> virtualDataSource, string dataSourceName,
// string connectionString,string readNodeName = null) where TShardingDbContext : DbContext, IShardingDbContext
// {
// if (virtualDataSource.ConnectionStringManager is IReadWriteConnectionStringManager
// readWriteAppendConnectionString)
// {
// readWriteAppendConnectionString.AddReadConnectionString(dataSourceName, connectionString, readNodeName);
// return;
// }
//
// throw new ShardingCoreInvalidOperationException(
// $"{virtualDataSource.ConnectionStringManager.GetType()} cant support add read connection string");
// }
// /// <summary>
// /// 动态添加读写分离链接字符串
// /// </summary>
// /// <typeparam name="TShardingDbContext"></typeparam>
// /// <param name="configId"></param>
// /// <param name="dataSourceName"></param>
// /// <param name="connectionString"></param>
// /// <param name="readNodeName"></param>
// public static void DynamicAppendReadWriteConnectionString<TShardingDbContext>(string configId, string dataSourceName,
// string connectionString, string readNodeName=null) where TShardingDbContext : DbContext, IShardingDbContext
// {
// var virtualDataSourceManager = ShardingContainer.GetRequiredVirtualDataSourceManager<TShardingDbContext>();
// var virtualDataSource = virtualDataSourceManager.GetVirtualDataSource(configId);
// DynamicAppendReadWriteConnectionString(virtualDataSource, dataSourceName, connectionString,readNodeName);
// }
// }
// }

42
src/ShardingCore/DynamicDataSources/IDataSourceInitializer`1.cs
View File

@ -1,21 +1,21 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
using ShardingCore.Sharding.Abstractions;
namespace ShardingCore.DynamicDataSources
{
public interface IDataSourceInitializer<TShardingDbContext> where TShardingDbContext : DbContext, IShardingDbContext
{
/// <summary>
///
/// </summary>
/// <param name="virtualDataSource"></param>
/// <param name="dataSourceName"></param>
void InitConfigure(IVirtualDataSource<TShardingDbContext> virtualDataSource, string dataSourceName);
}
}
// using System;
// using System.Collections.Generic;
// using System.Linq;
// using System.Text;
// using System.Threading.Tasks;
// using Microsoft.EntityFrameworkCore;
// using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
// using ShardingCore.Sharding.Abstractions;
//
// namespace ShardingCore.DynamicDataSources
// {
// public interface IDataSourceInitializer<TShardingDbContext> where TShardingDbContext : DbContext, IShardingDbContext
// {
// /// <summary>
// ///
// /// </summary>
// /// <param name="virtualDataSource"></param>
// /// <param name="dataSourceName"></param>
// void InitConfigure(IVirtualDataSource<TShardingDbContext> virtualDataSource, string dataSourceName);
// }
// }

132
src/ShardingCore/Extensions/ShardingPageExtensions/ShardingPageExtension.cs
View File

@ -1,66 +1,66 @@
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using ShardingCore.Core.ShardingPage.Abstractions;
namespace ShardingCore.Extensions.ShardingPageExtensions
{
/*
* @Author: xjm
* @Description:
* @Date: 2021/9/3 10:36:51
* @Ver: 1.0
* @Email: 326308290@qq.com
*/
public static class ShardingPageExtension
{
public static async Task<ShardingPagedResult<T>> ToShardingPageAsync<T>(this IQueryable<T> source, int pageIndex, int pageSize)
{
//设置每次获取多少页
var take = pageSize <= 0 ? 1 : pageSize;
//设置当前页码最小1
var index = pageIndex <= 0 ? 1 : pageIndex;
//需要跳过多少页
var skip = (index - 1) * take;
var shardingPageManager = ShardingContainer.GetService<IShardingPageManager>();
using (shardingPageManager.CreateScope())
{
//获取每次总记录数
var count = await source.CountAsync();
if (count <= skip)
return new ShardingPagedResult<T>(new List<T>(0), count);
//获取剩余条数
var remainingCount = count - skip;
//当剩余条数小于take数就取remainingCount
var realTake = remainingCount < take ? remainingCount : take;
var data = await source.Skip(skip).Take(realTake).ToListAsync();
return new ShardingPagedResult<T>(data, count);
}
}
public static ShardingPagedResult<T> ToShardingPage<T>(this IQueryable<T> source, int pageIndex, int pageSize)
{
//设置每次获取多少页
var take = pageSize <= 0 ? 1 : pageSize;
//设置当前页码最小1
var index = pageIndex <= 0 ? 1 : pageIndex;
//需要跳过多少页
var skip = (index - 1) * take;
var shardingPageManager = ShardingContainer.GetService<IShardingPageManager>();
using (shardingPageManager.CreateScope())
{
//获取每次总记录数
var count = source.Count();
if (count <= skip)
return new ShardingPagedResult<T>(new List<T>(0), count);
//获取剩余条数
var remainingCount = count - skip;
//当剩余条数小于take数就取remainingCount
var realTake = remainingCount < take ? remainingCount : take;
var data = source.Skip(skip).Take(realTake).ToList();
return new ShardingPagedResult<T>(data, count);
}
}
}
}
// using System.Collections.Generic;
// using System.Linq;
// using System.Threading.Tasks;
// using Microsoft.EntityFrameworkCore;
// using ShardingCore.Core.ShardingPage.Abstractions;
//
// namespace ShardingCore.Extensions.ShardingPageExtensions
// {
// /*
// * @Author: xjm
// * @Description:
// * @Date: 2021/9/3 10:36:51
// * @Ver: 1.0
// * @Email: 326308290@qq.com
// */
// public static class ShardingPageExtension
// {
// public static async Task<ShardingPagedResult<T>> ToShardingPageAsync<T>(this IQueryable<T> source, int pageIndex, int pageSize)
// {
// //设置每次获取多少页
// var take = pageSize <= 0 ? 1 : pageSize;
// //设置当前页码最小1
// var index = pageIndex <= 0 ? 1 : pageIndex;
// //需要跳过多少页
// var skip = (index - 1) * take;
// var shardingPageManager = ShardingContainer.GetService<IShardingPageManager>();
// using (shardingPageManager.CreateScope())
// {
// //获取每次总记录数
// var count = await source.CountAsync();
// if (count <= skip)
// return new ShardingPagedResult<T>(new List<T>(0), count);
// //获取剩余条数
// var remainingCount = count - skip;
// //当剩余条数小于take数就取remainingCount
// var realTake = remainingCount < take ? remainingCount : take;
// var data = await source.Skip(skip).Take(realTake).ToListAsync();
// return new ShardingPagedResult<T>(data, count);
// }
// }
// public static ShardingPagedResult<T> ToShardingPage<T>(this IQueryable<T> source, int pageIndex, int pageSize)
// {
// //设置每次获取多少页
// var take = pageSize <= 0 ? 1 : pageSize;
// //设置当前页码最小1
// var index = pageIndex <= 0 ? 1 : pageIndex;
// //需要跳过多少页
// var skip = (index - 1) * take;
//
// var shardingPageManager = ShardingContainer.GetService<IShardingPageManager>();
// using (shardingPageManager.CreateScope())
// {
// //获取每次总记录数
// var count = source.Count();
// if (count <= skip)
// return new ShardingPagedResult<T>(new List<T>(0), count);
// //获取剩余条数
// var remainingCount = count - skip;
// //当剩余条数小于take数就取remainingCount
// var realTake = remainingCount < take ? remainingCount : take;
// var data = source.Skip(skip).Take(realTake).ToList();
// return new ShardingPagedResult<T>(data, count);
// }
// }
// }
// }

246
src/ShardingCore/Helpers/DynamicShardingHelper.cs
View File

@ -1,123 +1,123 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.PhysicDataSources;
using ShardingCore.DynamicDataSources;
using ShardingCore.Exceptions;
using ShardingCore.Sharding.Abstractions;
using ShardingCore.Sharding.ReadWriteConfigurations.Abstractions;
namespace ShardingCore.Helpers
{
public class DynamicShardingHelper
{
private DynamicShardingHelper()
{
throw new InvalidOperationException($"{nameof(DynamicShardingHelper)} create instance");
}
/// <summary>
/// 动态添加虚拟数据源配置
/// </summary>
/// <typeparam name="TShardingDbContext"></typeparam>
/// <param name="configurationParams"></param>
/// <returns></returns>
public static bool DynamicAppendVirtualDataSourceConfig<TShardingDbContext>(
IVirtualDataSourceConfigurationParams<TShardingDbContext> configurationParams)
where TShardingDbContext : DbContext, IShardingDbContext
{
var virtualDataSourceManager = ShardingContainer.GetRequiredVirtualDataSourceManager<TShardingDbContext>();
if (virtualDataSourceManager.AddVirtualDataSource(configurationParams))
{
virtualDataSourceManager.SetDefaultIfMultiConfiguration();
var dataSourceInitializer = ShardingContainer.GetService<IDataSourceInitializer<TShardingDbContext>>();
var virtualDataSource = virtualDataSourceManager.GetVirtualDataSource(configurationParams.ConfigId);
foreach (var dataSource in virtualDataSource.GetDataSources())
{
var dataSourceName = dataSource.Key;
var connectionString = dataSource.Value;
dataSourceInitializer.InitConfigure(virtualDataSource, dataSourceName, connectionString, false);
}
return true;
}
return false;
}
/// <summary>
/// 动态添加数据源
/// </summary>
/// <typeparam name="TShardingDbContext"></typeparam>
/// <param name="virtualDataSource"></param>
/// <param name="dataSourceName"></param>
/// <param name="connectionString"></param>
/// <param name="createDatabase"></param>
/// <param name="createTable"></param>
public static void DynamicAppendDataSource<TShardingDbContext>(IVirtualDataSource<TShardingDbContext> virtualDataSource, string dataSourceName, string connectionString,bool? createDatabase=null,bool? createTable=null) where TShardingDbContext : DbContext, IShardingDbContext
{
var defaultDataSourceInitializer = ShardingContainer.GetService<IDataSourceInitializer<TShardingDbContext>>();
virtualDataSource.AddPhysicDataSource(new DefaultPhysicDataSource(dataSourceName, connectionString, false));
defaultDataSourceInitializer.InitConfigure(virtualDataSource, dataSourceName, connectionString, false,createDatabase,createTable);
}
/// <summary>
/// 动态添加数据源
/// </summary>
/// <typeparam name="TShardingDbContext"></typeparam>
/// <param name="configId"></param>
/// <param name="dataSourceName"></param>
/// <param name="connectionString"></param>
/// <param name="createDatabase"></param>
/// <param name="createTable"></param>
public static void DynamicAppendDataSource<TShardingDbContext>(string configId, string dataSourceName, string connectionString, bool? createDatabase = null, bool? createTable = null) where TShardingDbContext : DbContext, IShardingDbContext
{
var defaultDataSourceInitializer = ShardingContainer.GetService<IDataSourceInitializer<TShardingDbContext>>();
var virtualDataSourceManager = ShardingContainer.GetService<IVirtualDataSourceManager<TShardingDbContext>>();
var virtualDataSource = virtualDataSourceManager.GetVirtualDataSource(configId);
virtualDataSource.AddPhysicDataSource(new DefaultPhysicDataSource(dataSourceName, connectionString, false));
defaultDataSourceInitializer.InitConfigure(virtualDataSource, dataSourceName, connectionString, false, createDatabase, createTable);
}
/// <summary>
/// 动态添加读写分离链接字符串
/// </summary>
/// <typeparam name="TShardingDbContext"></typeparam>
/// <param name="virtualDataSource"></param>
/// <param name="dataSourceName"></param>
/// <param name="connectionString"></param>
/// <param name="readNodeName"></param>
/// <exception cref="ShardingCoreInvalidOperationException"></exception>
public static void DynamicAppendReadWriteConnectionString<TShardingDbContext>(IVirtualDataSource<TShardingDbContext> virtualDataSource, string dataSourceName,
string connectionString, string readNodeName=null) where TShardingDbContext : DbContext, IShardingDbContext
{
if (virtualDataSource.ConnectionStringManager is IReadWriteConnectionStringManager
readWriteAppendConnectionString)
{
readWriteAppendConnectionString.AddReadConnectionString(dataSourceName, connectionString, readNodeName);
return;
}
throw new ShardingCoreInvalidOperationException(
$"{virtualDataSource.ConnectionStringManager.GetType()} cant support add read connection string");
}
/// <summary>
/// 动态添加读写分离链接字符串
/// </summary>
/// <typeparam name="TShardingDbContext"></typeparam>
/// <param name="configId"></param>
/// <param name="dataSourceName"></param>
/// <param name="connectionString"></param>
/// <param name="readNodeName"></param>
public static void DynamicAppendReadWriteConnectionString<TShardingDbContext>(string configId, string dataSourceName,
string connectionString, string readNodeName = null) where TShardingDbContext : DbContext, IShardingDbContext
{
var virtualDataSourceManager = ShardingContainer.GetRequiredVirtualDataSourceManager<TShardingDbContext>();
var virtualDataSource = virtualDataSourceManager.GetVirtualDataSource(configId);
DynamicAppendReadWriteConnectionString(virtualDataSource, dataSourceName, connectionString, readNodeName);
}
}
}
// using System;
// using System.Collections.Generic;
// using System.Linq;
// using System.Text;
// using System.Threading.Tasks;
// using Microsoft.EntityFrameworkCore;
// using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
// using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
// using ShardingCore.Core.VirtualDatabase.VirtualDataSources.PhysicDataSources;
// using ShardingCore.DynamicDataSources;
// using ShardingCore.Exceptions;
// using ShardingCore.Sharding.Abstractions;
// using ShardingCore.Sharding.ReadWriteConfigurations.Abstractions;
//
// namespace ShardingCore.Helpers
// {
// public class DynamicShardingHelper
// {
// private DynamicShardingHelper()
// {
// throw new InvalidOperationException($"{nameof(DynamicShardingHelper)} create instance");
// }
// /// <summary>
// /// 动态添加虚拟数据源配置
// /// </summary>
// /// <typeparam name="TShardingDbContext"></typeparam>
// /// <param name="configurationParams"></param>
// /// <returns></returns>
// public static bool DynamicAppendVirtualDataSourceConfig<TShardingDbContext>(
// IVirtualDataSourceConfigurationParams<TShardingDbContext> configurationParams)
// where TShardingDbContext : DbContext, IShardingDbContext
// {
// var virtualDataSourceManager = ShardingContainer.GetRequiredVirtualDataSourceManager<TShardingDbContext>();
// if (virtualDataSourceManager.AddVirtualDataSource(configurationParams))
// {
// virtualDataSourceManager.SetDefaultIfMultiConfiguration();
// var dataSourceInitializer = ShardingContainer.GetService<IDataSourceInitializer<TShardingDbContext>>();
// var virtualDataSource = virtualDataSourceManager.GetVirtualDataSource(configurationParams.ConfigId);
// foreach (var dataSource in virtualDataSource.GetDataSources())
// {
// var dataSourceName = dataSource.Key;
// var connectionString = dataSource.Value;
// dataSourceInitializer.InitConfigure(virtualDataSource, dataSourceName, connectionString, false);
// }
//
// return true;
// }
//
// return false;
// }
// /// <summary>
// /// 动态添加数据源
// /// </summary>
// /// <typeparam name="TShardingDbContext"></typeparam>
// /// <param name="virtualDataSource"></param>
// /// <param name="dataSourceName"></param>
// /// <param name="connectionString"></param>
// /// <param name="createDatabase"></param>
// /// <param name="createTable"></param>
// public static void DynamicAppendDataSource<TShardingDbContext>(IVirtualDataSource<TShardingDbContext> virtualDataSource, string dataSourceName, string connectionString,bool? createDatabase=null,bool? createTable=null) where TShardingDbContext : DbContext, IShardingDbContext
// {
// var defaultDataSourceInitializer = ShardingContainer.GetService<IDataSourceInitializer<TShardingDbContext>>();
// virtualDataSource.AddPhysicDataSource(new DefaultPhysicDataSource(dataSourceName, connectionString, false));
// defaultDataSourceInitializer.InitConfigure(virtualDataSource, dataSourceName, connectionString, false,createDatabase,createTable);
// }
// /// <summary>
// /// 动态添加数据源
// /// </summary>
// /// <typeparam name="TShardingDbContext"></typeparam>
// /// <param name="configId"></param>
// /// <param name="dataSourceName"></param>
// /// <param name="connectionString"></param>
// /// <param name="createDatabase"></param>
// /// <param name="createTable"></param>
// public static void DynamicAppendDataSource<TShardingDbContext>(string configId, string dataSourceName, string connectionString, bool? createDatabase = null, bool? createTable = null) where TShardingDbContext : DbContext, IShardingDbContext
// {
// var defaultDataSourceInitializer = ShardingContainer.GetService<IDataSourceInitializer<TShardingDbContext>>();
// var virtualDataSourceManager = ShardingContainer.GetService<IVirtualDataSourceManager<TShardingDbContext>>();
//
// var virtualDataSource = virtualDataSourceManager.GetVirtualDataSource(configId);
// virtualDataSource.AddPhysicDataSource(new DefaultPhysicDataSource(dataSourceName, connectionString, false));
// defaultDataSourceInitializer.InitConfigure(virtualDataSource, dataSourceName, connectionString, false, createDatabase, createTable);
// }
//
// /// <summary>
// /// 动态添加读写分离链接字符串
// /// </summary>
// /// <typeparam name="TShardingDbContext"></typeparam>
// /// <param name="virtualDataSource"></param>
// /// <param name="dataSourceName"></param>
// /// <param name="connectionString"></param>
// /// <param name="readNodeName"></param>
// /// <exception cref="ShardingCoreInvalidOperationException"></exception>
// public static void DynamicAppendReadWriteConnectionString<TShardingDbContext>(IVirtualDataSource<TShardingDbContext> virtualDataSource, string dataSourceName,
// string connectionString, string readNodeName=null) where TShardingDbContext : DbContext, IShardingDbContext
// {
// if (virtualDataSource.ConnectionStringManager is IReadWriteConnectionStringManager
// readWriteAppendConnectionString)
// {
// readWriteAppendConnectionString.AddReadConnectionString(dataSourceName, connectionString, readNodeName);
// return;
// }
//
// throw new ShardingCoreInvalidOperationException(
// $"{virtualDataSource.ConnectionStringManager.GetType()} cant support add read connection string");
// }
// /// <summary>
// /// 动态添加读写分离链接字符串
// /// </summary>
// /// <typeparam name="TShardingDbContext"></typeparam>
// /// <param name="configId"></param>
// /// <param name="dataSourceName"></param>
// /// <param name="connectionString"></param>
// /// <param name="readNodeName"></param>
// public static void DynamicAppendReadWriteConnectionString<TShardingDbContext>(string configId, string dataSourceName,
// string connectionString, string readNodeName = null) where TShardingDbContext : DbContext, IShardingDbContext
// {
// var virtualDataSourceManager = ShardingContainer.GetRequiredVirtualDataSourceManager<TShardingDbContext>();
// var virtualDataSource = virtualDataSourceManager.GetVirtualDataSource(configId);
// DynamicAppendReadWriteConnectionString(virtualDataSource, dataSourceName, connectionString, readNodeName);
// }
// }
// }

108
src/ShardingCore/VirtualRoutes/Abstractions/AbstractShardingAutoCreateOperatorVirtualTableRoute.cs
View File

@ -7,11 +7,7 @@ using System.Text;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using ShardingCore.Core.EntityMetadatas;
using ShardingCore.Core.PhysicTables;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources.Abstractions;
using ShardingCore.Core.VirtualDatabase.VirtualTables;
using ShardingCore.Core.VirtualRoutes;
using ShardingCore.Core.VirtualRoutes.TableRoutes.Abstractions;
using ShardingCore.Extensions;
using ShardingCore.Jobs.Abstaractions;
@ -60,58 +56,58 @@ namespace ShardingCore.VirtualRoutes.Abstractions
protected abstract string ConvertNowToTail(DateTime now);
public virtual Task ExecuteAsync()
{
var virtualTableManager = (IVirtualTableManager)ShardingContainer.GetService(typeof(IVirtualTableManager<>).GetGenericType0(EntityMetadata.ShardingDbContextType));
var virtualTable = virtualTableManager.GetVirtualTable(typeof(TEntity));
_logger.LogDebug($"get {typeof(TEntity).Name}'s virtualTable ");
if (virtualTable == null)
{
_logger.LogDebug($" {typeof(TEntity).Name}'s virtualTable is null");
return Task.CompletedTask;
}
var entityMetadataManager = (IEntityMetadataManager)ShardingContainer.GetService(typeof(IEntityMetadataManager<>).GetGenericType0(EntityMetadata.ShardingDbContextType));
var tableCreator = (IShardingTableCreator)ShardingContainer.GetService(typeof(IShardingTableCreator<>).GetGenericType0(EntityMetadata.ShardingDbContextType));
var virtualDataSourceManager = (IVirtualDataSourceManager)ShardingContainer.GetService(typeof(IVirtualDataSourceManager<>).GetGenericType0(EntityMetadata.ShardingDbContextType));
var allVirtualDataSources = virtualDataSourceManager.GetAllVirtualDataSources();
var now = DateTime.Now.AddMinutes(IncrementMinutes);
var tail = ConvertNowToTail(now);
//必须先执行AddPhysicTable在进行CreateTable
virtualTableManager.AddPhysicTable(virtualTable, new DefaultPhysicTable(virtualTable, tail));
foreach (var virtualDataSource in allVirtualDataSources)
{
ISet<string> dataSources = new HashSet<string>();
if (entityMetadataManager.IsShardingDataSource(typeof(TEntity)))
{
var virtualDataSourceRoute = virtualDataSource.GetRoute(typeof(TEntity));
foreach (var dataSourceName in virtualDataSourceRoute.GetAllDataSourceNames())
{
dataSources.Add(dataSourceName);
}
}
else
{
dataSources.Add(virtualDataSource.DefaultDataSourceName);
}
_logger.LogInformation($"auto create table data source names:[{string.Join(",", dataSources)}]");
using (virtualDataSourceManager.CreateScope(virtualDataSource.ConfigId))
{
foreach (var dataSource in dataSources)
{
try
{
_logger.LogInformation($"begin table tail:[{tail}],entity:[{typeof(TEntity).Name}]");
tableCreator.CreateTable(dataSource, typeof(TEntity), tail);
_logger.LogInformation($"succeed table tail:[{tail}],entity:[{typeof(TEntity).Name}]");
}
catch (Exception e)
{
//ignore
_logger.LogInformation($"warning table tail:[{tail}],entity:[{typeof(TEntity).Name}]");
if (DoLogError)
_logger.LogError(e, $"{dataSource} {typeof(TEntity).Name}'s create table error ");
}
}
}
}
// var virtualTableManager = (IVirtualTableManager)ShardingContainer.GetService(typeof(IVirtualTableManager<>).GetGenericType0(EntityMetadata.ShardingDbContextType));
// var virtualTable = virtualTableManager.GetVirtualTable(typeof(TEntity));
// _logger.LogDebug($"get {typeof(TEntity).Name}'s virtualTable ");
// if (virtualTable == null)
// {
// _logger.LogDebug($" {typeof(TEntity).Name}'s virtualTable is null");
// return Task.CompletedTask;
// }
// var entityMetadataManager = (IEntityMetadataManager)ShardingContainer.GetService(typeof(IEntityMetadataManager<>).GetGenericType0(EntityMetadata.ShardingDbContextType));
// var tableCreator = (IShardingTableCreator)ShardingContainer.GetService(typeof(IShardingTableCreator<>).GetGenericType0(EntityMetadata.ShardingDbContextType));
// var virtualDataSourceManager = (IVirtualDataSourceManager)ShardingContainer.GetService(typeof(IVirtualDataSourceManager<>).GetGenericType0(EntityMetadata.ShardingDbContextType));
// var allVirtualDataSources = virtualDataSourceManager.GetAllVirtualDataSources();
// var now = DateTime.Now.AddMinutes(IncrementMinutes);
// var tail = ConvertNowToTail(now);
// //必须先执行AddPhysicTable在进行CreateTable
// virtualTableManager.AddPhysicTable(virtualTable, new DefaultPhysicTable(virtualTable, tail));
// foreach (var virtualDataSource in allVirtualDataSources)
// {
// ISet<string> dataSources = new HashSet<string>();
// if (entityMetadataManager.IsShardingDataSource(typeof(TEntity)))
// {
// var virtualDataSourceRoute = virtualDataSource.GetRoute(typeof(TEntity));
// foreach (var dataSourceName in virtualDataSourceRoute.GetAllDataSourceNames())
// {
// dataSources.Add(dataSourceName);
// }
// }
// else
// {
// dataSources.Add(virtualDataSource.DefaultDataSourceName);
// }
// _logger.LogInformation($"auto create table data source names:[{string.Join(",", dataSources)}]");
// using (virtualDataSourceManager.CreateScope(virtualDataSource.ConfigId))
// {
// foreach (var dataSource in dataSources)
// {
// try
// {
// _logger.LogInformation($"begin table tail:[{tail}],entity:[{typeof(TEntity).Name}]");
// tableCreator.CreateTable(dataSource, typeof(TEntity), tail);
// _logger.LogInformation($"succeed table tail:[{tail}],entity:[{typeof(TEntity).Name}]");
// }
// catch (Exception e)
// {
// //ignore
// _logger.LogInformation($"warning table tail:[{tail}],entity:[{typeof(TEntity).Name}]");
// if (DoLogError)
// _logger.LogError(e, $"{dataSource} {typeof(TEntity).Name}'s create table error ");
// }
// }
// }
// }
return Task.CompletedTask;
}

3
src/ShardingCore/VirtualRoutes/Days/AbstractSimpleShardingDayKeyDateTimeVirtualTableRoute.cs
View File

@ -2,9 +2,6 @@ using ShardingCore.Core.VirtualRoutes;
using ShardingCore.VirtualRoutes.Abstractions;
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using ShardingCore.Core.PhysicTables;
using ShardingCore.Core.VirtualTables;
namespace ShardingCore.VirtualRoutes.Days
{

7
src/ShardingCore/VirtualRoutes/Weeks/AbstractSimpleShardingWeekKeyLongVirtualTableRoute.cs
View File

@ -1,15 +1,8 @@
using ShardingCore.Core.EntityMetadatas;
using ShardingCore.Core.PhysicTables;
using ShardingCore.Core.VirtualDatabase.VirtualDataSources;
using ShardingCore.Core.VirtualDatabase.VirtualTables;
using ShardingCore.Core.VirtualRoutes;
using ShardingCore.Extensions;
using ShardingCore.Helpers;
using ShardingCore.TableCreator;
using ShardingCore.VirtualRoutes.Abstractions;
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace ShardingCore.VirtualRoutes.Weeks
{