彩尊娱乐-月子餐乌鱼咋做

首页

AD联系:507867812

彩尊娱乐

时间:2019-11-18 14:47:15 作者:追光娱乐 浏览量:15701

彩尊娱乐MongoDB基本查询整理MongoDB基本查询整理MongoDB基本查询整理MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux,见下图

MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux,见下图

MongoDB基本查询整理MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux,如下图

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理

MongoDB基本查询整理

如下图

MongoDB基本查询整理,如下图

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理,见图

彩尊娱乐MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

MongoDB基本查询整理

MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

MongoDB基本查询整理

MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理MongoDB基本查询整理MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

MongoDB基本查询整理

彩尊娱乐MongoDB基本查询整理

MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

1.MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理MongoDB基本查询整理MongoDB基本查询整理

2.

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理

3.MongoDB基本查询整理。

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理MongoDB基本查询整理MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

4.MongoDB基本查询整理。

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理MongoDB基本查询整理MongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linuxMongoDB基本查询整理

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux。彩尊娱乐

展开全文
相关文章
龙BT网址发布器

MongoDB基本查询整理

5694娱乐

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux....

多娱互动游戏

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux....

点点娱乐午夜电影

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux....

萄京娱乐

MongoDB基本查询整理....

相关资讯
点点娱乐欧美大片

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux....

永利澳门888

精确匹配

单个键值对:{"age":28}, 返回"age"值为28的所有文档。 多个键值对:{"username":"tom", "age":28},将多个查询条件组合在一起,等同于:条件1 AND 条件2 AND …AND 条件N。该查询文档返回:用户名为tom,并且年龄为28的所有文档。条件匹配范围“$lt”、“$lte”、“$gt”、“$gte”比较操作符,分别对应:< $lt <= $lte> $gt>= $gte可以组合起来查找一个范围内的值。如:年龄在18到35之间的查询文档是:{"age": {"$gte":18, "$lte":35}}该范围查询方式对日期类型值尤为方便。“$ne”“不相等”操作符,对应:!=如用户名不是tom的查询文档是: {"username": {"$ne":"tom"}}OR查询$in用来查询一个键对应的多个值,对单个键做OR查询。如:活动中奖号码是1,4,8,要找出全部这些中奖数据的查询文档是:{"ticket_no":{"$in":[1, 4, 8]}} $nin相对地,$nin返回与数组中值都不符合的数据,如找出没有中奖的数据的查询文档是:{ "ticket_no": {"$nin": [1, 4, 8]} }。 $or用来查询多个键的任意值,会更通用一些。它接受一个所有可能条件的数组作为参数,也可以含有其他条件句。如:{ "$or": [ { "ticket_no":{ "$in":[1, 4, 8] } }, { "winner":true } ]}$or的第一个条件应尽可能地匹配更多的文档,这样才最有效。$not

$not是元条件句,可以用在任何其他条件之上,表取反。如:查询文档:{"value":{"$mod":[5,1]}},符合条件的值有:1, 6, 11等。如果想要查找值为2, 3, 4, 5, 7, 8, 9, 10, 12等的数据就可以用:{"value":{"$not":{"$mod":[5,1]}}}。

$exists

用来查询文档中某个键是否存在,如找出不存在键名为key1的文档:{"key1":{"$exists":false}};相反,{"key1":{"$exists":true}}表示存在key1键。

类型匹配Null

查询文档{"x":null},执行后返回:包含有键值对“x”:null的文档,以及不存在x键的文档。

正则表达式

PCRE支持的正则表达式都能被MongoDB所接受。如查询文档{key1”} 都会返回。可用于SQL中的like场景。

查询数组数组中每一个元素都是整个键的值。如有文档:文档1:{"fruit":["apple", "pear", "peach"]},文档2:{"fruit":["peach", "banana", "apple"]},文档3:{"fruit":["orange", "banana", "apple"]},单个元素匹配若查询文档为:{"fruit":"apple"},文档1,2,3都会被成功匹配。多个元素匹配需要用到$all条件句了,若查询文档为:{"fruit":{"$all":["apple","peach"]}},则文档1,2会被匹配,与元素顺序无关。精确匹配若查询文档为:{"fruit":["apple", "pear", "peach"]},则只匹配文档1,对于缺少或冗余,以及顺序不一致的都不会匹配到。下标匹配采用key.index方式,数组下标从0开始。如查询文档:{"fruit.2":"apple"},则文档2,3被匹配。长度匹配若查询文档为:{"fruit":{"$size":3}},表示查询长度为3的数组,文档1,2,3都会被匹配。内嵌文档的查询点表示法如文档:{ "_id":1, "name":{"first":"Joe", "last":"Smith"}}则可以这样查询:{"name.first":"Joe", "name.last":"Smith"}$elemMatch当需要对一个内嵌文档的多个键操作时使用。如有文档:{ "comments": [ { "name": "Tom", "score": 3, "comment": "bad" }, { "name": "Jim", "score": 6, "comment": "good" } ]}要查找Tom评分大于5的评论文档,只能这样: {"comments":{"$elemMatch":{"name":"Tom","score":{"$gt":5}}}}而不能: {"comments":{"name":"Tom","score":{"$gt":5}}},不能匹配"comment"键了。或 {"comments.name":"Tom","comments.score":{"$gt":5}},匹配的不是同一条评论了。linux....

热门资讯