DataColumnQueryAssist - 字段查询的辅助配置

2017-02-19 10:34:35 访问(1685) 赞(0) 踩(0)

using System;
using System.Collections.Generic;
using System.Text;
using SlowX.Core.ICoreClasses;
using SlowX.Core.Classes;

using System.Reflection;

namespace SlowX.Core.CoreClasses
{
    /// <summary>
    /// 字段查询的辅助配置 + 
    /// </summary>
    [Serializable]
    public class DataColumnQueryAssist
        :
        IDataColumnQueryAssist
    {
        /// <summary>
        /// 小写的属性配置
        /// </summary>
        public readonly static DataColumnQueryAssist dataColumnQueryAssistEmStringCaseLower 
            = 
            GetDataColumnQueryAssistEmStringCaseLower();

        /// <summary>
        /// 小写的属性配置
        /// </summary>
        public readonly static DataColumnQueryAssist 
            dataColumnQueryAssistEmStringCaseUpper
            =
            GetDataColumnQueryAssistEmStringCaseUpper();

        /// <summary>
        /// 左边 前后填充,
        /// </summary>
        public readonly static DataColumnQueryAssist 
            dataColumnQueryAssistVarCharPrePostFillChar
            =
            GetDataColumnQueryAssistPrePostFillChar(true);


        /// <summary>
        /// 左边 前后填充,
        /// </summary>
        public readonly static DataColumnQueryAssist dataColumnQueryAssistNotVarCharPrePostFillChar
            =
            GetDataColumnQueryAssistPrePostFillChar(false);


        /// <summary>
        /// 树结构的辅助
        /// </summary>
        public readonly static DataColumnQueryAssist 
            dataColumnQueryAssistTreeLike
            =
            GetDataColumnQueryAssistTreeLike();

        /// <summary>
        /// 小写的属性配置
        /// </summary>
        /// <returns></returns>
        public static DataColumnQueryAssist GetDataColumnQueryAssistEmStringCaseLower()
        {
            DataColumnQueryAssist theResult 
                = 
                new DataColumnQueryAssist();

            theResult.emStringCaseValue 
                = 
                Enums.StringCase.EmStringCase.小写;

            return theResult;

        }

        /// <summary>
        /// 大写的属性配置
        /// </summary>
        /// <returns></returns>
        public static DataColumnQueryAssist GetDataColumnQueryAssistEmStringCaseUpper()
        {
            DataColumnQueryAssist theResult 
                = 
                new DataColumnQueryAssist();

            theResult.emStringCaseValue 
                = 
                Enums.StringCase.EmStringCase.大写;

            return theResult;

        }


        /// <summary>
        /// 树结构的辅助
        /// </summary>
        /// <returns></returns>
        public static DataColumnQueryAssist GetDataColumnQueryAssistTreeLike()
        {
            DataColumnQueryAssist theResult = new DataColumnQueryAssist();

            theResult.rightAddBaseSqlFunction
                (
                    BaseSqlFunction.baseSqlFunctionConvertToVarchar
                );

            theResult.rightAddBaseSqlFunction
                (
                    StringLinkSqlFunction.stringLinkSqlFunctionTreeLink
                );

            return theResult;
        }


        /// <summary>
        /// 树结构的辅助
        /// </summary>
        /// <returns></returns>
        public static DataColumnQueryAssist GetDataColumnQueryAssistPrePostFillChar
            (
                bool isVarChar
            )
        {
            DataColumnQueryAssist theResult = new DataColumnQueryAssist();

            if(!isVarChar)
                theResult.leftAddBaseSqlFunction(BaseSqlFunction.baseSqlFunctionConvertToVarchar);

            theResult.leftAddBaseSqlFunction
                (
                    StringLinkSqlFunction.stringLinkSqlFunctionTreeLink
                );

            return theResult;
        }

        #region 

        /// <summary>
        /// Count的属性配置
        /// </summary>
        public readonly static DataColumnQueryAssist dataColumnQueryAssistCount
            =
            GetDataColumnQueryAssistCount();


        /// <summary>
        /// Count方法的配置
        /// </summary>
        /// <returns></returns>
        public static DataColumnQueryAssist GetDataColumnQueryAssistCount()
        {
            DataColumnQueryAssist theResult = new DataColumnQueryAssist();

            theResult.leftAddBaseSqlFunction
                (
                    new BaseSqlFunction(SlowX.Core.Enums.SqlFunction.EmSqlFunction.Count)
                );

            return theResult;
        }

        #endregion

        public static DataColumnQueryAssist DataColumnQueryAssistCreateByEmSqlCommonFn
            (
                SlowX.Core.Enums.SqlCommonFn.EmSqlCommonFn emFn
            )
        {
            DataColumnQueryAssist theResult = new DataColumnQueryAssist();

            BaseSqlFunction bf = null;
            switch (emFn)
            {
                case SlowX.Core.Enums.SqlCommonFn.EmSqlCommonFn._Count:
                    bf = new BaseSqlFunction(SlowX.Core.Enums.SqlFunction.EmSqlFunction.Count);
                    break;
                case SlowX.Core.Enums.SqlCommonFn.EmSqlCommonFn._Avg:
                    bf = new BaseSqlFunction(SlowX.Core.Enums.SqlFunction.EmSqlFunction.Avg);
                    break;
                case SlowX.Core.Enums.SqlCommonFn.EmSqlCommonFn._Distinct:
                    bf = new BaseSqlFunction(SlowX.Core.Enums.SqlFunction.EmSqlFunction.Distinct);
                    break;
                case SlowX.Core.Enums.SqlCommonFn.EmSqlCommonFn._Max:
                    bf = new BaseSqlFunction(SlowX.Core.Enums.SqlFunction.EmSqlFunction.Max);
                    break;
                case SlowX.Core.Enums.SqlCommonFn.EmSqlCommonFn._Min:
                    bf = new BaseSqlFunction(SlowX.Core.Enums.SqlFunction.EmSqlFunction.Min);
                    break;
                case SlowX.Core.Enums.SqlCommonFn.EmSqlCommonFn._Sum:
                    bf = new BaseSqlFunction(SlowX.Core.Enums.SqlFunction.EmSqlFunction.Sum);
                    break;
                case SlowX.Core.Enums.SqlCommonFn.EmSqlCommonFn.无:
                default:
                    break;
            }

            if (bf != null)
            {
                theResult.leftAddBaseSqlFunction(bf);

            }
         
            return theResult;
        }


        /// <summary>
        /// 字段查询的辅助配置
        /// </summary>
        public DataColumnQueryAssist() 
        { 
        
        }


        #region ParameterName ~ 参数名称

        /// <summary>
        ///  参数名称
        /// </summary>
        protected string m_ParameterName = "";

        /// <summary>
        ///  参数名称
        /// </summary>
        public string ParameterName
        {
            get
            {
                return m_ParameterName;
            }
            set
            {
                m_ParameterName = value;
            }
        }

        #endregion ParameterName ~   参数名称

        #region linkSymbolReverse (查询反转)

        /// <summary>
        /// 查询反转
        /// </summary>
        protected bool m_linkSymbolReverse = false;

        /// <summary>
        /// 查询反转
        /// </summary>
        public bool linkSymbolReverse
        {
            get
            {
                return m_linkSymbolReverse;
            }
            set
            {
                m_linkSymbolReverse = value;
            }
        }

        #endregion linkSymbolReverse (查询反转)

        /// <summary>
        /// SQL方法
        /// </summary>
        protected List<BaseSqlFunction> m_leftListBaseSqlFunction 
            = 
            new List<BaseSqlFunction>();

        /// <summary>
        /// 获得SQL方法
        /// </summary>
        /// <returns></returns>
        public List<BaseSqlFunction> GetLeftListBaseSqlFunction()
        {
            return m_leftListBaseSqlFunction;
        }

        /// <summary>
        /// SQL方法
        /// </summary>
        protected List<BaseSqlFunction> m_rightListBaseSqlFunction
            = new List<BaseSqlFunction>();

        /// <summary>
        /// 获得SQL方法
        /// </summary>
        /// <returns></returns>
        public List<BaseSqlFunction> GetRightListBaseSqlFunction()
        {
            return m_rightListBaseSqlFunction;
        }


        /// <summary>
        /// 大小写
        /// </summary>
        public SlowX.Core.Enums.StringCase.EmStringCase emStringCaseValue
        {
            get
            {
                foreach (BaseSqlFunction item in m_leftListBaseSqlFunction)
                {
                    switch (item.emSqlFunctionValue)
                    {
                        case SlowX.Core.Enums.SqlFunction.EmSqlFunction.转换成大写:
                            return SlowX.Core.Enums.StringCase.EmStringCase.大写;
                        case SlowX.Core.Enums.SqlFunction.EmSqlFunction.转换成小写:
                            return SlowX.Core.Enums.StringCase.EmStringCase.小写;
                        default:
                            break;
                    }
                }

                return SlowX.Core.Enums.StringCase.EmStringCase.不设置;
            }
            set
            {
                BaseSqlFunction itemFind = null;

                foreach (BaseSqlFunction item in m_leftListBaseSqlFunction)
                {
                    if (item.emSqlFunctionValue == SlowX.Core.Enums.SqlFunction.EmSqlFunction.转换成小写
                        || item.emSqlFunctionValue == SlowX.Core.Enums.SqlFunction.EmSqlFunction.转换成大写)
                    {
                        itemFind = item;
                        break;
                    }
                }

                if (itemFind == null)
                {
                    switch (value)
                    {
                        case SlowX.Core.Enums.StringCase.EmStringCase.不设置:
                            break;
                        case SlowX.Core.Enums.StringCase.EmStringCase.大写:
                            itemFind = new BaseSqlFunction(SlowX.Core.Enums.SqlFunction.EmSqlFunction.转换成大写);
                            m_leftListBaseSqlFunction.Add(itemFind);
                            break;
                        case SlowX.Core.Enums.StringCase.EmStringCase.小写:
                            itemFind = new BaseSqlFunction(SlowX.Core.Enums.SqlFunction.EmSqlFunction.转换成小写);
                            m_leftListBaseSqlFunction.Add(itemFind);
                            break;
                        default:

                            throw new Exception
                                (
                                    "方法："
                                    + MethodBase.GetCurrentMethod().ReflectedType.FullName
                                    + " "
                                    + MethodBase.GetCurrentMethod().ToString()
                                    + " 发生异常："
                                    + "枚举（"
                                    + value.GetType().FullName
                                    + "."
                                    + value.ToString()
                                    + "）未知，对应的代码尚未实现。"
                                );
                    }
                }
                else
                {
                    switch (value)
                    {
                        case SlowX.Core.Enums.StringCase.EmStringCase.不设置:
                            m_leftListBaseSqlFunction.Remove(itemFind);
                            break;
                        case SlowX.Core.Enums.StringCase.EmStringCase.大写:
                            itemFind.SetEmSqlFunctionByStringCase(false);
                            break;
                        case SlowX.Core.Enums.StringCase.EmStringCase.小写:
                            itemFind.SetEmSqlFunctionByStringCase(true);
                            break;
                        default:

                            throw new Exception
                                (
                                    "方法："
                                    + MethodBase.GetCurrentMethod().ReflectedType.FullName
                                    + " "
                                    + MethodBase.GetCurrentMethod().ToString()
                                    + " 发生异常："
                                    + "枚举（"
                                    + value.GetType().FullName
                                    + "."
                                    + value.ToString()
                                    + "）未知，对应的代码尚未实现。"
                                );

                            
                    }
                }
            }
        }

        /// <summary>
        /// SQL方法添加
        /// </summary>
        /// <param name="_BaseSqlFunctionValue"></param>
        public void leftAddBaseSqlFunction(BaseSqlFunction _BaseSqlFunctionValue)
        {
            m_leftListBaseSqlFunction.Add(_BaseSqlFunctionValue);
        }

        /// <summary>
        /// SQL方法添加
        /// </summary>
        /// <param name="idx"></param>
        /// <param name="_BaseSqlFunctionValue"></param>
        public void leftInsertBaseSqlFunction(int idx, BaseSqlFunction _BaseSqlFunctionValue)
        {
            if (idx <= 0)
            {
                m_leftListBaseSqlFunction.Insert(0, _BaseSqlFunctionValue);
            }
            else
            {
                if (idx >= m_leftListBaseSqlFunction.Count)
                    m_leftListBaseSqlFunction.Add(_BaseSqlFunctionValue);
                else
                    m_leftListBaseSqlFunction.Insert(idx, _BaseSqlFunctionValue);
            }
        }



        /// <summary>
        /// SQL方法添加
        /// </summary>
        /// <param name="_BaseSqlFunctionValue"></param>
        public void rightAddBaseSqlFunction(BaseSqlFunction _BaseSqlFunctionValue)
        {
            m_rightListBaseSqlFunction.Add(_BaseSqlFunctionValue);
        }

        /// <summary>
        /// SQL方法添加
        /// </summary>
        /// <param name="idx"></param>
        /// <param name="_BaseSqlFunctionValue"></param>
        public void rightInsertBaseSqlFunction(int idx, BaseSqlFunction _BaseSqlFunctionValue)
        {
            if (idx <= 0)
            {
                m_rightListBaseSqlFunction.Insert(0, _BaseSqlFunctionValue);
            }
            else
            {
                if (idx >= m_rightListBaseSqlFunction.Count)
                    m_rightListBaseSqlFunction.Add(_BaseSqlFunctionValue);
                else
                    m_rightListBaseSqlFunction.Insert(idx, _BaseSqlFunctionValue);
            }
        }
    }
}