MongoDB 查询篇 及 数组修改器更新数据

查询方法

1. 查询方法

mongoose查询使用最基础的方法就是find、findOne方法，前者查询所有满足条件的值，后者取满足条件的某一个值。

2. 查询条件

mongoose查询条件其实就是在find方法的基础上添加mongodb条件操作符，如Thing.find().gt(‘age’, 21)就等同于Thing.find({age: {$gt: 21}})，mongodb条件操作符如下：

条件操作符	作用
$or	或关系
$nor	或关系取反
$gt	大于
$gte	大于等于
$lt	小于
$lte	小于等于
$ne	不等于
$in	在多个值范围内
$nin	不在多个值范围内
$all	匹配数组中多个值
$regex	正则，用于模糊查询
$size	匹配数组大小
$maxDistance	范围查询，距离（基于LBS）
$mod	取模运算
$near	邻域查询，查询附近的位置（基于LBS）
$exists	字段是否存在
$elemMatch	匹配内数组内的元素
$within	范围查询（基于LBS）
$box	范围查询，矩形范围（基于LBS）
$center	范围醒询，圆形范围（基于LBS）
$centerSphere	范围查询，球形范围（基于LBS）
$slice	查询字段集合中的元素（比如从第几个之后，第N到第M个元素）

3. 查询实例

• populate 联表查询

首先，我们定义三个Schema

drawApply = new Schema({
    salesId: { type: Schema.ObjectId, ref: 'sales' },
    money: Number,
    status: { type: Number, default: 0 },
    createTime: { type: Date, default: Date.now }
});

sales = new Schema({
    name: { type: String, required: true, unique: true },
    pwd: String,
    phone: String,
    merchant: { type: Schema.ObjectId, ref: 'merchant' },
    status: { type: Number, default: 0 }
});

merchant = new Schema({
    name: String,
    sname: String,
    type: String
});

返回的结果中除了drawApply表的数据外，还会包含salesId中_id，name，phone，merchant四个属性的值（注：需要查看什么属性就在第二个参数中明示，若populate方法中只有salesId参数，则会将sales表中所有属性返回）。但是merchant属性的值是以ObjectId的形式显示的，如果想知道对应的merchant其它属性的值，则需要再次使用到嵌套的populate。代码如下：

drawApply.find().populate({
    path: 'salesId',
    select: '_id name phone merchant',
    model: 'sales',
    populate: {
        path: 'merchant',
        select: '_id sname',
        model: 'merchant'
    }).sort({createTime: -1}).exec(function(err, list) {
  // list of drawApplies with salesIds populated and merchant populated
});

如果 drawApply 表中还存在其它 ObjectId 类型的字段，则可以在 populate 方法后面继续跟其它的 populate，使用方法相同，如：

drawApply.find().populate({
    path: 'salesId',
    select: '_id name phone merchant',
    model: 'sales',
    populate: {
        path: 'merchant',
        select: '_id sname',
        model: 'merchant'
    })
    .populate('approver', 'name')//这里是简写方式， {path:'approver',select:'name'}
    .populate('operator', 'name')
    .sort({createTime: -1}).exec(function(err, list) {
  // list of drawApplies with salesIds populated and merchant populated
});

• 复杂查询
  以下是一个复杂查询，基本包括了所有的查询用法

 Person
      .find({ occupation: /host/ }) 
      .where('name.last').equals('Ghost')   // Person.name.last是Ghost
      .where('age').gt(17).lt(66)  // 17 < Person.age <66
      .where('likes').in(['vaporizing', 'talking'])//likes是vaporizing或者talking
      .skip(10) //跳过前10条
      .limit(10)  //限制10条记录
      .sort({time:-1})  //根据time的倒序排
      .select('name occupation') //选择name和occupation字段
      .exec(callback);

• 模糊查询
  有时候在项目中需要搜索功能，而搜索功能的实现必须用模糊匹配，这个时候可以使用or进行多字段匹配，但速度比较慢，大系统最好使用专业的搜索方法
  or表示在数组里的条件满足一个即可，$regex表示一个正则表达式，匹配了key，同时，加入了$option的$i表示忽略大小写
  官网文档 ： MongoDB - regex

Job.find({
        $or: [
          {'description': {'$regex': key, $options: '$i'}},
          {'city': {'$regex': key, $options: '$i'}},
          {'name': {'$regex': key, $options: '$i'}}]
      })
      .populate('JobType', 'name')
      .exec(function (err, jobs) {
        if (err) {
          callback(err);
        } else {
          callback(null, jobs);
        }
      }

• 深层属性查询
  有些对象结构比较复杂，属性可能存在多层嵌套关系，有时需要通过对象属性下属的属性查询对象，如通过content的label的值查询Comment

Comment.find({'content.label': value}, function (err, comment) {
    console.log(comment)
})

• 二维数组查询
  如果二维数组结构为[[]]，这样的数组是可以查询，但是填充数组里对象时会有问题

Comment.find({'points': value}).populate('points').exec(function (err, comment) {
    console.log(comment) // 无法填充points
})

所以需要填充二维数组里的对象时，不能使用这种结构，而应该如schema.js中一样，将里面的数组先作为对象保存

Comment.find({'points': value}).populate('points.point').exec(function (err, comment) {
    console.log(comment) // 无法填充points
})

• 循环填充
  结构如Point，读取point时，需要填充children，而childern的childern也需要填充，使用populate只能填充当前的childern，在schema.js添加：

PointSchema.pre('find', function(next) {
  this.populate('children')
  next()
})

这样每次查询时，自动为point填充childern

• 多表联合查询
  mongoose其实没有多表联合查询的方法，不过我们可以通过多次查询来实现。
  通过user的name、post的content查询post:

User.find({name: name}, function (err, users) {
    Post.find({poster: {$in: users}, content: content}, function (err, posts) {
        console.log(posts)
    })
})

有时我们也需要对取出来的数据进行再次过滤，而不是通过查询语句查询
通过user的name、post的content、comment的content.main查询post:

User.find({name: name}, function (err, users) {
    Post.find({poster: {$in: users}, content: content}).populate('commenter').exec(function (err, posts) {
        posts.filter(function(post) {
            return post.commenter.content.main === value
        })
    })
})

数组修改器更新数据

这里，我们将了解一下数组修改器。数组，是我们经常看到和使用到的且非常有用的数据结构：它不仅可以通过索进行引用，还可以作为集合来使用。数组修改器，顾名思义，它是用来修改数组的，而不能用来修改整数或者字符串。数组修改器不多，就那么几个，但熟练掌握它后，将给我们带来非常方便的操作。下面，我们来了解一下：

> db.user.findOne()
{
    "_id" : ObjectId("4ffcb2ed65282ea95f7e3304"),
    "age" : 23,
    "favorite" : {
        "1" : "reading",
        "2" : "swimming",
        "3" : "listening music"
    },
    "fname" : "jeff",
    "height" : 166,
    "lname" : "jiang",
    "relationships" : [
        {
            "fname" : "deng",
            "lname" : "pan"
        },
        {
            "fname" : "qiang",
            "lname" : "he"
        },
        {
            "fname" : "dongren",
            "lname" : "zeng"
        }
    ]
}

$push

以上是我的还在完善中的个人信息文档。假设最近我又交了一个好朋友，我想把他加到我的人际关系“relationships”数组中。这时，$push修改器就派上用场了。$push的作用就是，如果指定的键已经存在，它会向已有的数组末尾加入一个元素，要是没有就会创建一个新的数组。下面我们把新朋友加进去。

> db.user.update({"_id" : ObjectId("4ffcb2ed65282ea95f7e3304")},{$push:{"relationships":{"fname":"xiong","lname":"lan"}}})
> db.user.findOne()
{
    "_id" : ObjectId("4ffcb2ed65282ea95f7e3304"),
    "age" : 23,
    "favorite" : {
        "1" : "reading",
        "2" : "swimming",
        "3" : "listening music"
    },
    "fname" : "jeff",
    "height" : 166,
    "lname" : "jiang",
    "relationships" : [
        {
            "fname" : "deng",
            "lname" : "pan"
        },
        {
            "fname" : "qiang",
            "lname" : "he"
        },
        {
            "fname" : "dongren",
            "lname" : "zeng"
        },
        {
            "fname" : "xiong",
            "lname" : "lan"
        }
    ]
}

$pop

有加就有减，那么怎么对数组进行“减”操作呢。能达到对数组“减”目的的修改器有两个，$pop和$pull。$pop和$pull又有区别，我们来分别实验。首先是$pop

> db.user.update({"_id" : ObjectId("4ffcb2ed65282ea95f7e3304")},{$pop:{"relationships":1}})
> db.user.findOne()
{
    "_id" : ObjectId("4ffcb2ed65282ea95f7e3304"),
    "age" : 23,
    "favorite" : {
        "1" : "reading",
        "2" : "swimming",
        "3" : "listening music"
    },
    "fname" : "jeff",
    "height" : 166,
    "lname" : "jiang",
    "relationships" : [
        {
            "fname" : "deng",
            "lname" : "pan"
        },
        {
            "fname" : "qiang",
            "lname" : "he"
        },
        {
            "fname" : "dongren",
            "lname" : "zeng"
        }
    ]
}

从上面可以看出，它把我们刚加进去的朋友又删除了，也就是说它从数组的最后删除。那么，如果我们想从数组的开头删除该怎么办呢。很简单，把上面的“1”改成“-1”，它将逆向操作。下面看一下：

> db.user.update({"_id" : ObjectId("4ffcb2ed65282ea95f7e3304")},{$pop:{"relationships":-1}})
> db.user.findOne()
{
    "_id" : ObjectId("4ffcb2ed65282ea95f7e3304"),
    "age" : 23,
    "favorite" : {
        "1" : "reading",
        "2" : "swimming",
        "3" : "listening music"
    },
    "fname" : "jeff",
    "height" : 166,
    "lname" : "jiang",
    "relationships" : [
        {
            "fname" : "qiang",
            "lname" : "he"
        },
        {
            "fname" : "dongren",
            "lname" : "zeng"
        }
    ]
}

$pull

从结果可以看出，它达到了我们预期的目的。那么如果我们想删除数组中间的呢。这时，$pull派上用场。首先，我们先将新朋友加进去，这里我不再演示。但我们可以想到“dongren”这个人是在数组的中间。现在我们要将他删除：

> db.user.update({"_id" : ObjectId("4ffcb2ed65282ea95f7e3304")},{$pull:{"relationships":{"fname":"dongren","lname":"zeng"}}})
> db.user.findOne()
{
    "_id" : ObjectId("4ffcb2ed65282ea95f7e3304"),
    "age" : 23,
    "favorite" : {
        "1" : "reading",
        "2" : "swimming",
        "3" : "listening music"
    },
    "fname" : "jeff",
    "height" : 166,
    "lname" : "jiang",
    "relationships" : [
        {
            "fname" : "qiang",
            "lname" : "he"
        },
        {
            "fname" : "xiong",
            "lname" : "lan"
        }
    ]
}

从上面可以看出，$pull可以将数组中间的数据删除。这里还有一点要注意，$pull会将所有匹配到的数据都删除，这里我就不做实验了。

$ne

下面，我们再来看看$push还有什么特点，我们再往数组里插入一相同的数据，看看会如何：

> db.user.update({"_id" : ObjectId("4ffcb2ed65282ea95f7e3304")},{$push:{"relationships":{"fname":"xiong","lname":"lan"}}})
> db.user.findOne()
{
    "_id" : ObjectId("4ffcb2ed65282ea95f7e3304"),
    "age" : 23,
    "favorite" : {
        "1" : "reading",
        "2" : "swimming",
        "3" : "listening music"
    },
    "fname" : "jeff",
    "height" : 166,
    "lname" : "jiang",
    "relationships" : [
        {
            "fname" : "qiang",
            "lname" : "he"
        },
        {
            "fname" : "xiong",
            "lname" : "lan"
        },
        {
            "fname" : "xiong",
            "lname" : "lan"
        }
    ]
}

结果表明，它是能正常插入到数组的。而在实际生产环境中，我们都不想看到这样的结果，那么，这里又出现了两个可以用的修改器：$ne和$addToSet。$ne主要拿来判断，若数组里面有这个值，则不插入；没有才插入。

> db.user.update({"relationships.fname":{$ne:"xiong"}},{$set:{"fname":"xiong","lname":"lan"}})
> db.user.findOne()
{
    "_id" : ObjectId("4ffcb2ed65282ea95f7e3304"),
    "age" : 23,
    "favorite" : {
        "1" : "reading",
        "2" : "swimming",
        "3" : "listening music"
    },
    "fname" : "jeff",
    "height" : 166,
    "lname" : "jiang",
    "relationships" : [
        {
            "fname" : "qiang",
            "lname" : "he"
        },
        {
            "fname" : "xiong",
            "lname" : "lan"
        },
        {
            "fname" : "xiong",
            "lname" : "lan"
        }
    ]
}

$addToSet … $each…

由结果可以看出，由于该数据在数组中已经存在，所以不再插入。其实，$addToSet比$ne更好用，它可以自己判断数据是否存在，而且它和$each结合使用，还能同时在数组中插入多个数据，这是$ne没办法办到的，下面我们来看一下$addToSet的用法，这里顺便结合了$each的使用：

> db.user.update({"_id" : ObjectId("4ffcb2ed65282ea95f7e3304")},
{$addToSet:{"relationships":{$each:[{"fname":"xiong","lname":"lan"},
{"fname":"dongren","lname":"zeng"}]}}})
> db.user.findOne()
{
    "_id" : ObjectId("4ffcb2ed65282ea95f7e3304"),
    "age" : 23,
    "favorite" : {
        "1" : "reading",
        "2" : "swimming",
        "3" : "listening music"
    },
    "fname" : "jeff",
    "height" : 166,
    "lname" : "jiang",
    "relationships" : [
        {
            "fname" : "qiang",
            "lname" : "he"
        },
        {
            "fname" : "xiong",
            "lname" : "lan"
        },
        {
            "fname" : "xiong",
            "lname" : "lan"
        },
        {
            "fname" : "dongren",
            "lname" : "zeng"
        }
    ]
}

在修改语句中，我们想同时插入{"fname":"xiong","lname":"lan"},{"fname":"dongren","lname":"zeng"}两个数据，但在原数组中，
{"fname":"xiong","lname":"lan"}这个数据已经存在，所以它只插入了后面那条。达到了我们想要的目的。所以，我个人更喜欢使用$addToSet。

$

有时候数组有多个值，而我们只想对其中的一部分进行操作。如果我们把整个文档都抄下来，那太麻烦也太愚蠢了。好在 mongodb 给我们提供了两种简便方法：通过位置或者操作符“$”。下面我们来分别看看这两种方法怎么使用。首先是通过数组位置来操作。数组都是以0开头的，可以将下标直接作为键来选择元素。例如，我们想给数组的第一个数据加上年龄键值对，我们可以这么操作：

> db.user.update({"_id" : ObjectId("4ffcb2ed65282ea95f7e3304")},{$set:{"relationships.0.age":22}})
> db.user.findOne()
{
    "_id" : ObjectId("4ffcb2ed65282ea95f7e3304"),
    "age" : 23,
    "favorite" : {
        "1" : "reading",
        "2" : "swimming",
        "3" : "listening music"
    },
    "fname" : "jeff",
    "height" : 166,
    "lname" : "jiang",
    "relationships" : [
        {
            "age" : 22,
            "fname" : "qiang",
            "lname" : "he"
        },
        {
            "fname" : "deng",
            "lname" : "pan"
        },
        {
            "fname" : "xiong",
            "lname" : "lan"
        }
    ]
}

可是很多情况下，不预先查询文档我们就不知道要修改数组的元素的下标。这时定位操作符“$”就很好用了。它就是用来定位查询文档已匹配的元素，并进行更新。我们来看看它怎么用：

> db.user.update({"relationships.fname":"xiong"},{$set:{"relationships.$.age":22}})
> db.user.findOne()
{
    "_id" : ObjectId("4ffcb2ed65282ea95f7e3304"),
    "age" : 23,
    "favorite" : {
        "1" : "reading",
        "2" : "swimming",
        "3" : "listening music"
    },
    "fname" : "jeff",
    "height" : 166,
    "lname" : "jiang",
    "relationships" : [
        {
            "age" : 22,
            "fname" : "qiang",
            "lname" : "he"
        },
        {
            "age" : 22,
            "fname" : "deng",
            "lname" : "pan"
        },
        {
            "age" : 22,
            "fname" : "xiong",
            "lname" : "lan"
        }
    ]
}

一个修改内嵌数组的实例：

var newid = /.*_52848$/
var zairzrq = '2016-02-15'
var zairzrq_new_Date = '2016-02-15'
var i = 0//第一步，循环病例的rows，日期大于等于新入组日期的row删除
var oldDates = db.artificial_modify.aggregate(
  [{ $match: { 'bingli': newid } }     //查询病例匹配                   
    , { $unwind: '$rows' }
    , {
    $project: {
      '_id': 0
      , 'bingli': 1
      , riqi: '$rows.riqi'
    }
  }]
)
oldDates.forEach(function (oldDate) {
  var tmpDate = oldDate.riqi
  var bingli = oldDate.bingli
  i++
  if (zairzrq == tmpDate) {
    print(zairzrq)
//db.artificial_modify.update({"bingli":bingli,"rows.riqi":zairzrq},{$set:{"rows.$.riqi":zairzrq_new_Date}});        
    db.artificial_modify.update({
      'bingli': bingli,
      'rows.riqi': zairzrq
    }, { $set: { 'rows.0.status.ruzu.CHUANGWH': 4 } })
  }
})    

$in

批量删除 和 批量查询 的方法

// 删除一条数据：传入id
Model.remove({ _id: 传入的id });

// 删除多条数据，传入id数组，使用$in方法
Model.remove({ _id: { $in: ['id1', 'id2'] } });

// 传入一个id查询一条数据：
Model.find({ _id: 传入的id });

// 传入多个id，查询多条数据，传入id数组，使用$in方法
Model.find({ _id: { $in: ['id1', 'id2'] } });