Example #1
0
        public static int UpdateEntityForLobColumn <T>(IClassMapper classMap, T entity, out IDictionary <string, object> dynamicParameters) where T : class
        {
            dynamicParameters = entity.ToDictionary();

            var lobColumns = classMap.Properties.Where(p => p.LobType != LobType.None);

            if (lobColumns.Count() == 0)
            {
                return(0);
            }
            int success = 0;

            foreach (var lobColumn in lobColumns)
            {
                string lobColumnKey = lobColumn.PropertyInfo.Name;
                if (dynamicParameters.ContainsKey(lobColumnKey))
                {
                    var lobColumnValue = dynamicParameters[lobColumnKey];
                    dynamicParameters[lobColumnKey] = LobConverter.ConvertValue(lobColumnValue, lobColumn.LobType);

                    success++;
                }
            }
            return(success);
        }
Example #2
0
        public static int UpdateDynamicParameterForLobColumn(IClassMapper classMap, IDictionary <string, object> dynamicParameters)
        {
            //自动转换clob 或者blob类型
            var lobColumns = classMap.Properties.Where(p => p.LobType != LobType.None);

            if (lobColumns.Count() == 0)
            {
                return(0);
            }
            int success = 0;

            foreach (var lobColumn in lobColumns)
            {
                string lobColumnKey = lobColumn.PropertyInfo.Name;
                if (dynamicParameters.ContainsKey(lobColumnKey))
                {
                    var lobColumnValue = dynamicParameters[lobColumnKey];
                    dynamicParameters[lobColumnKey] = LobConverter.ConvertValue(lobColumnValue, lobColumn.LobType);

                    success++;
                }
            }

            return(success);
        }
Example #3
0
        internal ExecuteSqlParamsContext UpdateInternal(object bindedObj = null, IDictionary <string, object> _PrimaryKeyValues = null, params string[] ignoreProperties)
        {
            var pd = pocoData;

            if (bindedObj != null)//自动绑定对象
            {
                BindPropertiesExts.BindPropertiesFromForDb(trackedObject, bindedObj, pd, ignoreProperties);
            }
            var    columns = UpdatedColumns();
            object poco    = trackedObject;

            //int defaultValue = 0;
            if (columns != null && !columns.Any())
            {
                return(null);
            }

            var    sb          = new StringBuilder();
            var    index       = 0;
            string paramPrefix = "";
            var    pkCols      = pd.Properties.Where(p => p.IsPrimaryKey).ToList();
            IDictionary <string, object> PrimaryKeyValues = new Dictionary <string, object>();

            if (_PrimaryKeyValues != null && _PrimaryKeyValues.Count > 0)
            {
                PrimaryKeyValues = _PrimaryKeyValues;
            }
            else
            {
                if (pkCols == null || pkCols.Count == 0)
                {
                    throw new ArgumentException("当前对象没有主键情况下,需要指定更新的主键值");
                }
                else
                {
                    var Properties = pd.Properties.Select(p => p.PropertyInfo);// poco.GetType().GetProperties();
                    foreach (var pk in pkCols)
                    {
                        string pName       = pk.Name;
                        string pColumnName = pk.Name;//  pk.ColumnName;
                        var    o           = Properties.FirstOrDefault(y => string.Equals(pName, y.Name, StringComparison.OrdinalIgnoreCase));
                        if (o != null)
                        {
                            var pValue = o.GetValue(poco, null);
                            PrimaryKeyValues.Add(pColumnName, pValue);
                        }
                    }
                }
            }


            IDictionary <string, object> parameters = new Dictionary <string, object>();


            var waitToUpdated = pd.Properties.Where(p => columns.Contains(p.ColumnName) || p.IsVersionColumn == true);

            foreach (var pocoColumn in waitToUpdated)
            {
                string properyName = pocoColumn.Name;//pocoColumn.ColumnName;

                // Don't update the primary key, but grab the value if we don't have it
                if (_PrimaryKeyValues == null && PrimaryKeyValues.ContainsKey(properyName))
                {
                    continue;
                }

                // Dont update result only columns
                if (pocoColumn.Ignored || pocoColumn.IsReadOnly || pocoColumn.IsPrimaryKey)
                {
                    continue;
                }

                var colType = pocoColumn.PropertyInfo.PropertyType;

                object value = pocoColumn.PropertyInfo.GetValue(poco, null);// GetColumnValue(pd, poco, ProcessMapper);
                if (pocoColumn.IsVersionColumn)
                {
                    if (colType == typeof(int) || colType == typeof(Int32))
                    {
                        value = Convert.ToInt32(value) + 1;
                    }
                    else if (colType == typeof(long) || colType == typeof(Int64))
                    {
                        value = Convert.ToInt64(value) + 1;
                    }
                    else if (colType == typeof(short) || colType == typeof(Int16))
                    {
                        value = Convert.ToInt16(value) + 1;
                    }
                }
                else
                {
                    if (Snapshotter.GetAutoFilterEmptyValueColumnsWhenTrack())
                    {
                        var defaultValueOfCol = ReflectionHelper.GetDefaultValueForType(colType);
                        if (object.Equals(defaultValueOfCol, value))//过滤空值列
                        {
                            continue;
                        }
                    }
                }



                // Build the sql
                if (index > 0)
                {
                    sb.Append(", ");
                }

                //string paramName = paramPrefix + index.ToString();// pocoColumn.Name;
                string paramName = paramPrefix + properyName;
                sb.AppendFormat("{0} = {1}{2}", db.SqlGenerator.GetColumnName(pd, pocoColumn, false), db.SqlGenerator.Configuration.Dialect.ParameterPrefix, paramName);

                parameters.Add(paramName, value);
                index++;
            }


            if (columns != null && columns.Any() && sb.Length == 0)
            {
                throw new ArgumentException("There were no columns in the columns list that matched your table", "columns");
            }

            var sql      = string.Format("UPDATE {0} SET {1} WHERE {2}", db.SqlGenerator.GetTableName(pd), sb, BuildWhereSql(db, pd, PrimaryKeyValues, paramPrefix, ref index));
            int temIndex = parameters.Count;

            foreach (var item in PrimaryKeyValues)
            {
                parameters.Add(paramPrefix + item.Key, item.Value);
                //parameters.Add(paramPrefix + temIndex, item.Value);
                temIndex++;
            }


            if (db.DatabaseType == DatabaseType.Oracle && LobConverter.Enable == true)
            {
                IDictionary <string, object> dictParameters = parameters;
                int convertCount = LobConverter.UpdateDynamicParameterForLobColumn(pd, dictParameters);
                if (convertCount > 0)
                {
                    //return db.Execute(sql, dictParameters);
                    return(new ExecuteSqlParamsContext(sql, dictParameters));
                }
                else
                {
                    //执行原始SQL
                    //return db.Execute(sql, parameters);

                    return(new ExecuteSqlParamsContext(sql, parameters));
                }
            }
            else
            {
                //执行原始SQL
                //return db.Execute(sql, parameters);
                return(new ExecuteSqlParamsContext(sql, parameters));
            }
        }
        private DbConnectionMetaInfo MapToDatabseConfig(PureDataConfiguration config, IDatabaseConfig databaseConfig)
        {
            DbConnectionMetaInfo metaInfo = null;

            if (config != null && databaseConfig != null)
            {
                if (config.Settings != null)
                {
                    var settings = config.Settings;
                    databaseConfig.ParameterPrefix            = settings.ParameterPrefix;
                    databaseConfig.ParameterSuffix            = settings.ParameterSuffix;
                    databaseConfig.GlobalTablePrefix          = settings.GlobalTablePrefix;
                    databaseConfig.ExecuteTimeout             = settings.ExecuteTimeout;
                    databaseConfig.DefaultPageSize            = settings.DefaultPageSize;
                    databaseConfig.AutoDisposeConnection      = settings.AutoDisposeConnection;
                    databaseConfig.ValidateStopOnFirstFailure = settings.ValidateStopOnFirstFailure;
                    databaseConfig.LoadMapperMode             = settings.LoadMapperMode;


                    databaseConfig.EnableDebug       = settings.EnableDebug;
                    databaseConfig.EnableIntercept   = settings.EnableIntercept;
                    databaseConfig.EnableLogError    = settings.EnableLogError;
                    databaseConfig.EnableOrmLog      = settings.EnableOrmLog;
                    databaseConfig.EnableInternalLog = settings.EnableInternalLog;
                    databaseConfig.LogWithRawSql     = settings.LogWithRawSql;
                    databaseConfig.CategoryLogType   = settings.CategoryLogType;
                    if (!string.IsNullOrEmpty(settings.OrmLogsPath))
                    {
                        databaseConfig.OrmLogsPath = settings.OrmLogsPath;
                    }
                    databaseConfig.MaxServerLogSize = settings.MaxServerLogSize;

                    databaseConfig.EnableOrmCache      = settings.EnableOrmCache;
                    databaseConfig.CacheOrmTime        = settings.CacheOrmTime;
                    databaseConfig.CacheOrmSingleTime  = settings.CacheOrmSingleTime;
                    databaseConfig.OrmCacheCheckPeriod = settings.OrmCacheCheckPeriod;

                    databaseConfig.EnableSqlMap        = settings.EnableSqlMap;
                    databaseConfig.NameSpacePrefix     = settings.NameSpacePrefix;
                    databaseConfig.FormatSql           = settings.FormatSql;
                    databaseConfig.IsWatchSqlMapFile   = settings.IsWatchSqlMapFile;
                    databaseConfig.WatchSqlMapInterval = settings.WatchSqlMapInterval;

                    databaseConfig.AutoMigrate = settings.AutoMigrate;
                    databaseConfig.AutoRemoveUnuseColumnInTable = settings.AutoRemoveUnuseColumnInTable;
                    databaseConfig.CanUpdatedWhenTableExisted   = settings.CanUpdatedWhenTableExisted;
                    databaseConfig.EnableAutoMigrateLog         = settings.EnableAutoMigrateLog;
                    databaseConfig.EnableAutoMigrateDebug       = settings.EnableAutoMigrateDebug;
                    databaseConfig.AutoMigrateOnContainTable    = settings.AutoMigrateOnContainTable;
                    databaseConfig.AutoMigrateWithoutTable      = settings.AutoMigrateWithoutTable;
                    if (!string.IsNullOrEmpty(settings.GlobalIgnoreUpdatedColumns))
                    {
                        databaseConfig.GlobalIgnoreUpdatedColumns = settings.GlobalIgnoreUpdatedColumns;
                    }
                    databaseConfig.EnableGlobalIgnoreUpdatedColumns     = settings.EnableGlobalIgnoreUpdatedColumns;
                    databaseConfig.AutoFilterEmptyValueColumnsWhenTrack = settings.AutoFilterEmptyValueColumnsWhenTrack;

                    //代码生成设置
                    databaseConfig.EnableCodeGen           = settings.EnableCodeGen;
                    databaseConfig.CodeGenType             = settings.CodeGenType;
                    databaseConfig.CodeGenClassNameMode    = settings.CodeGenClassNameMode;
                    databaseConfig.CodeGenPropertyNameMode = settings.CodeGenPropertyNameMode;

                    databaseConfig.CodeGenProjectName = settings.CodeGenProjectName;
                    databaseConfig.CodeGenNameSpace   = settings.CodeGenNameSpace;
                    databaseConfig.CodeGenTableFilter = settings.CodeGenTableFilter;
                    string _basePath = "";

                    //if (databaseConfig.EnableCodeGen)
                    //{
                    string[] basePaths = settings.CodeGenBaseDirectory.Split(';');
                    if (basePaths.Length > 0)
                    {
                        foreach (var basePath in basePaths)
                        {
                            if (System.IO.Directory.Exists(basePath))
                            {
                                _basePath = basePath;
                                break;
                            }
                        }
                    }

                    if (_basePath == "")
                    {
                        string baseRootPath = System.IO.Path.Combine(PathHelper.GetBaseDirectory(), "generate");
                        //if (Directory.Exists(baseRootPath))
                        //{
                        //    DirectoryInfo info = new DirectoryInfo(baseRootPath);
                        //    _basePath = info.Parent.FullName;
                        //}
                        _basePath = baseRootPath;
                    }
                    //}

                    databaseConfig.CodeGenBaseDirectory = _basePath;



                    //databaseConfig.EnableConnectionPool = settings.EnableConnectionPool;
                    //databaseConfig.EnableLogConnectionPool = settings.EnableLogConnectionPool;
                    //databaseConfig.MinIdle = settings.MinIdle;
                    //databaseConfig.MaxIdle = settings.MaxIdle;
                    //databaseConfig.InitialSize = settings.InitialSize;

                    //databaseConfig.MaxWaitMillis = settings.MaxWaitMillis;
                    //databaseConfig.MaxTotal = settings.MaxTotal;
                    //databaseConfig.TimeBetweenEvictionRunsMillis = settings.TimeBetweenEvictionRunsMillis;
                    //databaseConfig.MinEvictableIdleTimeMillis = settings.MinEvictableIdleTimeMillis;
                    //databaseConfig.EnableRemoveAbandoned = settings.EnableRemoveAbandoned;
                    //databaseConfig.RemoveAbandonedOnBorrow = settings.RemoveAbandonedOnBorrow;
                    //databaseConfig.RemoveAbandonedOnMaintenance = settings.RemoveAbandonedOnMaintenance;
                    //databaseConfig.RemoveAbandonedTimeout = settings.RemoveAbandonedTimeout;
                    //databaseConfig.NumTestsPerEvictionRun = settings.NumTestsPerEvictionRun;
                    //databaseConfig.SoftMinEvictableIdleTimeMillis = settings.SoftMinEvictableIdleTimeMillis;
                    //databaseConfig.TestOnBorrow = settings.TestOnBorrow;
                    //databaseConfig.TestOnCreate = settings.TestOnCreate;
                    //databaseConfig.TestOnReturn = settings.TestOnReturn;
                    //databaseConfig.TestWhileIdle = settings.TestWhileIdle;
                    //databaseConfig.ValidationQuery = settings.ValidationQuery;



                    databaseConfig.EnableLobConverter    = settings.EnableLobConverter;
                    databaseConfig.LobConverterClassName = settings.LobConverterClassName;
                    if (databaseConfig.EnableLobConverter == true)
                    {
                        try
                        {
                            Type type = Type.GetType(databaseConfig.LobConverterClassName);

                            if (type != null)
                            {
                                object obj = Activator.CreateInstance(type, true);

                                LobConverter.Init((ILobParameterConverter)(obj), databaseConfig.EnableLobConverter);
                            }
                            else
                            {
                                Log("没有找到相关ILobParameterConverter实现类,LobConverterClassName: " + databaseConfig.LobConverterClassName, new ArgumentException("没有找到相关ILobParameterConverter实现类,LobConverterClassName: " + databaseConfig.LobConverterClassName), MessageType.Error);
                            }
                        }
                        catch (Exception ex)
                        {
                            Log("没有找到相关ILobParameterConverter实现类,LobConverterClassName: " + databaseConfig.LobConverterClassName, new ArgumentException("没有找到相关ILobParameterConverter实现类,LobConverterClassName: " + databaseConfig.LobConverterClassName), MessageType.Error);

                            throw new ArgumentException("没有找到相关ILobParameterConverter实现类,LobConverterClassName: " + databaseConfig.LobConverterClassName, ex);
                        }
                    }
                    databaseConfig.BulkOperateClassName = settings.BulkOperateClassName;
                    databaseConfig.EnableDefaultPropertySecurityValidate = settings.EnableDefaultPropertySecurityValidate;

                    databaseConfig.PropertySecurityValidateClassName = settings.PropertySecurityValidateClassName;

                    if (!string.IsNullOrEmpty(settings.BulkOperateClassName))
                    {
                        try
                        {
                            Type type = Type.GetType(settings.BulkOperateClassName);

                            if (type != null)
                            {
                                IBulkOperate obj = (IBulkOperate)Activator.CreateInstance(type, true);
                                BulkOperateManage.Instance.Register(settings.BulkOperateClassName, obj);
                            }
                            else
                            {
                                Log("没有找到相关IBulkOperate实现类,BulkOperateClassName: " + settings.BulkOperateClassName, new ArgumentException("没有找到相关IBulkOperate实现类,BulkOperateClassName: " + settings.BulkOperateClassName), MessageType.Error);
                            }
                        }
                        catch (Exception ex)
                        {
                            Log("没有找到相关IBulkOperate实现类,BulkOperateClassName: " + settings.BulkOperateClassName, new ArgumentException("没有找到相关IBulkOperate实现类,BulkOperateClassName: " + settings.BulkOperateClassName), MessageType.Error);

                            throw new ArgumentException("没有找到相关IBulkOperate实现类,BulkOperateClassName: " + settings.BulkOperateClassName, ex);
                        }
                    }


                    if (!string.IsNullOrEmpty(settings.PropertySecurityValidateClassName))
                    {
                        try
                        {
                            Type type = Type.GetType(settings.PropertySecurityValidateClassName);

                            if (type != null)
                            {
                                IPropertySecurityValidate obj = (IPropertySecurityValidate)Activator.CreateInstance(type, true);
                                PropertySecurityValidateManage.Instance.Register(settings.PropertySecurityValidateClassName, obj);
                            }
                            else
                            {
                                Log("IPropertySecurityValidate 无法找到实现类, 将启用默认的安全校验器!");
                            }
                        }
                        catch (Exception ex)
                        {
                            Log("IPropertySecurityValidate 无法找到实现类, 将启用默认的安全校验器!");

                            // throw new ArgumentException("没有找到相关IBulkOperate实现类,PropertySecurityValidateClassName: " + settings.PropertySecurityValidateClassName, ex);
                        }
                    }
                }

                try
                {
                    if (config.DataSources != null)
                    {
                        string ConnectionString = "", ProviderName = "";
                        databaseConfig.DataSources = config.DataSources;

                        foreach (var item in config.DataSources)
                        {
                            if (item.IsMaster == true)//是否主数据库
                            {
                                ConnectionString = item.ConnectionString;
                                ProviderName     = item.Provider;
                                break;
                            }
                        }

                        metaInfo = DbConnectionFactory.CreateConnection(ConnectionString, ProviderName);
                    }
                    else
                    {
                        Log("DataSources 不能为空,且必须存在一个Master的数据源!", new ArgumentException("DataSources 不能为空,且必须存在一个Master的数据源!"), MessageType.Error);
                    }
                }
                catch (Exception ex)
                {
                    Log("DataSources 不能为空,且必须存在一个Master的数据源!", ex, MessageType.Error);

                    throw new ArgumentException("DataSources 不能为空,且必须存在一个Master的数据源!", ex);
                }



                if (config.MapperSources != null)
                {
                    Assembly ass = null;
                    string   _MapperSourcePath = "";
                    string   path = "";
                    MapperSource.MapperAssemblyType _MapperAssemblyType = MapperSource.MapperAssemblyType.ClassType;
                    try
                    {
                        databaseConfig.MappingAssemblies.Clear();

                        foreach (var item in config.MapperSources)
                        {
                            _MapperAssemblyType = item.Type;
                            if (item.Type == MapperSource.MapperAssemblyType.File)
                            {
                                _MapperSourcePath = item.Path;
                                path = FileLoader.GetPath(item.Path);
                                ass  = Assembly.LoadFrom(path);
                                databaseConfig.MappingAssemblies.Add(ass);
                            }
                            else if (item.Type == MapperSource.MapperAssemblyType.ClassType)
                            {
                                path = item.ClassName;

                                Type type = Type.GetType(item.ClassName);
                                if (type != null)
                                {
                                    ass = type.Assembly;
                                    if (ass != null)
                                    {
                                        databaseConfig.MappingAssemblies.Add(ass);
                                    }
                                }
                                else
                                {
                                    Log("MapperSource 中存在不正确的Type:" + item.ClassName, new ArgumentException("MapperSource 中存在不正确的Type:" + item.ClassName), MessageType.Error);
                                }
                            }
                        }


                        foreach (var item in PureDataConfigurationLoader.MapperSourceAssemblies)
                        {
                            if (item != null)
                            {
                                databaseConfig.MappingAssemblies.Add(item);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Log("Load MapperSource error on :" + _MapperAssemblyType + ", " + _MapperSourcePath + " , path:" + path, ex, MessageType.Error);
                        throw new ArgumentException("Load MapperSource error on :" + _MapperAssemblyType + ", " + _MapperSourcePath, ex);
                    }
                }



                if (config.SqlMapSources != null)
                {
                    var dirSqlMappers  = config.SqlMapSources.Where(p => p.Type == ResourceType.Directory);
                    var fileSqlMappers = config.SqlMapSources.Where(p => p.Type == ResourceType.File);

                    databaseConfig.SqlMapDirPaths  = dirSqlMappers.Select(p => p.Path).ToList();
                    databaseConfig.SqlMapFilePaths = fileSqlMappers.Select(p => p.Path).ToList();

                    foreach (var item in PureDataConfigurationLoader.SqlMapDirPaths)
                    {
                        if (item != null)
                        {
                            databaseConfig.SqlMapDirPaths.Add(item);
                        }
                    }
                    foreach (var item in PureDataConfigurationLoader.SqlMapFilePaths)
                    {
                        if (item != null)
                        {
                            databaseConfig.SqlMapFilePaths.Add(item);
                        }
                    }
                }

                try
                {
                    if (databaseConfig.EnableIntercept == true)
                    {
                        databaseConfig.Interceptors.Clear();

                        //if (databaseConfig.EnableDebug && databaseConfig.EnableIntercept)
                        //{
                        //    databaseConfig.Interceptors.Add(OutputSQLIntercept.Instance);
                        //    databaseConfig.Interceptors.Add(OutputExceptionIntercept.Instance);
                        //}

                        if (config.Interceptors != null)
                        {
                            IInterceptor ass  = null;
                            string       path = "";

                            foreach (var item in config.Interceptors)
                            {
                                ass = null;
                                if (string.IsNullOrEmpty(item.ClassFullName) || string.IsNullOrEmpty(item.AssemblyName))
                                {
                                    continue;
                                }
                                if (item.Type == InterceptorSource.InterceptorType.ConnectionInterceptor)
                                {
                                    ass = ReflectionHelper.CreateInstance <IConnectionInterceptor>(item.ClassFullName, item.AssemblyName);
                                }
                                else if (item.Type == InterceptorSource.InterceptorType.ExecutingInterceptor)
                                {
                                    ass = ReflectionHelper.CreateInstance <IExecutingInterceptor>(item.ClassFullName, item.AssemblyName);
                                }
                                else if (item.Type == InterceptorSource.InterceptorType.ExceptionInterceptor)
                                {
                                    ass = ReflectionHelper.CreateInstance <IExceptionInterceptor>(item.ClassFullName, item.AssemblyName);
                                }
                                else if (item.Type == InterceptorSource.InterceptorType.DataInterceptor)
                                {
                                    ass = ReflectionHelper.CreateInstance <IDataInterceptor>(item.ClassFullName, item.AssemblyName);
                                }
                                else if (item.Type == InterceptorSource.InterceptorType.TransactionInterceptor)
                                {
                                    ass = ReflectionHelper.CreateInstance <ITransactionInterceptor>(item.ClassFullName, item.AssemblyName);
                                }

                                if (ass != null)
                                {
                                    databaseConfig.Interceptors.Add(ass);
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    Log("Load Intercept error  !", ex, MessageType.Error);
                    throw new ArgumentException("Load Intercept error  !", ex);
                }



                if (config.CodeGenTemplates != null)
                {
                    databaseConfig.CodeGenTemplates = config.CodeGenTemplates;
                }
            }

            return(metaInfo);
        }