通用查詢類封裝之Mongodb篇

　　查詢在應用程序中很重要，花樣也特別多，不同得業務需求需要不同的查詢條件，還要支持and、or ……事實上也確實如此，程序中有N多個查詢類，並且很可能其中有多個類查詢同一張表，所以特別想弄一個通用的查詢類。

　　前幾天也是因為討論有關查詢的問題，想到了一個點子覺得可行，最近就抓緊實現了一下來驗證想法的可行性……

　　思路：其實查詢類很簡單，無非就是你要查詢哪個字段—字段名稱（Key）、你想搜索的值—字段值（Value）、以及如何進行比較—查詢類型（QueryType），這是單個查詢條件（之后都叫做查詢因子，不知道合適不合適，也是突然間想起來的），如果是多個條件，弄了一個集合就是好了，問題就在於這些查詢因子之間的關系（and、or）……既然叫做查詢因子，這個集合我們不管他們之間的關系，只是簡單的查詢因子的集合，我們在弄一個字段來存儲他們之間的關系，這里暫時叫做邏輯表達式，例如：((a|b)&c)|((a&b&d)|e)，最后我就解析這個表達式就可以了，a、b、c、d、e只要在集合中找到具體的哪個查詢因子就可以了，就是這樣了。說通用查詢類有點慚愧，目前只是在Mongodb下弄了一個簡單的實現（重點是思路了，嘿嘿），因為項目上用的是Mongodb所以先實現的肯定是他了，其他的數據庫同理……

/// <summary>
/// 通用查詢類
/// </summary>
public class QueryModel
{
    /// <summary>
    /// 邏輯表達式
    /// </summary>
    public string FilterStr { get; set; }

    /// <summary>
    /// 查詢因子字典集合
    /// </summary>
    public Dictionary<string, QueryFactor> DCQueryFactor { get; set; }
}
/// <summary>
/// 查詢因子類
/// </summary>
public class QueryFactor
{
    /// <summary>
    /// 查詢字段的名稱
    /// </summary>
    public string Key { get; set; }

    /// <summary>
    /// 查詢字段的值
    /// </summary>
    public object Value { get; set; }

    /// <summary>
    /// 比較類型,支持的類型有：
    /// eq：等於，
    /// ne：不等於
    /// gt：大於
    /// lt：小於
    /// gte：大於等於
    /// lte：小於等於
    /// in：范圍查詢
    /// like：模糊查詢
    /// </summary>
    public string QueryType { get; set; } = "eq";
}

　　這個倒是沒有什么，關鍵是這個所謂的邏輯表達式不知道如何解析，真是廢了半天勁兒……什么類似的堆棧實現計算器、逆波蘭式等弄了一大堆，感覺都沒有用上，最后對一個例子做了一些改進，才完成的……

public class QueryModelForMongodb
{
    private Dictionary<string, FilterDefinition<BsonDocument>> ParenthesesExpressionDic = new Dictionary<string, FilterDefinition<BsonDocument>>();

    /// <summary>
    /// 入口方法
    /// </summary>
    /// <param name="logicalExpression">邏輯表達式</param>
    /// <param name="queryModel">查詢類</param>
    /// <returns></returns>
    public FilterDefinition<BsonDocument> ToMongodbFilter(string logicalExpression, QueryModel queryModel)
    {
        int startIndex = logicalExpression.LastIndexOf("(");
        if (startIndex != -1)
        {
            //  截取括號中的表達式
            int endIndex = logicalExpression.IndexOf(")", startIndex);
            int len = endIndex - startIndex - 1;
            string simpleExpress = logicalExpression.Substring(startIndex + 1, len);
            //  處理簡單的表達式並結果保存到字典中
            string tempGuid = Guid.NewGuid().ToString();
            FilterDefinition<BsonDocument> fd1 = ToMongodbFilterSimpleLogicalExpression(simpleExpress, queryModel);
            ParenthesesExpressionDic.Add(tempGuid, fd1);
            //  繼續處理剩余表達式
            string leftStr = logicalExpression.Substring(0, startIndex);
            string rightStr = logicalExpression.Substring(endIndex + 1);
            return ToMongodbFilter($"{leftStr}{tempGuid}{rightStr}", queryModel);
        }
        return ToMongodbFilterSimpleLogicalExpression(logicalExpression, queryModel);
    }

    /// <summary>
    /// 處理簡單的邏輯表達式（不包含圓括號）
    /// </summary>
    /// <param name="logicalExpression"></param>
    /// <param name="queryModel"></param>
    /// <returns></returns>
    private FilterDefinition<BsonDocument> ToMongodbFilterSimpleLogicalExpression(string logicalExpression, QueryModel queryModel)
    {
        //  1、篩選出操作符：&、|
        Queue<char> qOperator = new Queue<char>();
        //Regex regexOperator = new Regex("[&|]");
        //foreach (Match item in regexOperator.Matches(logicalExpression))
        //{
        //    qOperator.Enqueue(item.Value);
        //}
        foreach (char c in logicalExpression)
        {
            if (c == '&' || c == '|')
            {
                qOperator.Enqueue(c);
            }
        }
        //  2、篩選出所有的變量
        Queue<string> qVariable = new Queue<string>();
        string[] tempVariables = logicalExpression.Replace("&", ",").Replace("|", ",").Split(",");
        foreach (string v in tempVariables)
        {
            qVariable.Enqueue(v);
        }
        //  3、返回結果組裝
        FilterDefinition<BsonDocument> filter = null;
        if (qVariable.Count >= 1)
        {
            string tempV = qVariable.Dequeue();
            filter = ParenthesesExpressionDic.ContainsKey(tempV) ? ParenthesesExpressionDic[tempV] : QueryFactorToMogodbFilter(queryModel.DCQueryFactor[tempV]);
            while (qVariable.Count > 0)
            {
                string rightV = qVariable.Dequeue();
                var tempFilter = ParenthesesExpressionDic.ContainsKey(rightV) ? ParenthesesExpressionDic[rightV] : QueryFactorToMogodbFilter(queryModel.DCQueryFactor[rightV]);
                char tempOperator = qOperator.Dequeue();
                switch (tempOperator)
                {
                    case '&':
                        {
                            filter = filter & tempFilter;
                            break;
                        }
                    case '|':
                        {
                            filter = filter | tempFilter;
                            break;
                        }
                }
            }
            filter = Builders<BsonDocument>.Filter.Empty & (filter);
        }
        return filter ?? Builders<BsonDocument>.Filter.Empty;
    }

    /// <summary>
    /// 將查詢因子轉換成Mongodb的Filter
    /// </summary>
    /// <param name="queryFactor"></param>
    /// <returns></returns>
    private FilterDefinition<BsonDocument> QueryFactorToMogodbFilter(QueryFactor queryFactor)
    {
        /// <summary>
        /// 比較類型,支持的類型有：
        /// eq：等於，
        /// ne：不等於
        /// gt：大於
        /// lt：小於
        /// gte：大於等於
        /// lte：小於等於
        /// in：范圍查詢
        /// like：模糊查詢
        /// </summary>
        if (queryFactor == null) return Builders<BsonDocument>.Filter.Empty;
        FilterDefinition<BsonDocument> filter = null;
        switch (queryFactor.QueryType.ToLower())
        {
            case "ne":
                {
                    filter = Builders<BsonDocument>.Filter.Ne(queryFactor.Key, queryFactor.Value);
                    break;
                }
            case "gt":
                {
                    filter = Builders<BsonDocument>.Filter.Gt(queryFactor.Key, queryFactor.Value);
                    break;
                }
            case "gte":
                {
                    filter = Builders<BsonDocument>.Filter.Gte(queryFactor.Key, queryFactor.Value);
                    break;
                }
            case "lt":
                {
                    filter = Builders<BsonDocument>.Filter.Lt(queryFactor.Key, queryFactor.Value);
                    break;
                }
            case "lte":
                {
                    filter = Builders<BsonDocument>.Filter.Lte(queryFactor.Key, queryFactor.Value);
                    break;
                }
            case "in":
                {
                    filter = Builders<BsonDocument>.Filter.In(queryFactor.Key, JsonConvert.DeserializeObject<IList<String>>(JsonConvert.SerializeObject(queryFactor.Value)));
                    break;
                }
            case "like":
                {
                    //filter = filter & Builders<BsonDocument>.Filter.Regex(queryFactor.Key, new BsonRegularExpression(new Regex(Regex.Escape(queryFactor.Value.ToString()), RegexOptions.IgnoreCase)));
                    filter = Builders<BsonDocument>.Filter.Regex(queryFactor.Key, new BsonRegularExpression(new Regex(".*" + Regex.Escape(queryFactor.Value.ToString()) + ".*", RegexOptions.IgnoreCase)));
                    break;
                }
            case "eq":
            default:
                {
                    filter = Builders<BsonDocument>.Filter.Eq(queryFactor.Key, queryFactor.Value);
                    break;
                }
        }
        return filter ?? Builders<BsonDocument>.Filter.Empty;
    }
}

　　具體的實現思路是這樣的，就是逐個的消除表達式中的括號，直到表達式中不包含圓括號，就用上面的表達式來舉個例子，((a|b)&c)|((a&b&d)|e)

　　1、找到最后一個“(”，之后尋找與之匹配的“)”，處理這對圓括號中的簡單表達式，這里是a&b&d，處理完之后將結果放在一個字典之中<guid,filter>，記作<1,filter1>，之后字符串變為((a|b)&c)|(1|e)

　　2、參照1的順序再次處理表達式((a|b)&c)|(1|e)，這次處理1|e，字典中添加一項<2,filter2>，字符串變為((a|b)&c)|2

　　3、處理a|b，字典中添加一項<3,filter3>，字符串變為(3&c)|2

　　4、處理3&c，字典中添加一項<4,filter4>，字符串變為4|2

　　5、至此，圓括號已不再，只是簡單的表達式，這就簡單了

　　結束了，歡迎大家提供更好的辦法來處理這個問題，共同努力，哈哈！