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}]"); } }