コード例 #1
0
        /// <summary>
        /// 解析生成删除SQL
        /// </summary>
        /// <remarks>按主键数据作为查询依据</remarks>
        /// <param name="domainModel">领域模型</param> 
        /// <param name="domainObject">领域对象</param>
        /// <param name="dataID">主键数据</param>
        /// <param name="shardingKeyValue">分库分表键值对</param>
        /// <returns>删除SQL</returns>
        public SqlStatementCollection ParseDeleteSqlByID(DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject, string dataID, ShardingValue shardingKeyValue = null)
        {
            var sqls = new SqlStatementCollection();
            var sqlSchema = new SqlStatementCollection();

            var routeInfo = routeService.RouteByDataID(domainModel, dataID, shardingKeyValue);
            var dataIDDic = CreatePkDataDictionary(domainModel, domainModel.RootDomainObject, dataID);
            var dataContext = DataContextBuilder.CreateDataContext<IDictionary<string, object>>(domainModel, domainObject, DataAccessOpType.D, dataIDDic);

            //解析SQL语句主干接口
            ParseDeleteSqlSchema(sqlSchema, domainModel, domainObject, routeInfo, dataContext);

            //在SqlSchema上逐表添加数据
            ParseDeleteSqlDetail(sqlSchema, sqls, domainModel, domainObject, dataContext, routeInfo);

            var result = new SqlStatementCollection();
            foreach (var tempDomainObject in domainModel.ReverseDomainObjects)
            {
                var sql = sqls.FirstOrDefault(i => i.NodeID == tempDomainObject.ID);
                if (sql != null)
                {
                    result.Add(sql);
                }
            }

            return result;
        }
コード例 #2
0
        /// <summary>
        /// 批量删除
        /// </summary>
        /// <remarks>按主键数据作为查询依据</remarks>
        /// <param name="domainModel">领域模型</param>
        /// <param name="domainObject">领域对象</param>
        /// <param name="dataID">主键数据</param>
        /// <param name="shardingKeyValue">分库分表键值对</param>
        /// <returns>删除SQL</returns>
        public void DeleteByIDs(DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject, IEnumerable <string> dataIDs, ShardingValue shardingKeyValue = null)
        {
            if (domainModel == null)
            {
                throw new ArgumentNullException("DataDeleteService.DeleteByID.domainModel");
            }
            if (domainObject == null)
            {
                throw new ArgumentNullException("DataDeleteService.DeleteByID.domainObject");
            }
            if (dataIDs == null || dataIDs.Count() == 0)
            {
                throw new ArgumentNullException("DataDeleteService.DeleteByID.dataIDs");
            }

            var sqlList = new SqlStatementCollection();

            foreach (var dataID in dataIDs)
            {
                var sqls = SQLBuilderFactory.CreateSQLBuilder().ParseDeleteSqlByID(domainModel, domainObject, dataID, shardingKeyValue);
                sqlList.AddRange(sqls);
            }

            var db = DatabaseFactory.CreateDefaultDatabase();

            db.ExecuteSQLWithTransaction(sqlList);
        }
コード例 #3
0
        /// <summary>
        /// 根据已经解析的SqlSchema,解析生成带数据的Update语句。
        /// </summary>
        /// <param name="sqlSchemata">已经解析的SqlSchema。</param>
        /// <param name="domainModel">领域对象</param>
        /// <param name="context">数据上下文</param>
        /// <returns>Insert语句集合</returns>
        private SqlStatementCollection ParseUpdateSqlDetail(SqlStatementCollection sqlSchemata, DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject,
            DataContext dataContext, Dictionary<string, ShardingTarget> routeInfo)
        {
            var result = new SqlStatementCollection();
            if (!dataContext.Data.ContainsKey(domainObject.ID))
            {
                return result;
            }
            var data = dataContext.Data[domainObject.ID];

            if (data == null || data.Count == 0) return result;

            var strategy = new UpdateSqlBuildStrategy();

            for (int i = 0; i < dataContext.Data[domainObject.ID].Count; i++)
            {
                dataContext.CurrentDataIndex = i;
                var context = new SqlBuildingContext(domainModel, domainObject, SQLBuilderUtils.GetCurrentDbType(), dataContext);
                context.RouteInfo = routeInfo;

                var rowSqls = new SqlStatementCollection();
                var sqls = sqlSchemata.Where(s => s.SqlBuildingInfo.CurrentNode.ID == domainObject.ID).ToList();
                rowSqls.AddRangeClone(sqls);

                strategy.BuildTableSqlDetail(rowSqls, context);
                result.AddRange(rowSqls);
            }

            return result;
        }
コード例 #4
0
        /// <summary>
        /// 保存领域模型数据
        /// </summary>
        /// <param name="domainModel">领域模型</param>
        /// <param name="instanceList">对象实例集合</param>
        /// <param name="shardingValueList">分区分表键值对集合</param>
        public void SaveBatch(DomainModel.Spi.DomainModel domainModel, List <object> instanceList, List <ShardingValue> shardingValueList = null)
        {
            if (domainModel == null)
            {
                throw new ArgumentNullException("SaveService.Save.domainModel");
            }
            if (instanceList == null)
            {
                throw new ArgumentNullException("SaveService.Save.instanceList");
            }

            var sqls = new SqlStatementCollection();

            for (int i = 0; i < instanceList.Count; i++)
            {
                var           currentObj    = instanceList[i];
                ShardingValue shardingValue = null;
                if (shardingValueList != null)
                {
                    shardingValue = shardingValueList[i];
                }

                var sqlstatements = SQLBuilderFactory.CreateSQLBuilder().ParseInsertSql(domainModel, currentObj, shardingValue);

                sqls.AddRange(sqlstatements);
            }

            var db = DatabaseFactory.CreateDefaultDatabase();

            db.ExecuteSQLWithTransaction(sqls);
        }
コード例 #5
0
 /// <summary>
 /// 批量增加SQL语句集合的副本。
 /// </summary>
 /// <param name="childSqlCollection">SQL语句集合。</param>
 public void AddRangeClone(SqlStatementCollection childSqlCollection)
 {
     foreach (var sql in childSqlCollection)
     {
         this.Add(sql.Clone() as SqlStatement);
     }
 }
コード例 #6
0
        private void ParseDeleteSqlDetail(SqlStatementCollection sqlSchemata, SqlStatementCollection result, DomainModel.Spi.DomainModel domainModel,
                                          DomainModel.Spi.DomainObject domainObject, DataContext dataContext, Dictionary <string, ShardingTarget> routeInfo)
        {
            //构造SQL语句的条件
            var strategy = new DeleteSqlBuildStrategy();
            var context  = new SqlBuildingContext(domainModel, domainObject, domainObject.DataObject.DataSource.DbType, dataContext);

            context.RouteInfo = routeInfo;
            var rowSqls = new SqlStatementCollection();
            var sqls    = sqlSchemata.Where(s => s.SqlBuildingInfo.CurrentNode.ID == domainObject.ID).ToList();

            rowSqls.AddRangeClone(sqls);
            strategy.BuildTableSqlDetail(rowSqls, context);
            result.AddRange(rowSqls);

            //递归处理子对象
            if (domainObject.ChildDomainObjects.Count == 0)
            {
                return;
            }
            foreach (var childModelObject in domainObject.ChildDomainObjects)
            {
                ParseDeleteSqlDetail(sqlSchemata, result, domainModel, childModelObject, dataContext, routeInfo);
            }
        }
コード例 #7
0
        /// <summary>
        /// 构造不包含数据的Sql(即SqlSchema)。
        /// </summary>
        /// <param name="sqls">Sql语句对象集合。</param>
        /// <param name="context">Sql构造的上下文信息。</param>
        public override SqlStatementCollection BuildTableSqlSchema(SqlBuildingContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("SelectSqlBuildStrategy.BuildTableSqlSchema");
            }

            var sqls = new SqlStatementCollection();

            var selectStatement = SQLStatementFactory.CreateSqlStatement(SqlStatementType.Select, context.DbType) as SelectSqlStatement;

            selectStatement.SqlBuildingInfo.DataSource = context.DataSource;

            //Parsing main part of query SQL statement
            BuildMainFrom(selectStatement, context.CommonObject, context.Node, context.DataObject, context.TableName, context);

            //Parsing query fields list
            BuildQueryFieldList(selectStatement, context.Node, context.DataObject);

            //Parsing inner join clause
            BuildMainInnerJoin(selectStatement, context);

            sqls.Add(selectStatement);
            sqls.ShardingInfo = context.RouteInfo;

            return(sqls);
        }
コード例 #8
0
        /// <summary>
        /// 在数据库事务中执行SQL语句返回影响行数
        /// </summary>
        /// <param name="sqls">SQL语句</param>
        public void ExecuteSQLWithTransaction(SqlStatementCollection sqls)
        {
            if (sqls == null)
            {
                throw new ArgumentNullException("DatabaseImpl.ExecuteSQLWithTransaction.sqls");
            }

            var sqlGroups = sqls.GroupBy(i => i.SqlBuildingInfo.DataSource);

            using (var ts = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions()
            {
                IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted
            }))
                try
                {
                    foreach (var sqlGroup in sqlGroups)
                    {
                        if (sqlGroup.Count() == 0)
                        {
                            continue;
                        }
                        var dataSourceName = sqlGroup.FirstOrDefault().SqlBuildingInfo.DataSource;

                        using (var db = GetDatabase(dataSourceName))
                        {
                            foreach (var sqlstatment in sqlGroup)
                            {
                                var sqlString = sqlstatment.ToSQL();
                                try
                                {
                                    var parameters = new List <IDbDataParameter>();
                                    parameters = CreateParameters(db, sqlstatment, parameters);

                                    if (parameters == null || parameters.Count == 0)
                                    {
                                        db.ExecSqlStatement(sqlString);
                                    }
                                    else
                                    {
                                        db.ExecSqlStatement(sqlString, parameters.ToArray());
                                    }
                                }
                                catch (Exception e)
                                {
                                    MonitorError(e, sqlString);
                                    throw;
                                }
                            }
                        }
                    }

                    ts.Complete();
                }
                catch (Exception e)
                {
                    MonitorError(e, new string[sqls.Count]);
                    throw;
                }
        }
コード例 #9
0
        /// <summary>
        /// 解析生成Insert语句。
        /// </summary>       
        /// <param name="domainModel">领域模型。</param>
        /// <param name="instance">要插入的数据。</param>
        /// <param name="shardingKeyValue">分库分表键值对</param>
        /// <returns>Insert语句集合。</returns>
        public SqlStatementCollection ParseInsertSql(DomainModel.Spi.DomainModel domainModel, object instance, ShardingValue shardingKeyValue = null)
        {
            var sqls = new SqlStatementCollection();
            var routeInfo = routeService.Route(domainModel, instance, shardingKeyValue);
            var dataContext = DataContextBuilder.CreateDataContext<object>(domainModel, domainModel.RootDomainObject, DataAccessOpType.I, instance);

            //解析SQL语句主干接口
            ParseInsertSqlSchema(sqls, domainModel, domainModel.RootDomainObject, routeInfo);

            //在SqlSchema上逐表添加数据
            return ParseInsertSqlDetail(sqls, domainModel, dataContext, routeInfo);
        }
コード例 #10
0
        /// <summary>
        /// 在SqlSchema基础上,构造包含数据的Sql。
        /// </summary>
        /// <param name="sqls">Sql语句对象集合。</param>
        /// <param name="context">Sql构造的上下文信息。</param>
        public override void BuildTableSqlDetail(SqlStatementCollection sqls, SqlBuildingContext context)
        {
            var sql = sqls.FirstOrDefault(i => i.SqlBuildingInfo.CurrentNode.ID == context.Node.ID);

            if (sql == null)
            {
                throw new Exception("DomainObject cannot find SqlSchema, DomainObjectID: " + context.Node.ID);
            }

            var deleteStatement = sql as DeleteSqlStatement;

            this.HandlingCondition(deleteStatement, context);
        }
コード例 #11
0
        /// <summary>
        /// 在SqlSchema基础上,构造包含数据的Sql。
        /// </summary>
        /// <param name="sqls">Sql语句对象集合。</param>
        /// <param name="context">Sql构造的上下文信息。</param>
        public override void BuildTableSqlDetail(SqlStatementCollection sqls, SqlBuildingContext context)
        {
            var sql = sqls.FirstOrDefault(x => x.SqlBuildingInfo.TableName == context.TableName);
            if (sql == null) return;

            var querySQL = sql as SelectSqlStatement;

            //Parsing left join clause of query SQL statement
            BuildSQLJoin(querySQL, context);

            //Parsing where clause of query SQL statement
            BuildSQLCondition(querySQL, context);
        }
コード例 #12
0
        /// <summary>
        /// 在SqlSchema基础上,构造包含数据的Sql。
        /// </summary>
        /// <param name="sqls">Sql语句对象集合。</param>
        /// <param name="context">Sql构造的上下文信息。</param>
        public override void BuildTableSqlDetail(SqlStatementCollection sqls, SqlBuildingContext context)
        {
            var sql = sqls.FirstOrDefault(x => x.SqlBuildingInfo.TableName == context.TableName);

            if (sql == null)
            {
                return;
            }

            var updateSql = sql as UpdateSqlStatement;

            this.HandlingUpdateFields(updateSql, context);
            this.HandlingConditionInfoAddData(updateSql, context);
        }
コード例 #13
0
        /// <summary>
        /// 在SqlSchema基础上,构造包含数据的Sql。
        /// </summary>
        /// <param name="sqls">Sql语句对象集合。</param>
        /// <param name="context">Sql构造的上下文信息。</param>
        public override void BuildTableSqlDetail(SqlStatementCollection sqls, SqlBuildingContext context)
        {
            var sql = sqls.FirstOrDefault(x => x.SqlBuildingInfo.TableName == context.TableName);

            if (sql == null)
            {
                return;
            }

            var insertStatement = sql as InsertSqlStatement;

            //insertStatement.SqlBuildingInfo = InitSqlBuildingInfo(context.CommonObject, context.Node, context.DataObject, context.TableName);

            this.HandlingFieldsAddData(insertStatement, context);
        }
コード例 #14
0
        /// <summary>
        /// 根据已经解析的SqlSchema,解析生成带数据的Update语句。
        /// </summary>
        /// <param name="sqlSchemata">已经解析的SqlSchema。</param>
        /// <param name="domainModel">领域对象</param>
        /// <param name="context">数据上下文</param>
        /// <returns>Insert语句集合</returns>
        private SqlStatementCollection ParseUpdateSqlDetail(SqlStatementCollection sqlSchemata, DomainModel.Spi.DomainModel domainModel, DataContext context, Dictionary<string, ShardingTarget> routeInfo)
        {
            var result = new SqlStatementCollection();

            foreach (var node in domainModel.DomainObjects)
            {
                var data = context.Data[node.ID];
                if (data == null || data.Count == 0) continue;

                context.ResetCurrentDataIndex();
                var nodeSqls = ParseUpdateSqlDetail(sqlSchemata, domainModel, node, context, routeInfo);
                result.AddRange(nodeSqls);
            }

            return result;
        }
コード例 #15
0
        /// <summary>
        /// 处理sql集合中的参数,调用底层数据访问接口,返回受影响的行数据。
        /// </summary>
        /// <param name="sqls">待处理的SQL语句集合</param>
        /// <returns>受影响的行数据</returns>
        public void ExecuteSQLs(SqlStatementCollection sqls)
        {
            if (sqls == null)
            {
                throw new ArgumentNullException("DatabaseImpl.ExecuteSQLs.sqls");
            }
            if (sqls.Count == 0)
            {
                return;
            }

            foreach (var sqlstatment in sqls)
            {
                using (var db = GetDatabase(sqlstatment.SqlBuildingInfo.DataSource))
                {
                    var sqlString = sqlstatment.ToSQL();
                    try
                    {
                        var parameters = new List <IDbDataParameter>();

                        if (sqlstatment is InsertSqlStatement)
                        {
                            parameters = ParameterHandlerForInsert(sqlstatment, db);
                        }

                        else if (sqlstatment is UpdateSqlStatement)
                        {
                            parameters = ParameterHandlerForUpdate(sqlstatment, db);
                        }

                        if (parameters == null || parameters.Count == 0)
                        {
                            db.ExecSqlStatement(sqlString);
                        }
                        else
                        {
                            db.ExecSqlStatement(sqlString, parameters);
                        }
                    }
                    catch (Exception e)
                    {
                        MonitorError(e, sqlString);
                        throw;
                    }
                }
            }
        }
コード例 #16
0
        /// <summary>
        /// 构造查询SQL语句的主干结构
        /// </summary>
        /// <param name="dataObject">数据对象</param>
        /// <returns>查询SQL语句的主干结构</returns>
        private void ParseDeleteSqlSchema(SqlStatementCollection sqlSchemata, DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject, Dictionary<string, ShardingTarget> routeInfo, DataContext dataContext)
        {
            var selectStrategy = new DeleteSqlBuildStrategy();
            var context = new SqlBuildingContext(domainModel, domainObject, SQLBuilderUtils.GetCurrentDbType(), dataContext);
            context.RouteInfo = routeInfo;

            var nodeSqlSchemata = selectStrategy.BuildTableSqlSchema(context);
            sqlSchemata.AddRange(nodeSqlSchemata);

            //递归处理子对象
            if (domainObject.ChildDomainObjects.Count == 0) return;

            foreach (var childModelObject in domainObject.ChildDomainObjects)
            {
                ParseDeleteSqlSchema(sqlSchemata, domainModel, childModelObject, routeInfo, dataContext);
            }
        }
コード例 #17
0
        /// <summary>
        /// 解析生成查询SQL
        /// </summary>
        /// <remarks>按主键数据作为查询依据</remarks>
        /// <param name="domainModel">领域模型</param>            
        /// <param name="domainObject">领域对象</param>        
        /// <param name="dataID">主键数据</param>
        /// <param name="shardingKeyValue">分库分表键值对</param>
        /// <returns>查询SQL</returns>
        public SqlStatementCollection ParseQuerySqlByID(DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject, string dataID, ShardingValue shardingKeyValue = null)
        {
            var sqls = new SqlStatementCollection();
            var sqlSchema = new SqlStatementCollection();

            var routeInfo = routeService.RouteByDataID(domainModel, dataID, shardingKeyValue);
            var dataIDDic = CreatePkDataDictionary(domainModel, domainObject, dataID);
            var dataContext = DataContextBuilder.CreateDataContext<IDictionary<string, object>>(domainModel, domainObject, DataAccessOpType.Q, dataIDDic);

            //解析SQL语句主干接口
            ParseQuerySqlSchema(sqlSchema, domainModel, domainObject, routeInfo, dataContext);

            //在SqlSchema上逐表添加数据
            ParseQuerySqlDetail(sqlSchema, sqls, domainModel, domainObject, dataContext, routeInfo);

            return sqlSchema;
        }
コード例 #18
0
        /// <summary>
        /// 构造不包含数据的Sql(即SqlSchema)。
        /// </summary>
        /// <param name="sqls">Sql语句对象集合。</param>
        /// <param name="context">Sql构造的上下文信息。</param>
        public override SqlStatementCollection BuildTableSqlSchema(SqlBuildingContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("UpdateSqlBuildStrategy.BuildTableSqlSchema");
            }

            var sqls = new SqlStatementCollection();

            var updateStatement = SQLStatementFactory.CreateSqlStatement(SqlStatementType.Update, context.DbType) as UpdateSqlStatement;

            updateStatement.SqlBuildingInfo.DataSource = context.DataSource;

            base.HandlingSqlStatement(updateStatement, context);
            sqls.Add(updateStatement);

            return(sqls);
        }
コード例 #19
0
        /// <summary>
        /// 构造不包含数据的Sql(即SqlSchema)。
        /// </summary>
        /// <param name="sqls">Sql语句对象集合。</param>
        /// <param name="context">Sql构造的上下文信息。</param>
        public override SqlStatementCollection BuildTableSqlSchema(SqlBuildingContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("InsertSqlBuilder.BuildTableSqlSchema");
            }

            var sqls = new SqlStatementCollection();

            var insertStatement = SQLStatementFactory.CreateSqlStatement(SqlStatementType.Insert, context.DbType) as InsertSqlStatement;

            base.HandlingSqlStatement(insertStatement, context);
            HandlingInsertFields(insertStatement, context);
            insertStatement.SqlBuildingInfo.DataSource = context.DataSource;

            sqls.Add(insertStatement);

            return(sqls);
        }
コード例 #20
0
        /// <summary>
        /// 构造不包含数据的Sql(即SqlSchema)。
        /// </summary>
        /// <param name="sqls">Sql语句对象集合。</param>
        /// <param name="context">Sql构造的上下文信息。</param>
        public override SqlStatementCollection BuildTableSqlSchema(SqlBuildingContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("DeleteSqlBuildStrategy.BuildTableSqlSchema");
            }

            var sqls = new SqlStatementCollection();

            //构造DeleteSql
            var sql = SQLStatementFactory.CreateSqlStatement(SqlStatementType.Delete, context.DbType) as DeleteSqlStatement;

            base.HandlingSqlStatement(sql, context);

            //构造DeleteSql的删除过滤条件
            this.HandlingJoin(sql, context);
            sqls.Add(sql);

            return(sqls);
        }
コード例 #21
0
        /// <summary>
        /// 解析生成Insert语句的主干部分。
        /// </summary>
        /// <param name="sqlSchemata">Insert语句的主干。</param>
        /// <param name="co">通用中间对象。</param>
        /// <param name="node">通用中间对象的节点。</param>
        /// <returns>Insert语句的主干部分。</returns>
        private void ParseInsertSqlSchema(SqlStatementCollection sqlSchemata, DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject,
                                          Dictionary <string, ShardingTarget> routeInfo)
        {
            var insertStrategy = new InsertSqlBuildStrategy();
            var context        = new SqlBuildingContext(domainModel, domainObject, domainObject.DataObject.DataSource.DbType);

            context.RouteInfo = routeInfo;

            var nodeSqlSchemata = insertStrategy.BuildTableSqlSchema(context);

            sqlSchemata.AddRange(nodeSqlSchemata);

            //递归处理子对象
            if (context.Node.ChildDomainObjects.Count == 0)
            {
                return;
            }

            foreach (var childModelObject in context.Node.ChildDomainObjects)
            {
                ParseInsertSqlSchema(sqlSchemata, domainModel, childModelObject, routeInfo);
            }
        }
コード例 #22
0
        /// <summary>
        /// 解析生成Insert语句的主干部分。
        /// </summary>
        /// <param name="sqlSchemata">Insert语句的主干。</param>
        /// <param name="co">通用中间对象。</param>
        /// <param name="node">通用中间对象的节点。</param>
        /// <returns>Insert语句的主干部分。</returns>
        private void ParseUpdateSqlSchema(SqlStatementCollection sqlSchemata, DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject,
                                          Dictionary <string, ShardingTarget> routeInfo, DataContext dataContext)
        {
            var updateStrategy = new UpdateSqlBuildStrategy();
            var context        = new SqlBuildingContext(domainModel, domainObject, domainObject.DataObject.DataSource.DbType);

            context.RouteInfo = routeInfo;
            if (dataContext.GetCurrentDataContextItem(domainObject.ID) != null)
            {
                var nodeSqlSchemata = updateStrategy.BuildTableSqlSchema(context);
                sqlSchemata.AddRange(nodeSqlSchemata);
            }

            //递归处理子对象
            if (context.Node.ChildDomainObjects.Count == 0)
            {
                return;
            }

            foreach (var childModelObject in context.Node.ChildDomainObjects)
            {
                ParseUpdateSqlSchema(sqlSchemata, domainModel, childModelObject, routeInfo, dataContext);
            }
        }
コード例 #23
0
        /// <summary>
        /// 解析生成查询SQL
        /// </summary>
        /// <remarks>按主键数据作为查询依据</remarks>
        /// <param name="domainModel">领域模型</param>            
        /// <param name="domainObject">领域对象</param>               
        /// <param name="filter">过滤器</param>
        /// <returns>查询SQL</returns>
        public SqlStatementCollection ParseQuerySqlByFilter(DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject, QueryFilter filter)
        {
            var sqls = new SqlStatementCollection();

            return sqls;
        }
コード例 #24
0
 /// <summary>
 /// 在SqlSchema基础上,构造GSPAbsDBTable包含数据的Sql。
 /// </summary>
 /// <param name="sqls">Sql语句对象集合。</param>
 /// <param name="context">Sql构造的上下文信息。</param>
 public abstract void BuildTableSqlDetail(SqlStatementCollection sqls, SqlBuildingContext context);
コード例 #25
0
        /// <summary>
        /// 执行SQL获取数据
        /// </summary>
        /// <param name="sql">SQL语句</param>
        /// <returns>数据</returns>
        public List <DataTable> GetDataCollection(SqlStatementCollection sqls)
        {
            if (sqls == null)
            {
                throw new ArgumentNullException("DatabaseImpl.GetData.sqls");
            }

            var dataTables = new List <DataTable>();
            var sqlGroups  = sqls.GroupBy(i => i.SqlBuildingInfo.DataSource);

            try
            {
                foreach (var sqlGroup in sqlGroups)
                {
                    if (sqlGroup.Count() == 0)
                    {
                        continue;
                    }
                    var dataSourceName = sqlGroup.FirstOrDefault().SqlBuildingInfo.DataSource;

                    using (var db = GetDatabase(dataSourceName))
                    {
                        foreach (var sqlstatment in sqlGroup)
                        {
                            var sqlString = sqlstatment.ToSQL();
                            try
                            {
                                var parameters = new List <IDbDataParameter>();

                                if (sqlstatment is SelectSqlStatement)
                                {
                                    parameters = ParameterHandlerForSelect(sqlstatment, db);
                                }

                                var ds = new DataSet();
                                if (parameters == null || parameters.Count == 0)
                                {
                                    ds = db.ExecuteDataSet(sqlString);
                                }
                                else
                                {
                                    ds = db.ExecuteDataSet(sqlString, parameters.ToArray());
                                }

                                if (ds != null)
                                {
                                    foreach (DataTable dt in ds.Tables)
                                    {
                                        dataTables.Add(dt);
                                    }
                                }
                            }
                            catch (Exception e)
                            {
                                MonitorError(e, sqlString);
                                throw;
                            }
                        }
                    }
                }

                return(dataTables);
            }
            catch (Exception e)
            {
                MonitorError(e, new string[sqls.Count]);
                throw;
            }
        }