DMSLinq表达式框架实现(五) DMSTableExpression实现

 /// <summary>
    /// 表的表达式处理实现
    /// </summary>
    public class DMSTableExpression : DMSExpressionVisitor, IDMSTableExpressionParser
    {
        /// <summary>
        /// 
        /// </summary>
        public IDMSDbProvider DbProvider
        {
            get;
            set;
        }
        private List<SingleTableExpression> SingleExpression
        {
            get;
            set;
        }
        /// <summary>
        /// 
        /// </summary>
        public Expression DMSExpression { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public Dictionary<string, string> KeyValue { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public Dictionary<string, string> TableNameAlias { get; set; }

        private StringBuilder _ResultSql = new StringBuilder();
        /// <summary>
        /// 
        /// </summary>
        /// <param name="keyTable"></param>
        /// <returns></returns>
        public string AnalyzeExpression(ref Dictionary<string, string> keyTable)
        {
            this._ResultSql = new StringBuilder();
            if (DMSExpression != null)
            {
                this.Visit(DMSExpression);
            }
            keyTable = this.KeyValue;

            if (keyTable.Count > 0)
            {
                string lastKey = keyTable.Last().Key;
                if (TableNameAlias.ContainsKey(lastKey))
                {
                    keyTable[lastKey] = TableNameAlias[lastKey];
                }
            }
            return this._ResultSql.ToString();
        }
        private bool IsAs = true;
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public string AnalyzeExpression()
        {
            this._ResultSql = new StringBuilder();
            this.IsAs = false;
            if (DMSExpression != null)
            {
                this.Visit(DMSExpression);
            }
            return this._ResultSql.ToString();
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="dms"></param>
        /// <param name="type"></param>
        public void Append(IDMSBase dms, Type type)
        {
            if (this.KeyValue == null)
                KeyValue = new Dictionary<string, string>();
            if (SingleExpression == null)
                SingleExpression = new List<SingleTableExpression>();
            if (TableNameAlias == null)
                TableNameAlias = new Dictionary<string, string>();

            if (typeof(DMSWhere) == type
               || typeof(DMSOn) == type
               || typeof(DMSSelect) == type)
            {
                if (SingleExpression.Find(q => q.Key == dms.CurrentType && q.TableType == type) != null)
                {
                    return;
                }
                SingleExpression.Add(new SingleTableExpression() { Key = dms.CurrentType, TableType = type });
            }
            if (!type.IsGenericType && type.IsClass)
            {
                NewArrayExpression newArrayExpression = Expression.NewArrayInit(typeof(object), Expression.New(type));
                if (this.DMSExpression != null)
                {
                    NewArrayExpression newArrayExpression2 = this.DMSExpression as NewArrayExpression;
                    IEnumerable<Expression> initializers2 = newArrayExpression2.Expressions.Concat(newArrayExpression.Expressions);
                    newArrayExpression = Expression.NewArrayInit(typeof(object), initializers2);
                    this.DMSExpression = dms.ModifyExpression(newArrayExpression);
                }
                else
                {
                    this.DMSExpression = dms.ModifyExpression(newArrayExpression);
                }
            }
            else
            {
                NewArrayExpression newArrayExpression = Expression.NewArrayInit(typeof(object), Expression.Constant(type.ToString()));
                if (this.DMSExpression != null)
                {
                    Expression exp = this.DMSExpression;
                    NewArrayExpression newArrayExpression2 = exp as NewArrayExpression;
                    if (newArrayExpression2 != null)
                    {
                        IEnumerable<Expression> initializers2 = newArrayExpression2.Expressions.Concat(newArrayExpression.Expressions);
                        newArrayExpression = Expression.NewArrayInit(typeof(object), initializers2);
                        this.DMSExpression = dms.ModifyExpression(newArrayExpression);
                    }
                }
                else
                {
                    this.DMSExpression = dms.ModifyExpression(newArrayExpression);
                }
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="nex"></param>
        /// <returns></returns>
        protected override NewExpression VisitNew(NewExpression nex)
        {
            Type type = nex.Type;

            if (!type.IsGenericType && type.IsClass)
            {
                AdjustConstant(type);
            }
            #region MyRegion
            //else
            //{
            //    foreach (Expression exp in nex.Arguments)
            //    {
            //        this.Visit(exp);
            //        if (!this._ResultSql.ToString().EndsWith(","))
            //        {
            //            this._ResultSql.Append(",");
            //        }
            //    }
            //    if (this._ResultSql.ToString().EndsWith(","))
            //    {
            //        this._ResultSql.Remove(this._ResultSql.Length - 1, 1);
            //    }
            //    this._ResultSql.Append(" ");
            //} 
            #endregion
            return nex;
        }
        private void AdjustConstant(Type type)
        {
            string text = string.Empty;
            bool IsEntity = false;
            //是否是IEntity
            if (type.GetInterface(typeof(IEntity).FullName, false) != null)
            {
                if (!this.KeyValue.ContainsKey(type.ToString()))
                {
                    string AliasName = "t" + this.KeyValue.Count;
                    if (TableNameAlias.ContainsKey(type.ToString()))
                    {
                        AliasName = TableNameAlias[type.ToString()];
                    }
                    this.KeyValue.Add(type.ToString(), AliasName);
                }
                text = type.GetEntityName();
                if (string.IsNullOrEmpty(text)) {
                    text = type.Name;
                }
                IsEntity = true;
            }
            else if (type.GetInterface(typeof(IDMSParser).FullName, false) != null)//是否是IDMSParser
            {
                text = type.GetDMSName();
                if (type == typeof(DMSSelect))
                {
                    text = "";
                }
            }
            else
            {
                if (!this.KeyValue.ContainsKey(type.ToString()))
                {
                    string AliasName = "t" + this.KeyValue.Count;
                    if (TableNameAlias.ContainsKey(type.ToString()))
                    {
                        AliasName = TableNameAlias[type.ToString()];
                    }
                    this.KeyValue.Add(type.ToString(), AliasName);
                }
            }
            if (!string.IsNullOrEmpty(text) && this.DbProvider != null && type.GetInterface(typeof(IDMSParser).FullName, false) == null)
            {
                text = this.DbProvider.BuildTableName(text);
            }
            this._ResultSql.Append(text);
            if (IsEntity && IsAs)
            {
                this._ResultSql.Append(" AS ");
                text = this.KeyValue[type.ToString()];
                if (!string.IsNullOrEmpty(text) && this.DbProvider != null)
                {
                    text = this.DbProvider.BuildTableName(text);
                }
                this._ResultSql.Append(text);
            }
            this._ResultSql.Append(" ");
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="c"></param>
        /// <returns></returns>
        protected override Expression VisitConstant(ConstantExpression c)
        {

            if (c.Value != null)
            {
                if (c.Type.IsArray)
                {
                    Array array = c.Value as Array;
                    foreach (object current in array)
                    {
                        if (current != null)
                        {
                            Type type = current.GetType();
                            if (type == typeof(string))
                            {
                                if (!this.KeyValue.ContainsKey(current.ToString()))
                                {
                                    string AliasName = "t" + this.KeyValue.Count;
                                    if (this.TableNameAlias.ContainsKey(current.ToString()))
                                    {
                                        AliasName = this.TableNameAlias[current.ToString()];
                                    }
                                    this.KeyValue.Add(current.ToString(), AliasName);
                                }
                            }
                            else
                            {
                                AdjustConstant(type);
                            }
                        }
                    }
                }
                else
                {
                    if (!this.KeyValue.ContainsKey(c.Value.ToString()))
                    {
                        this.KeyValue.Add(c.Value.ToString(), "t" + this.KeyValue.Count);
                    }
                }
            }
            return base.VisitConstant(c);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="na"></param>
        /// <returns></returns>
        protected override Expression VisitNewArray(NewArrayExpression na)
        {
            foreach (Expression current in na.Expressions)
            {
                this.Visit(current);
                this._ResultSql.Append(" ");
            }
            return na;
        }
    }