为了账号安全,请及时绑定邮箱和手机立即绑定

mongodb内嵌文档更新怎么做

/ 猿问

mongodb内嵌文档更新怎么做

米脂 2019-06-07 20:06:05

mongodb内嵌文档更新怎么做


查看完整描述

3 回答

?
慕丝7291255

# 返回集合里的所有文档对象的列表
cate = Categories.objects.all()

# 返回所有符合查询条件的结果的文档对象列表
cate = Categories.objects(name="Python")
# 更新查询到的文档:
cate.name = "LinuxZen"
cate.update()
查询数组 默认查询数组"="代表的意思是in:
class Posts(Document):
artid = IntField(required=True)
title = StringField(max_length=100, required=True)
content = StringField(required=True)
author = ReferenceField(User)
tags = ListField(StringField(max_length=20, required=True), required=True)
categories = ReferenceField(Categories), required=True)
comments = IntField(default=0, required=True)

# 将会返回所有tags包含coding的文档
Posts.objects(tags='coding')


 


查看完整回答
反对 回复 2019-06-08
?
FFIVE

创建文档

向MongoDB插入数据,使用insert,

如:db.refactor.insert({"refactor's blog":"http://www.cnblogs.com/refactor"})

这个操作会给 文档 增加 一个"_id",键,并保存在数据库中。

批量插入

如果要插入多个文档,使用批量插入会快一些,批量化插入能传入一个有文档构成的数据给数据库

一次批量插入只是单个的TCP请求,避免了许多零碎的请求带来的开销.由于无需处理大量的消息头,

这样能减少插入时间.每当单个文档发送致数据库时,会有一个头部信息,告诉数据库对指定的集合做

插入操作.用批量插入的话,数据库就不用重复的处理每个文档的这种头部信息了.

当前版本MongoDB消息的最大长度是16M,使用批量插入是有这个限制的.

插入的原理和作用

当执行插入的时候,使用的驱动程序会将数据转换成BSON的形式,然后将其送入数据库.数据库解析

BSON,检验是否包含"_id"键并且不超过16M,除此之外,不做别的验证,就只是简单的将文档原样的

存入数据库.这样做的坏处是允许插入无效的数据,好处是能让数据库更加安全,远离注入式攻击.

所有的主流语言的驱动会在传送数据之前进行一些数据的有效性检查(文档是否超长,是否含非utf-8的字符,

是否使用了未知类型).同样也可以启动数据库服务器的时候使用--objcheck选项,这样服务器就会在插入

之前先检验文档结构的有效性,当然这样要牺牲性能.

查看doc文档转化为BSON的大小(以字节为单位),在shell中使用Object.bsonsize(doc)

删除文档

db.users.remove()

会删除users集合的所有文档,但不会删除集合本身,原有的索引也会保留.

remove函数可以接受一个查询文档作为可选参数,给定这个参数,只有符合条件的文档才会被删除.

db.users.remove({"name":"Refactor"})

删除数据的永久性的,不能撤销和恢复.

如果要清除整个集合,直接删除集合(然后重建索引)比删除集合中所有的文档要快.

删除集合:db.drop_collection("users")

更新文档

update有两个参数,一个是查询文档,用来找出要更新的文档,另一个是修改器文档,描述对找到的文档进行那些更改

更新的操作是原子性的,若两个更新同时发生,先到服务器的先执行,然后执行另一个.最后的更新会显示在数据库

文档替换

更新最简单的就是使用一个新文档来替代匹配的文档,这适用于模式结构发生较大变化的时候.如将下面的文档

{
  "name":"refactor",
  "friends":20,
  enemies:2
}

更改为

{
  "name":"refactor",
  "relationships":
  {
    "friends":20,
    enemies:2
  }
}

使用修改器

通常文档只会有一部分更新,利用原子的"更新修改器",更新修改器是特殊的键,用来指定复杂的更新操作,比如:

调整,增加,删除键,操作数组,操作内嵌文档.

一般网站都有计数器,来记数公有多少人访问,可以使用原子修改器原子性的完成整个功能.如:

"$set"修改器入门

"$set"用来指定一个键的值,如果键不存在,则创建,这对更新模式或者增加用户定义键来说很方便.

如:
db.users.insert(
  {
    "name":"refactor",
    "age":23,
    "sex":"male"
  }
)
添加喜欢的书籍:
db.users.update(
  {
    "name":"refactor"
  },
  {
    "$set":{"book":"war and peace"}
  }
)
db.users.findOne(
  {"name":"refactor"}
 )
修改喜欢的数据
db.users.update(
  {
    "name":"refactor"
  },
  {
    "$set":{"book":"war and peace2"}
  }
)
"$set"可以修改键的数据类型,如果喜欢多本书,
将book键的值变为一个数组
db.users.update(
  {
    "name":"refactor"
  },
  {
    "$set":{"book":["war and peace","war and peace2"]}
  }
)
使用"$unset"将键删除,没有要删除的键也不报错
db.users.update(
  {
    "name":"refactor"
  },
  {
    "$unset":{"book":1}
  }
)
使用"$set"修改内嵌文档
db.blog.insert(
  {
    "title":"refactor's blog",
    "Content":"refactor's blog test",
    "author":
    {
      "name":"refactor",
      "email":"295240648@163.com"
    }
  }
)

db.blog.update(
  {
    "author.name":"refactor"
  },
  {
    "$set":{"author.name":"refactor2"}
  }
)
db.blog.findOne(
  {
    "title":"refactor's blog"
  }
)
增加,修改,删除键的时候,应该使用$修改器.一定要使用$开头的修改器来修改键值对.

使用"$inc" 增加和减少

"$inc"用来增加已有键的值,若不存在键,则增加.用于分析数据,因果关系,投票或其他有变化值的地方.

如:

db.users.insert(
  {"url":"http://www.cnblogs.com/refactor"}
)

使用"$inc" 增加一个键pageViews,默认值为10000

db.users.update(
  {"url":"http://www.cnblogs.com/refactor"},
  {"$inc":{"pageViews":10000}}
)

使用"$inc"给键pageViews,再增加10000

db.users.update(
  {"url":"http://www.cnblogs.com/refactor"},
  {"$inc":{"pageViews":10000}}
)

使用"$inc"给键pageViews,再减少10000

db.users.update(
  {"url":"http://www.cnblogs.com/refactor"},
  {"$inc":{"pageViews":-10000}}
)

"$inc"和"$set"用法相似,用来增加或减少数字."$inc"只能用于整数,长整数或双精度浮点数.

虽然很多语言能将 null,bool,有数字构成的字符串 转化成 数字,但使用"$inc"仍会报错:

"$inc"键的值也必须为数字.

数组修改器

"$push"和"$pop"只能用于数组.

如果指定的键已存在,"$push"会向已有的数组末尾加入一个元素,如果键不存在,就创建一个新数组.

如:

db.blog.insert(
  {
    "title":"refactor's blog",
    "Content":"refactor's blog test",
    "author":
    {
      "name":"refactor",
      "email":"295240648@163.com"
    }
  }
)

向以上文档中,添加一个包含一个数组的"comment"键,还向 comment 数组push一个评论.

这个数组会自动创建,并加入评论:

db.blog.update(
  {"title":"refactor's blog"},
  {
    $push:
    {
      "comments":
      {
        "name":"refactor2",
        "content":"nice"
      }
    }
  }
)

还想添加一条评论:

db.blog.update(
  {"title":"refactor's blog"},
  {
    $push:
    {
      "comments":
      {
        "name":"refactor3",
        "content":"good"
      }
    }
  }
)

如果一个值不在数组里就把它加进去.可以在查询文档时使用"$ne".

使用"$addToSet"

db.users.insert(
  {
    "userName":"refactor",
    "emails":
    [
      "295240648@163.com",
      "295240648@126.com"
    ]
  }
)

向emails添加新地址,用"$addToSet"避免重复

db.users.update(
  {"userName":"refactor"},
  {
    "$addToSet":
    {
      "emails":"295240648@163.com"
    }
  }
)

这样"295240648@163.com" 不会插入到emails中

db.users.update(
  {"userName":"refactor"},
  {
    "$addToSet":
    {
      "emails":"295240648@qq.com"
    }
  }
)

这样"295240648@qq.com" 会插入到emails中

将"$addToSet"和"$each"一起使用,可以添加不同的值.

db.users.update(
  {"userName":"refactor"},
  {
    "$addToSet":
    {
      "emails":
      {
        "$each":
        [
          "295240648@111.com",
          "295240648@112.com",
          "295240648@113.com"
        ]
      }
    }
  }
)

使用"$pop",可以从数组任何一端删除元素.

{$pop:{key:1}}从数组末尾删除一个元素
{$pop:{key:-1}}从数组头部删除一个元素

使用"$pull",可以根据特定条件删除元素,也可以根据位置删除元素

db.users.update(
  {"userName":"refactor"},
  {
    "$pull":
    {
      "emails":"295240648@111.com"
    }
  }
)

"$pull"会将所有匹配的部分删掉,对于数组[1,1,2,1]执行pull 1,得到的结果数组是[2]



查看完整回答
反对 回复 2019-06-08
?
繁星coding

DBCollection类:指定数据库中指定集合的实例,提供了增删改查等一系列操作。在关系型数据库中,对数据的增删改查操作是建立在表的基础上的,在mongodb中是建立在集合的基础上进行的。
DBObject接口:DBObject是键值的映射,因此,可以将DBObject的实现类作为查询的返回结果,也可以作为查询条件
DBCursor:游标,返回结果的集合。
下面是部分实例:

[java] view plaincopy
Mongo mongo = new Mongo();
DB db = mongo.getDB("myMongoDB");
DBCollection course = db.getCollection("course");//对myMongoDB数据库中course集合进行操作

//添加操作
//下面分别是创建文档的几种方式:1. .append() 2. .put() 3. 通过map 4. 将json转换成DBObject对象
DBObject english = new BasicDBObject().append("name","english").append("score", 5).append("id",1);
course.insert(english);

DBObject math = new BasicDBObject();
math.put("id", 2);
math.put("name", "math");
math.put("score", 10);
course.insert(math);

Map<String,Object> map = new HashMap<String,Object>();
map.put("name","physics" );
map.put("score", 10);
map.put("id", 3);
DBObject physics= new BasicDBObject(map);
course.insert(physics);

String json ="{'name':'chemistry','score':10,'id':4}";
DBObject chemistry =(DBObject)JSON.parse(json);
course.insert(chemistry);

List<DBObject> courseList = new ArrayList<DBObject>();
DBObject chinese = new BasicDBObject().append("name","chinese").append("score", 10).append("id", 5);
DBObject history = new BasicDBObject().append("name", "history").append("score", 10).append("id", 6);
courseList.add(chinese);
courseList.add(history);
course.insert(courseList);

//添加内嵌文档
String json2 =" {'name':'english','score':10,'teacher':[{'name':'柳松','id':'1'},{'name':'柳松松','id':2}]}";
DBObject english2= (DBObject)JSON.parse(json);
course.insert(english2);

List<DBObject> list = new ArrayList<DBObject>();
list.add(new BasicDBObject("name","柳松").append("id",1));
list.add(new BasicDBObject("name","柳松松").append("id",2));
DBObject english3= new BasicDBObject().append("name","english").append("score",10).append("teacher",list);

//查询
//查询所有、查询一个文档、条件查询
DBCursor cur = course.find();
while(cur.hasNext()){
DBObject document = cur.next();
System.out.println(document.get("name"));
}

DBObject document = course.findOne();
String name=(String)document.get("name");
System.out.println(name);

//查询学分=5的
DBObject query1 = new BasicDBObject("score",5);
DBObject query2 = new BasicDBObject("score",new BasicDBObject("$gte",5));
DBCursor cur2 = course.find(query2);
//条件表达式:$ge(>) $get(>=) $lt(<) $lte(<=) $ne(<>) $in $nin $all $exists $or $nor $where $type等等

//查找并修改
DBObject newDocument = course.findAndModify(new BasicDBObject("score",5), new BasicDBObject("score",15));

//更新操作
//q:更新条件 o:更新后的对象
course.update(new BasicDBObject("score",10), new BasicDBObject("test",15));
course.update(new BasicDBObject("score",15), new BasicDBObject("$set",new BasicDBObject("isRequired",true)));
//两个的区别是,第一个更新是将{"test":15}这个文档替换原来的文档,
//第二个更新添加了条件表达式$set,是在原来文档的基础上添加"isRequired"这个键
//条件表达式:$set $unset $push $inc $push $push $addToSet $pull $pullAll $pop等等

//当_id相同时,执行save方法相当于更新操作
course.save(new BasicDBObject("name","math").append("_id", 1));
course.save(new BasicDBObject("name","数学").append("_id", 1));

//删除符合条件的文档
course.remove(new BasicDBObject("score",15));

//删除集合及所有文档
course.drop();<span style="font-family:Arial, Helvetica, sans-serif;"><span style="white-space: normal;">
</span></span>

上面只是介绍了一些简单的操作,具体复杂的查询更新可以根据需求再去查找文档资料。其实,不管操作简单还是复杂,其核心都是对DBObject和DBCollection的操作,主要掌握DBObject如何构造键值对,以及一些条件表达式。


 


查看完整回答
反对 回复 2019-06-08

添加回答

回复

举报

0/150
提交
取消
意见反馈 帮助中心 APP下载
官方微信