protected AbstractCacheManager(SmartSqlConfig smartSqlConfig)
{
SmartSqlConfig = smartSqlConfig;
Logger = SmartSqlConfig.LoggerFactory.CreateLogger <AbstractCacheManager>();
InitCacheMapped();
Timer = new Timer(FlushOnInterval, null, DueTime, PeriodTime);
}
public OptionConfigBuilder(SmartSqlConfigOptions configOptions, ILoggerFactory loggerFactory = null)
{
loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
Logger = loggerFactory.CreateLogger <XmlConfigBuilder>();
_configOptions = configOptions;
SmartSqlConfig = new SmartSqlConfig();
}
public PrepareStatementMiddleware(SmartSqlConfig smartSqlConfig)
{
_logger = smartSqlConfig.LoggerFactory.CreateLogger <PrepareStatementMiddleware>();
_sqlParamAnalyzer = smartSqlConfig.SqlParamAnalyzer;
_dbProviderFactory = smartSqlConfig.Database.DbProvider.Factory;
_typeHandlerFactory = smartSqlConfig.TypeHandlerFactory;
}
public CacheManager(SmartSqlConfig smartSqlConfig)
{
_smartSqlConfig = smartSqlConfig;
_logger = _smartSqlConfig.LoggerFactory.CreateLogger <CacheManager>();
InitCacheMapped();
_sessionMappedExecutionQueue = new ConcurrentDictionary <Guid, ConcurrentQueue <ExecutionContext> >();
_timer = new Timer(FlushOnInterval, null, _defaultDueTime, _defaultPeriodTime);
}
public SqlMapBuilder(XmlDocument xmlSqlMap, SmartSqlConfig smartSqlConfig)
{
XmlSqlMap = xmlSqlMap;
SmartSqlConfig = smartSqlConfig;
XmlNsManager = new XmlNamespaceManager(xmlSqlMap.NameTable);
XmlNsManager.AddNamespace(SQLMAP_PREFIX, SMART_SQL_MAP_NAMESPACE);
XmlSqlMapRoot = xmlSqlMap.SelectSingleNode($"/{SQLMAP_PREFIX}:SmartSqlMap", XmlNsManager);
}
/// <summary>
/// SmartSqlMapConfig 配置方式构建
/// </summary>
/// <param name="smartSqlConfig"></param>
/// <returns></returns>
public SmartSqlBuilder UseNativeConfig(SmartSqlConfig smartSqlConfig)
{
if (smartSqlConfig == null)
{
throw new ArgumentNullException(nameof(smartSqlConfig));
}
ConfigBuilder = new NativeConfigBuilder(smartSqlConfig);
return(this);
}
public RootConfigBuilder(IEnumerable <KeyValuePair <string, string> > importProperties)
{
SmartSqlConfig = new SmartSqlConfig();
if (importProperties != null)
{
SmartSqlConfig.Properties.Import(importProperties);
}
Initialized = true;
}
public CacheManager(SmartSqlConfig smartSqlConfig)
{
_smartSqlConfig = smartSqlConfig;
_logger = _smartSqlConfig.LoggerFactory.CreateLogger <CacheManager>();
smartSqlConfig.InvokeSucceedListener.InvokeSucceeded += (sender, args) =>
{
HandleCache(args.ExecutionContext);
};
InitCacheMapped();
_timer = new Timer(FlushOnInterval, null, _defaultDueTime, _defaultPeriodTime);
}
public XmlConfigBuilder(ResourceType resourceType, string resourcePath, ILoggerFactory loggerFactory = null)
{
_resourceType = resourceType;
_resourcePath = resourcePath;
_loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
Logger = _loggerFactory.CreateLogger <XmlConfigBuilder>();
XmlConfig = ResourceUtil.LoadAsXml(resourceType, resourcePath);
XmlNsManager = new XmlNamespaceManager(XmlConfig.NameTable);
XmlNsManager.AddNamespace(CONFIG_PREFIX, SMART_SQL_CONFIG_NAMESPACE);
XmlConfigRoot = XmlConfig.SelectSingleNode($"/{CONFIG_PREFIX}:SmartSqlMapConfig", XmlNsManager);
SmartSqlConfig = new SmartSqlConfig();
}
public Type Build(Type interfaceType, SmartSqlConfig smartSqlConfig, string scope = "")
{
string implName = $"{interfaceType.Name.TrimStart('I')}_Impl_{Guid.NewGuid():N}";
var typeBuilder = _moduleBuilder.DefineType(implName, TypeAttributes.Public);
typeBuilder.AddInterfaceImplementation(interfaceType);
typeBuilder.AddInterfaceImplementation(typeof(IRepositoryProxy));
var sqlMapperField = typeBuilder.DefineField("sqlMapper", ISqlMapperType.Type, FieldAttributes.Family);
var scopeField = typeBuilder.DefineField("scope", CommonType.String, FieldAttributes.Family);
scope = PreScope(interfaceType, scope);
var sqlMap = GetOrAddSqlMap(smartSqlConfig, interfaceType, scope);
EmitBuildCtor(scope, typeBuilder, sqlMapperField, scopeField);
var interfaceMethods = new List <MethodInfo>();
var currentMethodInfos = interfaceType.GetMethods(BindingFlags.Instance | BindingFlags.Public);
interfaceMethods.AddRange(currentMethodInfos);
var currentIIs = interfaceType.GetInterfaces();
foreach (var currentII in currentIIs)
{
var currentIIMethods = currentII.GetMethods(BindingFlags.Instance | BindingFlags.Public);
interfaceMethods.AddRange(currentIIMethods);
}
foreach (var methodInfo in interfaceMethods)
{
if (methodInfo.ReturnType == ISqlMapperType.Type)
{
BuildInternalGet(typeBuilder, methodInfo, sqlMapperField);
}
else
{
BuildMethod(interfaceType, typeBuilder, methodInfo, sqlMapperField, smartSqlConfig, sqlMap);
}
}
if (sqlMap.Path == interfaceType.AssemblyQualifiedName)
{
if (sqlMap.Caches?.Count > 0)
{
smartSqlConfig.CacheManager.Reset();
}
}
return(typeBuilder.CreateTypeInfo());
}
public CUDSqlGenerator(SmartSqlConfig config)
{
_generatorFuncList = new Dictionary <string, Func <GeneratorParams, Statement> >
{
{ CUDStatementName.GET_BY_ID, BuildGetEntity },
{ CUDStatementName.INSERT, BuildInsert },
{ CUDStatementName.INSERT_RETURN_ID, BuildInsertReturnId },
{ CUDStatementName.UPDATE, BuildUpdate },
{ CUDStatementName.DELETE_BY_ID, BuildDeleteById },
{ CUDStatementName.DELETE_ALL, BuildDeleteAll },
{ CUDStatementName.DELETE_MANY, BuildDeleteMany },
};
_provider = config.Database.DbProvider;
_analyzer = new StatementAnalyzer();
}
public virtual SmartSqlConfig Build(IEnumerable <KeyValuePair <string, string> > importProperties)
{
SmartSqlConfig = new SmartSqlConfig();
OnBeforeBuild();
ImportProperties(importProperties);
BuildSettings();
BuildProperties();
BuildIdGenerators();
BuildDatabase();
BuildTypeHandlers();
BuildTagBuilders();
BuildSqlMaps();
EnsureDependency();
OnAfterBuild();
return(SmartSqlConfig);
}
/// <summary>
/// 数据源方式构建
/// </summary>
/// <param name="writeDataSource"></param>
/// <returns></returns>
public SmartSqlBuilder UseDataSource(WriteDataSource writeDataSource)
{
if (writeDataSource == null)
{
throw new ArgumentNullException(nameof(writeDataSource));
}
var smartSqlConfig = new SmartSqlConfig
{
Database = new Database
{
DbProvider = writeDataSource.DbProvider,
Write = writeDataSource
}
};
return(UseNativeConfig(smartSqlConfig));
}
private SqlMap GetOrAddSqlMap(SmartSqlConfig smartSqlConfig, Type interfaceType, string scope)
{
if (!smartSqlConfig.SqlMaps.TryGetValue(scope, out var sqlMap))
{
sqlMap = new SqlMap
{
Path = interfaceType.AssemblyQualifiedName,
Scope = scope,
SmartSqlConfig = smartSqlConfig,
Statements = new Dictionary <string, Statement>(),
Caches = new Dictionary <string, Configuration.Cache>(),
MultipleResultMaps = new Dictionary <string, MultipleResultMap>(),
ParameterMaps = new Dictionary <string, ParameterMap>(),
ResultMaps = new Dictionary <string, ResultMap>()
};
smartSqlConfig.SqlMaps.Add(scope, sqlMap);
}
BuildCache(sqlMap, interfaceType);
return(sqlMap);
}
public NativeConfigBuilder(SmartSqlConfig smartSqlConfig)
{
SmartSqlConfig = smartSqlConfig;
}
public IsNotEmptyTest(SmartSqlFixture smartSqlFixture)
{
SmartSqlConfig = smartSqlFixture.SqlMapper.SmartSqlConfig;
}
public IsGreaterThanTest(SmartSqlFixture smartSqlFixture)
{
SmartSqlConfig = smartSqlFixture.SqlMapper.SmartSqlConfig;
}
public ResultHandlerMiddleware(SmartSqlConfig smartSqlConfig)
{
_deserializerFactory = smartSqlConfig.DeserializerFactory;
}
public InitializerMiddleware(SmartSqlConfig smartSqlConfig)
{
_smartSqlConfig = smartSqlConfig;
}
public NowTest(SmartSqlFixture smartSqlFixture)
{
SmartSqlConfig = smartSqlFixture.SqlMapper.SmartSqlConfig;
}
public SqlMapper(SmartSqlConfig smartSqlConfig)
{
_logger = smartSqlConfig.LoggerFactory.CreateLogger <SqlMapper>();
SmartSqlConfig = smartSqlConfig;
SessionStore = smartSqlConfig.SessionStore;
}
public SqlMapper(SmartSqlConfig smartSqlConfig)
{
SmartSqlConfig = smartSqlConfig;
SessionStore = smartSqlConfig.SessionStore;
}
public DataSourceFilterMiddleware(SmartSqlConfig smartSqlConfig)
{
_dataSourceFilter = smartSqlConfig.DataSourceFilter;
}
public CachingMiddleware(SmartSqlConfig smartSqlConfig)
{
_cacheManager = smartSqlConfig.CacheManager;
}
public override void SetupSmartSql(SmartSqlBuilder smartSqlBuilder)
{
_smartSqlConfig = smartSqlBuilder.SmartSqlConfig;
}
public DynamicTest(SmartSqlFixture smartSqlFixture)
{
SmartSqlConfig = smartSqlFixture.SqlMapper.SmartSqlConfig;
}
public DefaultDbSession(SmartSqlConfig smartSqlConfig)
{
Id = Guid.NewGuid();
_logger = smartSqlConfig.LoggerFactory.CreateLogger <DefaultDbSession>();
SmartSqlConfig = smartSqlConfig;
}
public CommandExecuterMiddleware(SmartSqlConfig smartSqlConfig)
{
_commandExecuter = new CommandExecuter(smartSqlConfig.LoggerFactory.CreateLogger <CommandExecuter>());
}
private StatementAttribute PreStatement(Type interfaceType, string scope, MethodInfo methodInfo, Type returnType, bool isTaskReturnType, SmartSqlConfig smartSqlConfig)
{
returnType = isTaskReturnType ? returnType.GetGenericArguments().FirstOrDefault() : returnType;
var statementAttr = methodInfo.GetCustomAttribute <StatementAttribute>();
var methodName = _sqlIdNamingConvert == null ? methodInfo.Name : _sqlIdNamingConvert.Invoke(interfaceType, methodInfo);
if (isTaskReturnType && methodInfo.Name.EndsWith("Async") && _sqlIdNamingConvert == null)
{
methodName = methodName.Substring(0, methodName.Length - 5);
}
if (statementAttr != null)
{
statementAttr.Id = !String.IsNullOrEmpty(statementAttr.Id) ? statementAttr.Id : methodName;
statementAttr.Scope = !String.IsNullOrEmpty(statementAttr.Scope) ? statementAttr.Scope : scope;
}
else
{
statementAttr = new StatementAttribute
{
Scope = scope,
Id = methodName
};
}
if (returnType == typeof(DataTable))
{
statementAttr.Execute = ExecuteBehavior.GetDataTable;
return(statementAttr);
}
if (returnType == typeof(DataSet))
{
statementAttr.Execute = ExecuteBehavior.GetDataSet;
return(statementAttr);
}
if (statementAttr.Execute == ExecuteBehavior.Auto)
{
Configuration.StatementType statementType = Configuration.StatementType.Unknown;
if (String.IsNullOrEmpty(statementAttr.Sql))
{
var sqlStatement = smartSqlConfig.GetSqlMap(statementAttr.Scope).GetStatement($"{statementAttr.Scope}.{statementAttr.Id}");
statementType = sqlStatement.StatementType;
}
else
{
statementType = _statementAnalyzer.Analyse(statementAttr.Sql);
}
if (CommonType.IsValueTuple(returnType))
{
statementAttr.Execute = ExecuteBehavior.QuerySingle;
}
else if (returnType == CommonType.Int32 || returnType == CommonType.Void || returnType == null)
{
statementAttr.Execute = ExecuteBehavior.Execute;
if (returnType == CommonType.Int32)
{
if (statementType.HasFlag(Configuration.StatementType.Select))
{
statementAttr.Execute = ExecuteBehavior.ExecuteScalar;
}
}
}
else if (returnType.IsValueType || returnType == CommonType.String)
{
statementAttr.Execute = ExecuteBehavior.ExecuteScalar;
if (!statementType.HasFlag(Configuration.StatementType.Select))
{
statementAttr.Execute = ExecuteBehavior.Execute;
}
}
else
{
var isQueryEnumerable = typeof(IEnumerable).IsAssignableFrom(returnType);
statementAttr.Execute = isQueryEnumerable ? ExecuteBehavior.Query : ExecuteBehavior.QuerySingle;
}
}
return(statementAttr);
}
private void BuildMethod(Type interfaceType, TypeBuilder typeBuilder, MethodInfo methodInfo, FieldBuilder sqlMapperField, SmartSqlConfig smartSqlConfig, string scope)
{
var methodParams = methodInfo.GetParameters();
var paramTypes = methodParams.Select(m => m.ParameterType).ToArray();
if (paramTypes.Any(p => p.IsGenericParameter))
{
_logger.LogError("SmartSql.DyRepository method parameters do not support generic parameters for the time being!");
throw new SmartSqlException("SmartSql.DyRepository method parameters do not support generic parameters for the time being!");
}
var returnType = methodInfo.ReturnType;
var implMethod = typeBuilder.DefineMethod(methodInfo.Name
, MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final
, returnType, paramTypes);
var isTaskReturnType = CommonType.Task.IsAssignableFrom(returnType);
if (methodInfo.IsGenericMethod)
{
var genericArgs = methodInfo.GetGenericArguments();
var gArgNames = genericArgs.Select(gArg => gArg.Name).ToArray();
var defineGenericArgs = implMethod.DefineGenericParameters(gArgNames);
for (int i = 0; i < gArgNames.Length; i++)
{
var genericArg = genericArgs[i];
var defineGenericArg = defineGenericArgs[i];
defineGenericArg.SetGenericParameterAttributes(genericArg.GenericParameterAttributes);
}
}
StatementAttribute statementAttr = PreStatement(interfaceType, scope, methodInfo, returnType, isTaskReturnType, smartSqlConfig);
var ilGen = implMethod.GetILGenerator();
bool onlyOneParam = paramTypes.Length == 1;
Type firstParamType = paramTypes.FirstOrDefault();
ilGen.DeclareLocal(RequestContextType.AbstractType);
if (onlyOneParam && RequestContextType.AbstractType.IsAssignableFrom(firstParamType))
{
throw new SmartSqlException($"DyRepository.Method ParameterType :{firstParamType.FullName} can not be RequestContext.");
//ilGen.LoadArg(1);
//ilGen.StoreLocalVar(0);
}
bool isOnlyOneClassParam = onlyOneParam && !IsSimpleParam(firstParamType);
EmitNewRequestContext(ilGen, isOnlyOneClassParam, firstParamType);
EmitSetCommandType(ilGen, statementAttr);
EmitSetDataSourceChoice(ilGen, statementAttr);
if (String.IsNullOrEmpty(statementAttr.Sql))
{
EmitSetScope(ilGen, statementAttr.Scope);
EmitSetSqlId(ilGen, statementAttr);
}
else
{
EmitSetRealSql(ilGen, statementAttr);
}
if (isOnlyOneClassParam)
{
ilGen.LoadLocalVar(0);
ilGen.LoadArg(1);
ilGen.Callvirt(RequestContextType.Method.SetRequest);
}
else if (paramTypes.Length > 0)
{
ilGen.DeclareLocal(SqlParameterType.SqlParameterCollection);
bool ignoreParameterCase = smartSqlConfig.Settings.IgnoreParameterCase;
ilGen.Emit(ignoreParameterCase ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
ilGen.New(SqlParameterType.Ctor.SqlParameterCollection);
ilGen.StoreLocalVar(1);
for (int i = 0; i < methodParams.Length; i++)
{
int argIndex = i + 1;
var reqParam = methodParams[i];
string reqParamName = reqParam.Name;
var paramAttr = reqParam.GetCustomAttribute <ParamAttribute>();
if (paramAttr != null && !String.IsNullOrEmpty(paramAttr.Name))
{
reqParamName = paramAttr.Name;
}
ilGen.LoadLocalVar(1);
ilGen.LoadString(reqParamName);
ilGen.LoadArg(argIndex);
if (reqParam.ParameterType.IsValueType)
{
ilGen.Box(reqParam.ParameterType);
}
ilGen.LoadType(reqParam.ParameterType);
ilGen.New(SqlParameterType.Ctor.SqlParameter);
ilGen.Dup();
var getHandlerMethod = paramAttr?.FieldType != null?TypeHandlerCacheType.GetHandlerMethod(reqParam.ParameterType, paramAttr?.FieldType)
: PropertyTypeHandlerCacheType.GetHandlerMethod(reqParam.ParameterType);
ilGen.Call(getHandlerMethod);
ilGen.Call(SqlParameterType.Method.SetTypeHandler);
ilGen.Call(SqlParameterType.Method.Add);
}
ilGen.LoadLocalVar(0);
ilGen.LoadLocalVar(1);
ilGen.Callvirt(RequestContextType.Method.SetRequest);
}
MethodInfo executeMethod = PreExecuteMethod(statementAttr, returnType, isTaskReturnType);
ilGen.LoadArg(0);
ilGen.FieldGet(sqlMapperField);
ilGen.LoadLocalVar(0);
ilGen.Call(executeMethod);
if (returnType == CommonType.Void)
{
ilGen.Pop();
}
ilGen.Return();
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"RepositoryBuilder.BuildMethod:{methodInfo.Name}->Statement:[Scope:{statementAttr.Scope},Id:{statementAttr.Id},Execute:{statementAttr.Execute},Sql:{statementAttr.Sql},IsAsync:{isTaskReturnType}]");
}
}
