示例#1
0
        public void Create(SQL _Sql, LambdaExpression _LambdaExpression, EJoinType _EJoinType, Analysis analysis)
        {
            if (_LambdaExpression.Body is BinaryExpression)
            {
                var body = (_LambdaExpression.Body as BinaryExpression);

                var _Parameters = _LambdaExpression.Parameters;

                var _Parameter = _Parameters[_Parameters.Count - 1];

                var _Alias = DbSettings.KeywordHandle(_Parameter.Name);

                var _TabName = DbSettings.KeywordHandle(_Parameter.Type.Name);

                _Sql.Code_Join.AppendFormat(" {0} {1} AS {2} ON ", _EJoinType.ToString().Replace("_", " "), _TabName, _Alias);

                var _New_Sql = new SQL();
                _New_Sql.Parameter = _Sql.Parameter;

                analysis.CreateWhere(_LambdaExpression, _New_Sql);

                _Sql.Code_Join.Append(_New_Sql.Code_Where);

                _Sql.Parameter = _New_Sql.Parameter;

                _Sql.Alias[_Alias] = _TabName;
            }
        }
示例#2
0
 public JoinTable(IQueryTable joinQueryTable, WhereClip joinWhere, EJoinType joinType, params ExpressionClip[] queryCulumns)
 {
     this.JoinQueryTable = joinQueryTable;
     this.JoinWhere      = joinWhere;
     this.JoinType       = joinType;
     this.QueryCulumns   = queryCulumns;
 }
示例#3
0
        public void Create(SQL _Sql, LambdaExpression _LambdaExpression, EJoinType _EJoinType, Analysis analysis)
        {
            PropertyInfo propertyInfo = null;

            foreach (var item in _LambdaExpression.Parameters)
            {
                var _TypeInfo = item.Type as TypeInfo;
                propertyInfo = _TypeInfo.GetProperties().OrderByDescending(w => w.Name).ToList()[0];
            }

            var _Alias   = DbSettings.KeywordHandle(propertyInfo.Name);
            var _TabName = DbSettings.KeywordHandle(propertyInfo.PropertyType.Name);

            _Sql.Code_Join.AppendFormat(" {0} {1} AS {2} ON ", _EJoinType.ToString().Replace("_", " "), _TabName, _Alias);
            var _New_Sql = new SQL();

            _New_Sql.Parameter = _Sql.Parameter;

            analysis.CreateWhere(_LambdaExpression, _New_Sql);

            _Sql.Code_Join.Append(_New_Sql.Code_Where);

            _Sql.Parameter = _New_Sql.Parameter;

            _Sql.Alias[_Alias] = _TabName;

            if (!_Sql.TableNames.Contains(propertyInfo.PropertyType.Name))
            {
                _Sql.TableNames.Add(propertyInfo.PropertyType.Name);
            }
        }
示例#4
0
 public JOIN(EJoinType joinType, Expression table1, Expression table2, Expression joinExpression)
 {
     this.joinType       = joinType;
     this.table1         = table1;
     this.table2         = table2;
     this.joinExpression = joinExpression;
     this.joinType       = joinType;
 }
示例#5
0
 public JoinedTable(EJoinType joinType, ITableSource table, bool isWeak, ISearchCondition searchCondition)
 {
     JoinType        = joinType;
     Table           = table;
     IsWeak          = isWeak;
     Condition       = searchCondition;
     CanConvertApply = true;
 }
示例#6
0
文件: Join.cs 项目: forki/bars2db
        internal Join(EJoinType joinType, ISqlTableSource table, string alias, bool isWeak, IReadOnlyList <IJoin> joins)
        {
            JoinedTable = new JoinedTable(joinType, table, alias, isWeak);

            if (joins != null && joins.Count > 0)
            {
                for (var index = 0; index < joins.Count; index++)
                {
                    JoinedTable.Table.Joins.AddLast(joins[index].JoinedTable);
                }
            }
        }
示例#7
0
        /// <summary>
        /// 添加关联查询
        /// </summary>
        /// <param name="queryTable">关联表</param>
        /// <param name="joinWhere">关联条件</param>
        /// <param name="joinType">关联类型</param>
        /// <returns>ModalAdapter</returns>
        public ModalAdapter <T> Join(IQueryTable queryTable, WhereClip joinWhere, EJoinType joinType)
        {
            switch (joinType)
            {
            case EJoinType.Join:
                this._SelectSection.Join(queryTable, joinWhere);
                break;

            case EJoinType.LeftJoin:
                this._SelectSection.LeftJoin(queryTable, joinWhere);
                break;

            case EJoinType.RightJoin:
                this._SelectSection.RightJoin(queryTable, joinWhere);
                break;
            }
            this.JoinTables.Add(new JoinTable(queryTable, joinWhere, joinType));
            return(this);
        }
示例#8
0
 public abstract IJoin <T, TJoin> Join <TJoin>(Expression <Func <HzyTuple <T, TJoin>, bool> > ON, EJoinType _EJoinType = EJoinType.LEFT_JOIN);
示例#9
0
 public JoinedTable(EJoinType joinType, ISqlTableSource table, string alias, bool isWeak)
     : this(joinType, new TableSource(table, alias), isWeak)
 {
 }
示例#10
0
 public JoinedTable(EJoinType joinType, ITableSource table, bool isWeak)
     : this(joinType, table, isWeak, new SearchCondition())
 {
 }
示例#11
0
 /// <summary>
 /// 创建 Join 对象
 /// </summary>
 /// <param name="_LambdaExpression"></param>
 /// <param name="_Sql"></param>
 /// <param name="_EJoinType"></param>
 public void CreateJoin(LambdaExpression _LambdaExpression, SQL _Sql, EJoinType _EJoinType)
 {
     new JoinAnalysis().Create(_Sql, _LambdaExpression, _EJoinType, this);
 }
示例#12
0
 public abstract IJoin <T1, T2, TJoin> Join <TJoin>(Expression <Func <T1, T2, TJoin, bool> > ON, EJoinType _EJoinType = EJoinType.LEFT_JOIN);
示例#13
0
 public override IJoin <T, TJoin> Join <TJoin>(Expression <Func <HzyTuple <T, TJoin>, bool> > ON, EJoinType _EJoinType = EJoinType.LEFT_JOIN)
 {
     if (ON == null)
     {
         throw new DbFrameException(" Join 连接对象不能为 NULL !");
     }
     this.analysis.CreateJoin(ON, this.SqlCode, _EJoinType);
     return(new JoinAchieve <T, TJoin>(this.SqlCode, this.Ado, this.analysis));
 }
示例#14
0
        public override IJoin <T, TJoin> Join <TJoin>(Expression <Func <T, TJoin, bool> > ON, EJoinType _EJoinType = EJoinType.LEFT_JOIN)
        {
            if (ON == null)
            {
                throw new DbFrameException(" Join 连接对象不能为 NULL !");
            }
            //给表设置别名
            var _Param = ON.Parameters[0];
            var _Alias = DbSettings.KeywordHandle(_Param.Name);

            this.SqlCode.Code_FromTab.Append(" AS " + _Alias);
            this.SqlCode.Alias[_Alias] = _Param.Type.Name;
            this.SqlCode.IsAlias       = true;
            this.analysis.CreateJoin(ON, this.SqlCode, _EJoinType);
            return(new JoinAchieve <T, TJoin>(this.SqlCode, this.Ado, this.analysis));
        }
示例#15
0
 public JoinTable(IQueryTable joinQueryTable, string aliasName, WhereClip joinWhere, EJoinType joinType, params ExpressionClip[] queryCulumns)
     : this(joinQueryTable, joinWhere, joinType, queryCulumns)
 {
     this.AliasName = aliasName;
 }
示例#16
0
        /// <summary>
        /// 添加关联查询
        /// </summary>
        /// <param name="queryTable">关联表</param>
        /// <param name="joinTableAliasName">关联表别名</param>
        /// <param name="joinWhere">关联条件</param>
        /// <param name="joinType">关联类型</param>
        /// <returns>ModalAdapter</returns>
        public SearchHelper Join(IQueryTable queryTable, string joinTableAliasName, WhereClip joinWhere, EJoinType joinType)
        {
            switch (joinType)
            {
            case EJoinType.Join:
                this._SelectSection.Join(queryTable, joinTableAliasName, joinWhere);
                break;

            case EJoinType.LeftJoin:
                this._SelectSection.LeftJoin(queryTable, joinTableAliasName, joinWhere);
                break;

            case EJoinType.RightJoin:
                this._SelectSection.RightJoin(queryTable, joinTableAliasName, joinWhere);
                break;
            }
            this.JoinTables.Add(new JoinTable(queryTable, joinTableAliasName, joinWhere, joinType));
            return(this);
        }
示例#17
0
 public static JoinTable New(string table, EJoinType joinType)
 {
     return(new JoinTable(table, joinType));
 }
示例#18
0
 public JoinTable(string table, EJoinType joinType)
 {
     this.Table    = table;
     this.JoinType = joinType;
 }