[toc]
## 查看数据库
```
show dbs
```
默认已经存在的数据库
- admin
- local
## 原生查询
### 嵌套文档的查询
想要的是数组成员或则普通类型
```
>db.users.find({hobbies:"eat"});
{
...
"name":"ahhh"
"hobbies":["eat","baseball"]
}
```
想要的是对象成员，并且还能够无线`.`纵深下去
```
>db.users.find({"hobbies.eat":{$exists:true}});
{
...
"name":"ahhh"
"hobbies":{
"eat":{"desc":"so high"}
}
}
```
对象里面包数组，查找数组成员中name为hiking的
```
>db.users.find({hobbies.name:"hiking"});
{
...
"name":"ahhh"
"hobbies":[
{
"name":"hiking"
,"level":"great"
}
,{
"name":"painting"
,"level":"fine"
}
]
}
```
对象里面包数组，查找数组成员中第一个name为hiking的的
```
db.users.find({"hobbies.0.name":"hiking"})
```
### findOne
只会查找一条文档记录
```
>db.students.findOne();
```
### find
查看集合下所有文档
```
>db.students.find();
>db.students.find().pretty(); //pretty会优化显示格式
```
#### 筛选显示字段
1:显示该字段
0:不显示该字段
当一个`{}`只设置一个字段时，`1`和`0`代表的是只显示该字段和除了该字段都显示。
当一个`{}`中设置了多个字段时，`1`和`0`不能同时存在，只能全是1或则全是0（**除了`_id`**）
> **注意：** 以下会报错，因为逻辑冲突了
```
>db.students.find({},{name:1,age:0});
```
除了1、0，也可以进行一般的查询筛选
#### 条件查找
##### $in
离散查找
```
db.students.find({age:[$in:[20,70]]});
```
##### $nin
$in取反
```
db.students.find({age:[$nin:[20,70]]});
```
##### $not
非
```
db.students.find(age:{$not:{$in:[20,70]}});
```
##### $gt和$lt
- $gt ：大于
- $gte ：大于等于
- $lt：小于
- $lte：小于等于
```
db.students.find({age:{$gte:20,$lte:70}});
```
```
db.students.find({age:{$not:{$gte:20,$lte:70}}});;
```
##### 完全匹配
```
db.students.find({hobby:["1","2","3"]})
```
##### 关于值为数组的情况
且
```
db.students.find({hobby:{$all:['smoking','drinking']}})
```
$in 和 数组 -> 离散
```
db.students.find({hobby:{$in:['smoking','drinking']}})
```
$size
```
db.students.find({hobby:{$size:3}}) //有三个hobby的
```
$where
```
db.students.find($where:"this.age>30&&this.age<100")
```
$slice
若想要hobby这种数据（数组形式的值），只显示其中的几项，需要用到`$slice`截取(注意这个操作并不是筛选而只是决定是否显示)
```
//$slice:2 就是0、1
//$slice:-2 就是倒数最后一个和倒数第二个
db.students.find({hobby:{$size:3},{hobby:{$slice:2},_id:false})
```
##### 依据id查找
```
{_id:ObjectId("...")}
```
##### 正则查找`//`or`$regex`
```
{name:/.../}
{name:{$regex:"..."}}
```
##### 与和或
且
```
db.students.find({name:'ahhh',age:999});
```
or
```
db.students.find($or:[{name:'ahhh'},{age:999}]);
```
且或连用
名字是ahhh，年龄是20或则100
```
db.students.find({name:'ahhh',$or:[{age:20},{age:100}]});
```
##### $exists
将没有age字段的数据查出
```
db.students.find({age:{$exists:false}});
```
#### cursor
```
var db = connect('students');
//返回的是一个游标，指向结果集的一个指针
var cursor = db.students.find();
while(cursor.hasNext()){
var record = cursor.next();
printjson(record);
}
```
或则
```
var db = connect('students');
cursor.forEach(function(item){
printjson(item);
});
```
#### 分页查询
跳过前三条取三条
```
db.students.find().skip(3).limit(3);
```
```
var pagesize = 3;
var pagenumber = 2;
db.students.find().skip(pagenumber-1)*pagesize).limit(pagesize).sort(1)
```
每个`()`方法不论顺序
## mongoose查询
### 查询不到时的结果
为`[]`数组，这货在判断里不等于false
### 基础查询
>语法
>Model.find(查询条件,callback);
```
Model.find({},function(error,docs){
//若没有向find传递参数，默认的是显示所有文档
});
Model.find({ "age": 111 }, function (error, docs) {
if(error){
console.log("error :" + error);
}else{
console.log(docs); //docs: age为111的所有文档
}
});
```
#### 属性过滤
>语法
>find(Conditions,field,callback)
```
//field省略或为Null，则返回所有属性。
//返回只包含name、age两个键的所有记录
Model.find({},{name:1, age:1, _id:0}，function(err,docs){
//docs 查询结果集
})
```
我们只需要把显示的属性设置为大于零的数就可以，当然1是最好理解的，_id是默认返回，如果不要显示加上`("_id":0)`
#### findOne(查询单条)
>语法
>findOne(Conditions,callback)
find相同，但只返回单个文档，也就说当查询到即一个符合条件的数据时，将停止继续查询，并返回查询结果 语法
```
TestModel.findOne({ age: 111}, function (err, doc){
// 查询符合age等于6的第一条数据
// doc是查询结果
});
```
#### findById(按ID单条数据)
>语法
>findById(_id, callback)
与findOne相同，但它只接收文档的_id作为参数，返回单个文档 语法
与原生不同的是，原生需要使用`ObjectId()`
```
PersonModel.findById(person._id, function (err, doc){
//doc 查询结果文档
});
```
#### $gt、$lt(大于、小于)
查询时我们经常会碰到要根据某些字段进行条件筛选查询，比如说Number类型，怎么办呢，我们就可以使用$gt(>)、$lt(<)、$lte(<=)、$gte(>=)操作符进行排除性的查询，如下示例：
```
Model.find({"age":{"$gt":6}},function(error,docs){
//查询所有nage大于6的数据
});
Model.find({"age":{"$lt":6}},function(error,docs){
//查询所有nage小于6的数据
});
Model.find({"age":{"$gt":6,"$lt":9}},function(error,docs){
//查询所有nage大于6小于9的数据
});
```
#### $ne(不等于)
$ne(!=)操作符的含义相当于不等于、不包含，查询时我们可通过它进行条件判定，具体使用方法如下：
```
Model.find({ age:{ $ne:6}},function(error,docs){
//查询age不等于6的所有数据
});
```
#### $in(包含)
和$ne操作符相反，$in相当于包含、等于，查询时查找包含于指定字段条件的数据
```
Model.find({ age:{ $in: 6}},function(error,docs){
//查询age等于6的所有数据
});
Model.find({ age:{$in:[6,7]}},function(error,docs){
//可以把多个值组织成一个数组
});
```
#### $or(或者)
可以查询多个键值的任意给定值，只要满足其中一个就可返回，用于存在多个条件判定的情况下使用，如下示例：
```
Model.find({"$or":[{"name":"zfpx"},{"age":6}]},function(error,docs){
//查询name为zfpx或age为6的全部文档
});
```
#### $exists(是否存在)
$exists操作符，可用于判断某些关键字段是否存在来进行条件查询。如下示例：
```
Model.find({name: {$exists: true}},function(error,docs){
//查询所有存在name属性的文档
});
Model.find({email: {$exists: false}},function(error,docs){
//查询所有不存在email属性的文档
});
```
### 高级查询
可以限制结果的数量,跳过部分结果,根据任意键对结果进行各种排序
所有这些选项都要在查询被发送到服务器之前指定
#### limit(限制数量)
>语法
>find(Conditions,fields,options,callback);
在查询操作中,有时数据量会很大,这时我们就需要对返回结果的数量进行限制 那么我们就可以使用limit函数，通过它来限制结果数量。 语法
```
Model.find({},null,{limit:20},function(err,docs){
console.log(docs);
});
```
如果匹配的结果不到20个，则返回匹配数量的结果，也就是说limit函数指定的是上限而非下限
#### skip(跳过/略过的数量)
>语法
>find(Conditions,fields,options,callback);
skip函数的功能是略过指定数量的匹配结果，返回余下的查询结果 如下示例：
```
Model.find({},null,{skip:4},function(err,docs){
console.log(docs);
});
```
如果查询结果数量中少于4个的话，则不会返回任何结果。
#### sort函数
>语法
>find(Conditions,fields,options,callback)
sort函数可以将查询结果数据进行排序操作 该函数的参数是一个或多个键/值对 键代表要排序的键名,值代表排序的方向,1是升序,-1是降序 语法
```
Model.find({},null,{sort:{age:-1}},function(err,docs){
//查询所有数据，并按照age降序顺序返回数据docs
});
```
sort函数可根据用户自定义条件有选择性的来进行排序显示数据结果。
#### 分页查询
```
Model('User').find({})
.sort({createAt:-1})
.skip((pageNum-1)*pageSize)
.limit(pageSize)
.populate('user')
.exec(function(err,docs){
console.log(docs);
});
```
#### populate
连表查询
```
var mongoose = require('mongoose');
//连接数据库
mongoose.connect('mongodb://localhost:27017/201606blog');
//定义课程Schema
var CourseSchema = new mongoose.Schema({
name:String
});
var CourseModel = mongoose.model('Course',CourseSchema);
var PersonSchema = new mongoose.Schema({
name:{
type:String,
required:true
},
// 外键 别的集合的主键
course:{
type:mongoose.Schema.Types.ObjectId,
ref:'Course' //指明此外键是哪个集合中的外键
}
});
var PersonModel = mongoose.model('Person',PersonSchema);
CourseModel.create({name:'node.js'},function(err,course){
PersonModel.create({name:'ahhh',course:course._id},function(err,doc){
console.log(doc);
PersonModel.findById(doc._id).populate('course').exec(function(err,doc){
console.log(doc); //连表查询后的结果
})
})
});
```
