1. 程式人生 > >Monogdb查詢分析

Monogdb查詢分析

一、輸出查詢過程:

db.getCollection('multobj').find({}).explain("executionStats")

二、對queryPlanner分析

2.1 queryPlanner: queryPlanner的返回

    queryPlanner.namespace:該值返回的是該query所查詢的表

    queryPlanner.indexFilterSet:針對該query是否有indexfilter

    queryPlanner.winningPlan:查詢優化器針對該query所返回的最優執行計劃的詳細內容。

    queryPlanner.winningPlan.stage:最優執行計劃的stage,這裡返回是FETCH,可以理解為
    通過返回的index位置去檢索具體的文件(stage有數個模式,將在後文中進行詳解)。

    queryPlanner.winningPlan.inputStage:用來描述子stage,並且為其父stage提供文件和索引關鍵字。

    queryPlanner.winningPlan.stage的child stage,此處是IXSCAN,表示進行的是index scanning。

    queryPlanner.winningPlan.keyPattern:所掃描的index內容,此處是did:1,status:1,modify_time: -1與scid : 1

    queryPlanner.winningPlan.indexName:winning plan所選用的index。

    queryPlanner.winningPlan.isMultiKey是否是Multikey,此處返回是false,如果索引建立在array上,此處將是true。

    queryPlanner.winningPlan.direction:此query的查詢順序,此處是forward,如果用了.sort({modify_time:-1})
    將顯示backward。

    queryPlanner.winningPlan.indexBounds:winningplan所掃描的索引範圍,如果沒有制定範圍就是[MaxKey, MinKey],
    這主要是直接定位到mongodb的chunck中去查詢資料,加快資料讀取。

    queryPlanner.rejectedPlans:其他執行計劃(非最優而被查詢優化器reject的)的詳細返回,其中具體資訊與
    winningPlan的返回中意義相同,故不在此贅述。
    

2.2 對executionStats返回逐層分析

    第一層,executionTimeMillis

    最為直觀explain返回值是executionTimeMillis值,指的是我們這條語句的執行時間,這個值當然是希望越少越好。

    其中有3個executionTimeMillis,分別是:

    executionStats.executionTimeMillis

    該query的整體查詢時間。

    executionStats.executionStages.executionTimeMillisEstimate

    該查詢根據index去檢索document獲得2001條資料的時間。

    executionStats.executionStages.inputStage.executionTimeMillisEstimate

    該查詢掃描2001行index所用時間。

    第二層,index與document掃描數與查詢返回條目數

    這個主要討論3個返回項,nReturned、totalKeysExamined、totalDocsExamined,分別代表該條查詢返回的條目、
    索引掃描條目、文件掃描條目。

    這些都是直觀地影響到executionTimeMillis,我們需要掃描的越少速度越快。

    對於一個查詢,我們最理想的狀態是:

    nReturned=totalKeysExamined=totalDocsExamined

    第三層,stage狀態分析

    那麼又是什麼影響到了totalKeysExamined和totalDocsExamined?是stage的型別。型別列舉如下:

    COLLSCAN:全表掃描

    IXSCAN:索引掃描

    FETCH:根據索引去檢索指定document

    SHARD_MERGE:將各個分片返回資料進行merge

    SORT:表明在記憶體中進行了排序

    LIMIT:使用limit限制返回數

    SKIP:使用skip進行跳過

    IDHACK:針對_id進行查詢

    SHARDING_FILTER:通過mongos對分片資料進行查詢

    COUNT:利用db.coll.explain().count()之類進行count運算

    COUNTSCAN:count不使用Index進行count時的stage返回

    COUNT_SCAN:count使用了Index進行count時的stage返回

    SUBPLA:未使用到索引的$or查詢的stage返回

    TEXT:使用全文索引進行查詢時候的stage返回

    PROJECTION:限定返回欄位時候stage的返回

    對於普通查詢,我希望看到stage的組合(查詢的時候儘可能用上索引):

    Fetch+IDHACK

    Fetch+ixscan

    Limit+(Fetch+ixscan)

    PROJECTION+ixscan

    SHARDING_FITER+ixscan

    COUNT_SCAN

    不希望看到包含如下的stage:

    COLLSCAN(全表掃描),SORT(使用sort但是無index),不合理的SKIP,SUBPLA(未用到index的$or),
    COUNTSCAN(不使用index進行count)
轉載地址:https://www.cnblogs.com/c-abc/p/6023824.html

三、我的查詢分析文字

{
    "queryPlanner" : {
        "plannerVersion" : 1,    #版本
        "namespace" : "ifaas_data.multobj",  #庫名稱,表名稱
        "indexFilterSet" : false,  #針對該query是否有indexfilter
        "parsedQuery" : {     # 解析後的查詢條件
            "$and" : [ 
                {
                    "$or" : [ 
                        {
                            "targetType" : {
                                "$eq" : "face"
                            }
                        }, 
                        {
                            "targetType" : {
                                "$eq" : "body"
                            }
                        }
                    ]
                }, 
                {
                    "sourceId" : {
                        "$eq" : "130"
                    }
                }, 
                {
                    "sourceType" : {
                        "$eq" : "zipFile"
                    }
                }, 
                {
                    "time" : {
                        "$lte" : ISODate("2018-12-29T03:56:00.000Z")
                    }
                }, 
                {
                    "time" : {
                        "$gte" : ISODate("2018-12-26T00:00:00.000Z")
                    }
                }
            ]
        },
        "winningPlan" : {   #查詢優化器針對該query所返回的最優執行計劃的詳細內容。
            "stage" : "SKIP",  #最優執行計劃的stage,這裡返回是FETCH,可以理解為通過返回的index位置去檢索具體的文件(stage有數個模式,將在後文中進行詳解)。
            "skipAmount" : 0,
            "inputStage" : {   #用來描述子stage,並且為其父stage提供文件和索引關鍵字。
                "stage" : "SORT",
                "sortPattern" : {
                    "time" : -1.0
                },
                "limitAmount" : 200,
                "inputStage" : {  #用來描述子stage,並且為其父stage提供文件和索引關鍵字。
                    "stage" : "SORT_KEY_GENERATOR",
                    "inputStage" : {
                        "stage" : "FETCH",
                        "filter" : {
                            "$and" : [ 
                                {
                                    "$or" : [ 
                                        {
                                            "targetType" : {
                                                "$eq" : "face"
                                            }
                                        }, 
                                        {
                                            "targetType" : {
                                                "$eq" : "body"
                                            }
                                        }
                                    ]
                                }, 
                                {
                                    "sourceType" : {
                                        "$eq" : "zipFile"
                                    }
                                }, 
                                {
                                    "time" : {
                                        "$lte" : ISODate("2018-12-29T03:56:00.000Z")
                                    }
                                }, 
                                {
                                    "time" : {
                                        "$gte" : ISODate("2018-12-26T00:00:00.000Z")
                                    }
                                }
                            ]
                        },
                        "inputStage" : {
                            "stage" : "IXSCAN",
                            "keyPattern" : {  #所掃描的index內容, 
                                "sourceId" : 1.0
                            },
                            "indexName" : "sourceId_1",  #winning plan所選用的index。
                            "isMultiKey" : false,  #是否是Multikey,此處返回是false,如果索引建立在array上,此處將是true。
                            "multiKeyPaths" : {
                                "sourceId" : []
                            },
                            "isUnique" : false,
                            "isSparse" : false,
                            "isPartial" : false,
                            "indexVersion" : 2,
                            "direction" : "forward", #此query的查詢順序,此處是forward,如果用了.sort({modify_time:-1})將顯示backward。
                            "indexBounds" : {    #所掃描的索引範圍,如果沒有制定範圍就是[MaxKey, MinKey],這主要是直接定位到mongodb的chunck中去查詢資料,加快資料讀取
                                "sourceId" : [ 
                                    "[\"130\", \"130\"]"
                                ]
                            }
                        }
                    }
                }
            }
        },
        "rejectedPlans" : [   #其他執行計劃(非最優而被查詢優化器reject的)的詳細返回,其中具體資訊與winningPlan的返回中意義相同,故不在此贅述
            {
                "stage" : "SKIP",
                "skipAmount" : 100,
                "inputStage" : {
                    "stage" : "SORT",
                    "sortPattern" : {
                        "time" : -1.0
                    },
                    "limitAmount" : 200,
                    "inputStage" : {
                        "stage" : "SORT_KEY_GENERATOR",
                        "inputStage" : {
                            "stage" : "FETCH",
                            "filter" : {
                                "$and" : [ 
                                    {
                                        "sourceId" : {
                                            "$eq" : "130"
                                        }
                                    }, 
                                    {
                                        "sourceType" : {
                                            "$eq" : "zipFile"
                                        }
                                    }, 
                                    {
                                        "time" : {
                                            "$lte" : ISODate("2018-12-29T03:56:00.000Z")
                                        }
                                    }, 
                                    {
                                        "time" : {
                                            "$gte" : ISODate("2018-12-26T00:00:00.000Z")
                                        }
                                    }
                                ]
                            },
                            "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                    "targetType" : 1.0
                                },
                                "indexName" : "targetType_1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                    "targetType" : []
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                    "targetType" : [ 
                                        "[\"body\", \"body\"]", 
                                        "[\"face\", \"face\"]"
                                    ]
                                }
                            }
                        }
                    }
                }
            }, 
            {
                "stage" : "LIMIT",
                "limitAmount" : 100,
                "inputStage" : {
                    "stage" : "SKIP",
                    "skipAmount" : 100,
                    "inputStage" : {
                        "stage" : "FETCH",
                        "filter" : {
                            "$and" : [ 
                                {
                                    "$or" : [ 
                                        {
                                            "targetType" : {
                                                "$eq" : "face"
                                            }
                                        }, 
                                        {
                                            "targetType" : {
                                                "$eq" : "body"
                                            }
                                        }
                                    ]
                                }, 
                                {
                                    "sourceId" : {
                                        "$eq" : "130"
                                    }
                                }, 
                                {
                                    "sourceType" : {
                                        "$eq" : "zipFile"
                                    }
                                }
                            ]
                        },
                        "inputStage" : {
                            "stage" : "IXSCAN",
                            "keyPattern" : {
                                "time" : -1.0
                            },
                            "indexName" : "time_-1",
                            "isMultiKey" : false,
                            "multiKeyPaths" : {
                                "time" : []
                            },
                            "isUnique" : false,
                            "isSparse" : false,
                            "isPartial" : false,
                            "indexVersion" : 2,
                            "direction" : "forward",
                            "indexBounds" : {
                                "time" : [ 
                                    "[new Date(1546055760000), new Date(1545782400000)]"
                                ]
                            }
                        }
                    }
                }
            }, 
            {
                "stage" : "SKIP",
                "skipAmount" : 100,
                "inputStage" : {
                    "stage" : "SORT",
                    "sortPattern" : {
                        "time" : -1.0
                    },
                    "limitAmount" : 200,
                    "inputStage" : {
                        "stage" : "SORT_KEY_GENERATOR",
                        "inputStage" : {
                            "stage" : "FETCH",
                            "filter" : {
                                "$and" : [ 
                                    {
                                        "$or" : [ 
                                            {
                                                "targetType" : {
                                                    "$eq" : "face"
                                                }
                                            }, 
                                            {
                                                "targetType" : {
                                                    "$eq" : "body"
                                                }
                                            }
                                        ]
                                    }, 
                                    {
                                        "sourceId" : {
                                            "$eq" : "130"
                                        }
                                    }, 
                                    {
                                        "time" : {
                                            "$lte" : ISODate("2018-12-29T03:56:00.000Z")
                                        }
                                    }, 
                                    {
                                        "time" : {
                                            "$gte" : ISODate("2018-12-26T00:00:00.000Z")
                                        }
                                    }
                                ]
                            },
                            "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                    "sourceType" : 1.0
                                },
                                "indexName" : "sourceType_1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                    "sourceType" : []
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                    "sourceType" : [ 
                                        "[\"zipFile\", \"zipFile\"]"
                                    ]
                                }
                            }
                        }
                    }
                }
            }
        ]
    },
    "executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 100,
        "executionTimeMillis" : 3355, #指的是我們這條語句的執行時間,這個值當然是希望越少越好。
        "totalKeysExamined" : 134688, #索引掃描條目
        "totalDocsExamined" : 134688, #文件掃描條目 對於一個查詢,
		#我們最理想的狀態是:nReturned=totalKeysExamined=totalDocsExamined,那麼又是什麼影響到了totalKeysExamined和totalDocsExamined?是stage的型別。型別列舉如下:
        "executionStages" : {
            "stage" : "SKIP",
            "nReturned" : 100, #該條查詢返回的條目
            "executionTimeMillisEstimate" : 1750, #該查詢根據index去檢索document獲得100條資料的時間。
            "works" : 134891,
            "advanced" : 100,
            "needTime" : 134790,
            "needYield" : 0,
            "saveState" : 4216,
            "restoreState" : 4216,
            "isEOF" : 1,
            "invalidates" : 0,
            "skipAmount" : 0,
            "inputStage" : {
                "stage" : "SORT",
                "nReturned" : 200, #該條查詢返回的條目
                "executionTimeMillisEstimate" : 1740,  #該查詢掃描200行index所用時間。
                "works" : 134891,
                "advanced" : 200,
                "needTime" : 134690,
                "needYield" : 0,
                "saveState" : 4216,
                "restoreState" : 4216,
                "isEOF" : 1,
                "invalidates" : 0,
                "sortPattern" : {
                    "time" : -1.0
                },
                "memUsage" : 4215716,
                "memLimit" : 33554432,
                "limitAmount" : 200,
                "inputStage" : {
                    "stage" : "SORT_KEY_GENERATOR",
                    "nReturned" : 134688,
                    "executionTimeMillisEstimate" : 1100,
                    "works" : 134690,
                    "advanced" : 134688,
                    "needTime" : 1,
                    "needYield" : 0,
                    "saveState" : 4216,
                    "restoreState" : 4216,
                    "isEOF" : 1,
                    "invalidates" : 0,
                    "inputStage" : {
                        "stage" : "FETCH",
                        "filter" : {
                            "$and" : [ 
                                {
                                    "$or" : [ 
                                        {
                                            "targetType" : {
                                                "$eq" : "face"
                                            }
                                        }, 
                                        {
                                            "targetType" : {
                                                "$eq" : "body"
                                            }
                                        }
                                    ]
                                }, 
                                {
                                    "sourceType" : {
                                        "$eq" : "zipFile"
                                    }
                                }, 
                                {
                                    "time" : {
                                        "$lte" : ISODate("2018-12-29T03:56:00.000Z")
                                    }
                                }, 
                                {
                                    "time" : {
                                        "$gte" : ISODate("2018-12-26T00:00:00.000Z")
                                    }
                                }
                            ]
                        },
                        "nReturned" : 134688,
                        "executionTimeMillisEstimate" : 840,
                        "works" : 134689,
                        "advanced" : 134688,
                        "needTime" : 0,
                        "needYield" : 0,
                        "saveState" : 4216,
                        "restoreState" : 4216,
                        "isEOF" : 1,
                        "invalidates" : 0,
                        "docsExamined" : 134688,
                        "alreadyHasObj" : 0,
                        "inputStage" : {
                            "stage" : "IXSCAN",
                            "nReturned" : 134688,
                            "executionTimeMillisEstimate" : 90,
                            "works" : 134689,
                            "advanced" : 134688,
                            "needTime" : 0,
                            "needYield" : 0,
                            "saveState" : 4216,
                            "restoreState" : 4216,
                            "isEOF" : 1,
                            "invalidates" : 0,
                            "keyPattern" : {
                                "sourceId" : 1.0
                            },
                            "indexName" : "sourceId_1",
                            "isMultiKey" : false,
                            "multiKeyPaths" : {
                                "sourceId" : []
                            },
                            "isUnique" : false,
                            "isSparse" : false,
                            "isPartial" : false,
                            "indexVersion" : 2,
                            "direction" : "forward",
                            "indexBounds" : {
                                "sourceId" : [ 
                                    "[\"130\", \"130\"]"
                                ]
                            },
                            "keysExamined" : 134688,
                            "seeks" : 1,
                            "dupsTested" : 0,
                            "dupsDropped" : 0,
                            "seenInvalidated" : 0
                        }
                    }
                }
            }
        }
    },
    "serverInfo" : {
        "host" : "deed829d4373",
        "port" : 27017,
        "version" : "3.6.5",
        "gitVersion" : "a20ecd3e3a174162052ff99913bc2ca9a839d618"
    },
    "ok" : 1.0
}