通用查詢類封裝之Mongodb篇

阿新 • • 發佈：2019-01-02

　　查詢在應用程式中很重要，花樣也特別多，不同得業務需求需要不同的查詢條件，還要支援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;
    }
}

Mongodb實現

　　具體的實現思路是這樣的，就是逐個的消除表示式中的括號，直到表示式中不包含圓括號，就用上面的表示式來舉個例子，((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、至此，圓括號已不再，只是簡單的表示式，這就簡單了

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

通用查詢類封裝之Mongodb篇

通用查詢類封裝之Mongodb篇

工具類封裝之--BaseController

mysql數據庫-查詢優化之索引篇

《 mongodb 學習》之安裝篇

MongoDB入門系列之科普篇

PHP之Model類封裝(PDO)

MongoDB操作類封裝

MongoDB上手之操作篇

python中的面向物件學習以及類的封裝（這篇文章初學者一定要好好看）

通用JS工具類封裝——網路資料請求功能、獲取服務端介面 url、引數功能

發散逆向思維之查詢類列表測試範圍的思考

muduo_base程式碼剖析之日誌類封裝

安卓專案實戰之好用的SharedPreferences工具類封裝

資料結構之排序篇——插入排序 //無序查詢有序位置，邊比較邊移動，有哨兵

使用Mybatis實現簡單和複雜查詢----通用工具類

資料結構之排序篇——插入排序 //無序查詢有序位置，邊比較邊移動，有哨兵

安卓專案實戰之通用的PopupWindow封裝和使用

PHP之Model類封裝

MongoDB初探及JAVA工具類封裝

mongodb與spring整合及基礎dao類封裝

通用查詢類封裝之Mongodb篇

相關推薦