深入学习MongoDB---1---入门篇+基础重点篇

最新推荐文章于 2024-08-21 23:31:17 发布
最新推荐文章于 2024-08-21 23:31:17 发布
阅读量1.1k 收藏 1
点赞数
文章标签： mongodb 数据库 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wspppdy/article/details/130094901
版权

MongoDB入门

  • MongDB作为NoSQL数据库之一，主要关注：灵活性、扩展性、高可用
  • 灵活性：NoSQL的特点就是反范式理论，为数据的水平扩展和字段的组织提供了巨大的便利
  • 高可用：天生就伴随副本集（从节点）的概念，通过Raft算法实现集群的高可用；
  • 扩展性：拥有分片机制，不需要应用程序或者插件就能实现数据分片和分片集群的搭建，只需要启动一个分片服务器、分片配置服务器、路由服务器即可自动进行分片和分片查询；
  • MongoDB是最接近关系数据库的非关系型数据库，提供了关系数据库的众多核心功能，实现了其中众多核心概念：
    • 索引机制
    • 存储引擎和存储函数：WiredTiger存储引擎、js的存储函数；
    • 事务机制：ACID和Base理论的结合
    • 日志系统：慢查询、journal log（redo log）、oplog
    • 类SQL的查询（甚至支持Lookup左连接查询）

基础

快速入门

数据结构
数据结构（逻辑）

image-20220421161434968

SQLMongoDB备注
databasedatabase
tablecollection
rowdocument
columnfield
primary keyprimary key主键
indexindex索引
viewview视图
  • 支持视图、索引、事务、数据分片和分布式管理
  • 通过命名空间进行操作，一般MongoDB有三层命名空间
    • databse
    • collection
    • document
  • 文档的id一般由**：时间戳、客户端ID、客户进程ID、三个字节的增量计数器**组成
  • MongoDB支持存储过程，它是javascript写的，保存在db.system.js表中。
数据模型

  • 前面学习NoSQl的时候已经介绍过，作为反范式，MongoDB可以灵活保存数据

    • 可以没有任何文档结构（数据模型）约束
    • 文档的属性也可以没有任何约束

  • 文档校验：处于规范，很多时候我们需要对文档进行约束

    • 校验器（validator）：MongoDB通过校验器校验数据和文档格式是否合法
      • 拒绝策略：
        • error：报错
        • warn：继续保存，但是发出警告
    • 跳过校验：通过bypassDocumentValidation跳过校验
校验器
  • required : 数据可以是任意类型，表示这个数据必须传入
  • max: 用于Number 类型数据，最大值
  • min: 用于Number 类型数据，最小值
  • enum:枚举类型(数组中的类型是String)，要求数据必须满足枚举值enum: [‘0’, ‘1’, ‘2’]
  • match:增加的数据必须符合match（正则）的规则
  • maxlength：数据必须是String类型，数据最大长度
  • minlength：数据必须是String类型，数据最小长度
  • bsonType：数据类型
validator: {										   #校验器
      $jsonSchema: {                               		  #json数据格式约束
         bsonType: "object",							#类型
         required: [ "name", "year", "major", "address" ], #必须的字段
         properties: {									#字段规则
            name: {
               bsonType: "string",
               description: "must be a string and is required"
            },
            year: {
               bsonType: "int",
               minimum: 2017,
               maximum: 3017,
               description: "must be an integer in [ 2017, 3017 ] and is required"
            },
            major: {
               enum: [ "Math", "English", "Computer Science", "History", null ],
               description: "can only be one of the enum values and is required"
            },
            gpa: {
               bsonType: [ "double" ],
               description: "must be a double if the field exists"
            },
            address: {
               bsonType: "object",
               required: [ "city" ],
               properties: {
                  street: {
                     bsonType: "string",
                     description: "must be a string if the field exists"
                  },
                  city: {
                     bsonType: "string",
                     "description": "must be a string and is required"
                  }
               }
            }
         }
      }
   }
数据结构（物理）
  • JSON格式存取
  • BSON格式保存（BSON就是JSON的二进制形式，并且增强了JSON）
  • 数据最终通过B-Tree的形式在文件系统中组织存储；
数据库基本操作
  • options是操作可以携带的条件，同样是key-value形式
数据库操作
  • 数据库增删改查
    • 使用：use
      • 增：在use的数据库中插入数据即可（如果没有该数据库则创建、有则插入数据）
      • 删：db.dropDatabase()
        • 删除use的数据库
      • 查：show dbs
  • 用户
    • 切换用户use usernam
    • 登录：auth(“用户名”,“密码”)
    • 创建用户：db.createUser
  • 视图
  • 索引
集合操作
  • 增删改查
    • 增：db.createCollection(name，options)
      • 可选的options：
      • image-20220421155851555
    • 删：db.集合名.drop()
    • 改：
    • 查
      • 查看该数据库全部集合：show collections()
      • 查看某一个集合的状态：db.集合名称.stats()
文档操作（集合操作文档）

  • MongoDB通过BSON格式保存文档数据，BSON由一个到多个key-value键值对组成；

  • 文档就像关系数据库的具体数据一样，操作是通过collection进行；

  • 文档操作类似关系数据库，主要分为

    • select子句：
    • where子句
    • limit子句
    • group by子句
    • order by子句

  • 命令：

    • 增删改：

      db.<collectionName>.<操作>()

    • 查

      db.<collectionName>
.find(
	{query},#where子句
	{fields}#select子句（一般指定查询的field字段）
)
.group()#group子句
.sort()#order by子句
.limit().skip()#limit子句
增

  • insertOne

  • insertMany

  • insert

  • # db.<collectionName>.insert({data},{options})
db.test1.insert({
	"name":"www",
	"hhh":123
	})
	
#db.<collectionName>.insertMany([{data}……],{options})
db.test.insertMany(
    [
        {"name":"lili","age":19},
        {"name":"liyi","age":20},
        {"name":"liuliu","age":21}
    ]
)
删

  • 有delete和remove俩种删除方法（推荐使用delete）

    • deleteOne
    • deleteMany
    • remove
  • # db.<collectionName>.remove(<query>,{options})
db.test1.remove({
	{"tid":"test"},#query，相当于SQL的where
	{"justOne":true}#只删除一条记录
	})

db.test1.insert(
   { item: "envelopes", qty : 100, type: "Clasp" },
   { writeConcern: { w: "majority" , wtimeout: 5000 } } #开启写关注
)
改

  • 改主要有两种手段：覆盖（save、replace）、查询修改（update）

    • updateOne
    • updateMany
    • update
    • save
    • replaceOne

  • 主要操作

    • $set：修改
    • $unset：删除字段
    • $push：添加元素（一般用在数组）
    • $inc：数值+x
  • #覆盖，save覆盖一般需要携带_id，来覆盖指定id的文档
	# db.<collectionName>.save(data,{options})
db.test1.save("_id":ObjectId("xxxxxxxxxx"),其他数据部分,{options})

#更新
	# db.<collectionName>.update(<query>,<update{data},update{date}……>,{options})
	#update：$set、$inc等
db.test1.update({},{$set:{'title':'HHHH'},{options}})
查

  • 支持组合操作、支持批量操作

  • image-20220423121257030 
  • # db.<collectionName>.find(<query>,<fields>)
db.test1.find({}) #查询所有

#查询名字为lili的age字段 SELECT age FROM test1 WHERE name = 'lili'
db.test1.find({"name":"lili"},{"age":1}) 

db.test.find({$or: [{"age": {$gt:22}},{name:"www"}]})
query子句

  • 即SQL的where子句，

    • 支持聚合运算、
    • 支持数值运算、条件运算（in、or、and、等于、大于、大于等于、小于、小于等于、不等于）、
    • 正则表达式、
    • 模糊查询、
    • exists和not exists等

  • 数值运算

    • “key”:{<运算符>:数值}

      • 运算符：
        • 大于:$gt
        • 大于等于：$gte
        • 小于：$lt
        • 小于等于：$lte
        • 不等于: $ne
    • #score大于等于50分
{
	'score':{$gte:50}
}
# 等于
{
	'score':50
}

  • IN

    • $in

    • { 
	'status': { $in: [ "A", "D" ] } 
}

  • 条件运算

    • 或：$or

    • #score大于90或者num小于80
{
	$or : [
		{'score':{$gt:90}},
		{'num':{$lt:80}}
	]
}

#与操作
	#score大于90并且num小于80
{
	'score':{$gt:90},
	'num':{$lt:80}
}

  • 模糊查询和正则表达式

    • MongoDB支持正则表达式操作符$regex来做字符串模式匹配。

    • {
	'title': /^震惊/ #以震惊开头
}
内置函数

  • 主要有：

    • 事务相关
      • snapshot
      • readConcern
      • readRef
    • 统计相关
      • explain：类似SQL的expail，用于分析
      • count：统计数量
    • 聚合相关
      • limit和skip：SQL的limit
      • sort：SQL的sort（-1表示倒排，1表示顺序）
      • max和min
    • 连接相关
      • close
      • maxTimeMS
    • 其他
      • pretty：提高可读性
      • forEach、next、hashNext
  • image-20220424163553449
  • image-20220424163725470
  • image-20220424163633173
管道聚合框架
  • 聚合框架（Aggregation Framework）是用于在一个或几个集合上进行的一系列运算从而得到期望的数据集的运算框架。主要有管道聚合、map-reduce、单一目的聚合；
  • 下面主要介绍管道聚合
  • 管道（PipeLine）：管道是聚合框架对数据进行处理的过程，和操作系统的管道类似（单向、流、保存在内存中）
  • 构件：筛选($filter)、投射($project)、 分组($group)、 排序($sort)、 限制($limit)和跳过($skip)、过滤（$match ）、连接运算（$lookup)、展开、图搜索（$graphLookup）、分面搜索($facet/$bucket )、运算的子运算等。
    • 连接运算：只支持左外连接
    • 子运算：
      • image-20220421212304338
  • 步骤（Stage）：步骤是管道中数据流动的一系列操作，就是执行的构件；
#
db.<collectionName>.aggregate({stage},……)


#下面是管道的两步操作
db.test1.aggregate([
    { 
    	$match: { status: "A" } 
    }, #stage1
    { 
    	$group: { 
    		_id: "$cust_id", 
    		total: { $sum: "$amount" } 
    		} 
    }#stage2
])
使用
  • 下面主要基于SpringBoot整合MongoDB
SpringBoot-mongo基础
<!---mongodb相关依赖-->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

mongodb:
	host: localhost 
	port: 27017
	database: 数据库名
	username: XXX
	password: xxx
	authentication-database:  认证的权限
  • 实体类：
    • @Document：标记实体类
    • @MongoId：标记主键
    • @Field：标记为属性（如果属性名和数据库不同需要指定）
    • @Transient：标记属性不作为数据库的属性
    • @DBRef：标记属性位一个document对象
    • @Indexed：标记为该key设置索引
    • @CompoundIndex：联合索引
    • @CompoundIndexes：多个联合索引
  • 通过MongoTemplate进行操作常用的类
    • 查询：Query类
      • 如果文件很大需要允许使用磁盘：query.allowDiskUse(true);
    • 条件：BasicDBObject、Criteria
    • Update：更新类（拼接数据）
    • DeleteResult、UpdateResult：删除结果、更新结果

例子

https://www.cnblogs.com/luoxiao1104/p/15145686.html

    
//实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
@CompoundIndexes(
        {
                @CompoundIndex(def = "{name:1,clazz:1,age:-1}")//联合索引
        }
)
@Document("test")
public class StudentEntity {
    @MongoId
    //@Indexed(unique = true,name = "_id")：默认主键就是唯一索引
    private Long id;
    private String name;
    @Field("class")
    @Indexed(name = "class_text")//普通索引
    private String clazz;
    private Integer age;
    private String[] hobby;
    private Date dateTime;
    @Transient
    private String other;
}


//使用
public void updateUser(){
        //根据id查询数据
        User user = mongoTemplate.findById("611a1cf8d5ba747098ff4625", User.class);
        //设置修改的值
        user.setName("lisi");
        user.setAge(18);
        //调用方法实现修改操作
        Query query = new Query(Criteria.where("_id").is(user.getId()));
        Update update = new Update();
        update.set("name",user.getName());
        update.set("age",user.getAge());
        UpdateResult upsert = mongoTemplate.upsert(query, update, User.class);
        long count = upsert.getModifiedCount();
        System.out.println(count);
    }
MongoDbTemplate

  • 可选配置（主要涉及事务和分布式：事务处理机制、读写关注、ack机制、读依赖、写检查）

    • image-20220428111540186
    • 事务：sessionSyncronization
      • image-20220428111938767
    • 读写关注
      • WriteConcern、ReadConcern
    • 读依赖：ReadPreference
    • ack机制：entityCallBack
    • 写检查：WriteResultChecking，有严格检查（报异常）和不检查

  • 使用

    • 增：insert和save

      • image-20220428112853606image-20220428114820069

      • //MongoTemplate studydb;

//既可以通过集合也可以通过实体类插入
	//以实体类为例子：实体类：StudentEntity，集合名：test4
studydb.insert(new StudentEntity(),"test");

    • 改

      • 修改：可以只改一个或者修改多个（First\Multi）；可以是update（modify）或者replace

        • update和modify：用于部分字段更新
        • repalce：覆盖
      • image-20220428114531870 image-20220428121457361
      • image-20220428120911842 
      • //以只更新一个为例子
	//Query：查询更新的文档；BasicUpdate：更新的内容；document更新的文档（key-value形式）
	//Class：更新文档参考字段名（即key的字段名），不指定则参考集合的字段名；
	//String：集合名
studydb.updateFirst(new Query(), new BasicUpdate(document),StudentEntity.class,"test");

studydb.findAndModify(new Query(), new Update(), 
                      new FindAndModifyOptions(), StudentEntity.class,"test");

//覆盖
studydb.findAndReplace(new Query(), new StudentEntity(),
                       	new FindAndReplaceOptions(),StudentEntity.class,"test");

    • 删

      • 删除：主要是删除多个或者删除一个；只有remove没有delete

      • image-20220428120213974 
      •     //删除多个
    studydb.remove(new Query(),StudentEntity.class,"test");
    //删除一个
    studydb.remove(new Query(),"test");
    //删除多个
    studydb.findAllAndRemove(new Query(),StudentEntity.class,"test");
    //删除一个
    studydb.findAndRemove(new Query(),StudentEntity.class,"test");

    • 查

      • image-20220428121855262 image-20220428121925923 image-20220428121954035 
      • //
studydb.find(new Query(),StudentEntity.class,"test");
//fieldName：去重的字段；List:结果集
studydb.findDistinct(new Query(),"fieldName","test",StudentEntity.class, List.class);

  • 聚合函数

  • 管道操作

    • agreegate：

    • image-20220428122906275 
    • //TypedAggregation：聚合操作
studydb.aggregate( TypedAggregation.newAggregation(Aggregation.match(Criteria.where("a").gt("11"))),
                  "test",
               StudentEntity.class);
Criteria

  • 用于创建查询的中心类。它遵循流畅的API风格，因此您可以轻松地将多个条件链接在一起。标准的静态导入。这种方法提高了可读性。

  • 简单来说就是专门处理条件的类，一般通过静态方法直接创建；

  • 包含前面提到的几乎所有查询：例如

    •     //爱好必须为"睡觉", "吃饭"，且顺序一致;
  	//Criteria.where("hobby").all("睡觉", "吃饭").size(2);爱好是吃饭睡觉，顺序不要求
  		final Criteria hobby = Criteria.where("hobby").is(new String[]{"睡觉", "吃饭"});
    final Criteria criteria = new Criteria();//用于组合条件
    final Criteria age = new Criteria("age").lt(22).gt(5);//年龄6-21
    final List<StudentEntity> studentEntities = mongoTemplate.find(
        new Query(criteria.andOperator(age,new Criteria().orOperator
                                       (hobby,Criteria.where("name").is("zhangsan3")))), StudentEntity.class, "test4");
Query

image-20220428122653998

Aggregation
  • SpringBoot提供了：Aggregation和TypeAggregation、AggregationUpdate处理聚合条件，
    • TypeAggregation：对指定集合聚合，输出指定的实体类型
    • Aggregation：通用的聚合类（另外两个都是其子类）
    • AggregationUpdate：显然是用于update

重点

索引

  • MongoDB能快速查找到主要原因是其强大的索引机制：
  • image-20220421210244432
  • 除了和关系数据库类似的：单字段索引、复合索引（同样有最左匹配原则）、hash索引、
  • Hash索引（散列索引）：散列索引是指按照某个字段的散列值来建立索引；
  • 多键值索引（数组索引）：主要是key对应的value是数组的情况
  • 过期索引：会过期的索引，在索引过期之后，索引对应的数据会被删除
  • 全文索引：MongoDB会自动对索引的Field的数据进行分词，极大加快查找速度（不支持中文分词）
  • 地理空间索引：
    • 2d索引：可以用来存储和查找平面上的点
    • 2d sphere索引：可以用来存储和查找球面上的点。

文本搜索

  • 文本搜索显然是MongoDB的亮点之一，

    • 基于正则表达式的全文搜索：range
    • 基于全文索引的$text

  • 进行文本搜索，首先需要在文本搜索的Field建立索引

  • 和ES类似，MongoDB的文本搜索也是一个赋分的制度，分值越高说明匹配度越高；

  • $$text、$search、score、$meta$：是核心关键字

    • #简单的搜索
db.<collectionName>.find({$text:{$search:"Jon"}})

#多关键词搜索，注意这种搜索是 or的关系，有index 或者 有 operator都可以，所以，这个搜索会出来 Jon Snow，Jon Bon Jovi， Don Jon 等好多名字，而且 Jon Snow还不一定能出现在第一个
db.<collectionName>.find({$text:{$search:"Jon Snow"}})

#有Jon 但是没有Don的
db.<collectionName>.find({$text:{$search:"Jon -Don"}})

#搜索包含Jon Snow的词组。用这个搜索，我发现就出不来了。 因为我们的库里面的词组是Jon Aegon Snow
db.<collectionName>.find({$text:{$search:"\"Jon Snow\""}})

#加了下评分权重的排序。
db.<collectionName>.find( {$text:{$search:"Jon Snow"}}, {score:{$meta:"textScore"}} ).sort({score:{$meta:"textScore"}})

#使用两个短语，这就是一个逻辑上的AND关系，完美。假如你要使用mongodb 多个字符串匹配的查询，就用这个。不过，据说对中文分词不行。
db.<collectionName>.find({$text:{$search:"\"Jon\"\"Snow\""}})

视图

  • 和关系数据库一样，MongoDB的视图也是为了方便对查找进行权限控制

  • MongoDB的视图支持：查找、统计、管道操作

    • #视图创建
db.createCollection()
db.createView()

#查找
db.collection.find()
db.collection.findOne()
#聚合操作
db.collection.aggregate()
#统计操作
db.collection.countDocuments()
db.collection.estimatedDocumentCount()
db.collection.count()
#去重
db.collectionName.distinct()

#删除视图
db.collectionName.drop()

聚合

  • 聚合操作处理数据记录和 return 计算结果。聚合操作将来自多个文档的值组合在一起，并且可以对分组数据执行各种操作以返回单个结果。
  • MongoDB 提供了三种执行聚合的方法：聚合管道，map-reduce function和单一目的聚合方法。
    • 管道聚合：前面已经介绍过
    • 映射规约（map-reduce）：映射规约是大数据处理的一种基本思想；
      • Map-reduce 使用自定义 JavaScript 函数来执行 map 和 reduce操作，以及可选的 finalize 操作。
      • map-reduce 操作有两个阶段：
        • map 阶段：它处理每个文档并为每个输入文档发出一个或多个对象
        • reduce阶段：将map操作的输出组合在一起
      • image-20220423152108290
    • 单一目的聚合

事务

image-20220422160105825

复杂的查询

数组和嵌套文档

数组

  • { : { : , … } }

  • # fruits和aminal都是数组
db.test2.insertMany(
    [
        {"name":"lili","age":19,"fruits":["apple","banana"],"aminal":["cat","dog"]},
		……
    ]
)

# {<array field> : { <operator1>: <value1>, ... } }
db.test2.find( { fruits: ["apple", "banana"], aminal: { $all: ["cat", "dog"] } )
	# fruits只包含两个元素"apple","banana"并且按顺序的数组
	# $all:表示只要包含"cat"和"dog"，不需要知道是否包含其他和顺序 

#可以通过下标指定元素（下标由0开始）；
db.test2.find( { fruits.1: "apple"} )
	#指定fruits第二个元素必须为apple
	
# $elemMatch：对元素进行多条件查询
	#数组中最少一个元素同时满足所有的查询条件。
db.test2.find( { age: { $elemMatch: { $gt: 22, $lt: 30 } } } )
	#数组存在一个元素大于22且小于30

# $size：元素的个数
db.test2.find( { fruits: { $size: 3 } } )
	#fruits有三个元素的文档
嵌套文档
  • { : { : }, … }
  • 和数组基本一致，不过嵌套文档嵌套的数据可以比较复杂；
    • 需要子文档属性的顺序
      • 对嵌套文档整体做等值匹配的时候，要求的是对指定文档的精确匹配，包含字段顺序。
    • 可以像数组一样指定字段
      • 例如``likes.amnimal`:指定为嵌套文档的amniamal字段
db.test2.insertMany(
    [
        {"name":"liyi","age":20,"likes":{{"fruits":["watermalon","banana"]},{"aminal":["panda","mouse"]}}},
         ……
    ]
)

#由于等值查询，必须对查询的fruits、aminal和likes保存的顺序一致
db.inventory.find( { likes: { fruits: [], aminal:[] } } )

#指定likes的fruilts的第二个元素
db.test2.find( { likes.fruits.1: "apple"} )

集合框架搜索

  • 支持运算符

    • $match:滤波操作（相当于where)

    • $project：投影操作（相当于SELECT xxx）

    • $group: 相当于group by

    • $sort: 相当于order by

    • $limit和$skip: 相当于limit

    • $lookup: 左连接

    • $graphLookup：图连接

      • {
$lookup: {
            from: "xxx", #连接的外部表
            localField: "xx", #外部表和本表连接的键
            foreignField: "xx", #外键
            as: ""#连接的外部表的属性的别名
         }
}

{
   $graphLookup: {
      from: <collection>,
      startWith: <expression>,
      connectFromField: <string>,
      connectToField: <string>,
      as: <string>,
      maxDepth: <number>,
      depthField: <string>,
      restrictSearchWithMatch: <document>
   }
}

    • $unwind：拆分数组

      • //原数据
{
    "_id" : ObjectId("59f93c8b8523cfae4cf4ba86"),
    "name" : "鲁迅",
    "books" : [ 
        {
            "name" : "呐喊",
            "publisher" : "花城出版社"
        }, 
        {
            "name" : "彷徨",
            "publisher" : "南海出版出"
        }
    ]
}
//拆分  db.xxxxx.aggregate({$unwind:"$books"})
{
    "_id" : ObjectId("59f93c8b8523cfae4cf4ba86"),
    "name" : "鲁迅",
    "books" : {
        "name" : "呐喊",
        "publisher" : "花城出版社"
    }
}
{
    "_id" : ObjectId("59f93c8b8523cfae4cf4ba86"),
    "name" : "鲁迅",
    "books" : {
        "name" : "彷徨",
        "publisher" : "南海出版出"
    }
}

  • db..aggregate([{管道操作}])

文本查询（文本搜索）

  • 视图不支持文本搜索。

  • 前面已经介绍过使用（在有文本所有的field中）

    • $test+$search：进行文本搜搜
    • score+$meta：进行匹配度排序

  • 聚合框架下的文本查询的限制

    • $text的$search必须在聚合的第一个Stage

    • 只能有一次$search

    • 如果需要按照分数排序需要在后面的Stage中进行（默认不会排序）

    • db.test.aggregate(
   [
       { $match: { $text: { $search: "cake tea" } } },  #第一阶段进行search
       { $project: { title: 1, _id: 0, score: { $meta: "textScore" } } },#需要排序，必须自己排序
       { $match: { score: { $gt: 1.0 } } }
   ]
)

地理空间查询

  • 待学习

集合

  • MongoDB的集合类似MySQL的表（关系模型），类似redis的hash表，在MongoDB中，几乎一切数据都是通过集合组织起来的；
  • 在MongoDB中集合有俩种类型：固定集合和动态分配集合，动态分配集合又可以分为：有约束和没有约束（即校验器校验）
  • capped collection：固定集合，顾名思义，就是大小、存储文档数量固定的集合；在固定集合中：
    • 循环覆盖：没有足够空间时，最老的文档会被删除以释放空间，新插入的文档会占据这块空间。
    • 不能更改：无法将固定集合转换为非固定集合，也不能修改固定集合容量和可存最大文档数据
    • 有序：自然顺序就是文档的插入顺序，可以指定由就到新或者相反；
  • 动态分配集合：就是一般的集合，没有固定的大小，由hash节点的node记录相关信息；

索引机制

舔猫
关注
黑夜力作-Web爬虫入门与实战精讲-专栏导读
黑夜开发者的博客
08-21 2107
本专栏本着从零到一，全面覆盖，实战为王，学以致用。本专栏从爬虫的基本概念讲起，逐步深入到HTTP协议、请求与响应、XPath等，再到Selenium、BeautifulSoup等主流爬虫框架的应用，最后手把手开发出电商订单抓取实战项目，让你轻松掌握Web爬虫的奥秘，下面是专栏主要的一些内容展示，欢迎大家订阅，分享，探讨。
Spring Boot进阶(55)：高效无缝集成MongoDB！SpringBoot开发从容应对大数据存储挑战。
**My Coding Family**
07-19 3758
SpringBoot如何集成MongoDB及实战使用？一文教你搞定。
深入学习MongoDB
china-pub网上书店
03-06 110
深入学习MongoDB 基本信息 原书名： Scaling MongoDB 原出版社： O'Reilly 作者： (美)Kristina Chodorow    [作译者介绍] 译者： 巨成 程显峰 丛书名： 图灵程序设计丛书 出版社：人民邮电出版社 ISBN：9787115272119 上架时间：2012-1-11 出版日期：201...
深入学习mongoDB
Bug制造者
08-10 275
1.创库建表基础命令 1.查看当前数据库 show dbs； 2.查看当前库下的集合 show tables/collections； 3.切换库 use database_Name; database_Name 库名 use 不存在的库，然后创建集合就会显示该库 4.创建集合 db.createCollection('test') ； 创建集合test 2. 集合增删改查 2.1 ...
学习MongoDB语法，这一篇就够了
2201_76129403的博客
08-21 1039
"掌握MongoDB的基本操作是迈向高效数据管理的第一步。勇敢尝试，并不断实践，掌握更多的技巧和知识，才能真正发挥MongoDB的全部潜力。期待在你的项目中看到这些操作的精彩应用，加油！
想学MongoDB？阿里架构师带你深入学习MongoDB
老男孩的架构路
10-24 244
2007 年，MongoDB 公司的前身 10gen 正式成立，2009 年 2 月开源数据库 MongoDB 1.0 正式面世，以开源的方式进入市场接受考验。时至今日，MongoDB 已经从一个在数据库领域籍籍无名的“小透明”，变成了话题度和热度都很高的“流量”数据库。
深入学习mongodb概述
胃小的博客
07-14 376
    MongoDB被称为最像关系型数据库的非关系型数据库,结构非常松散,支持复杂的数据类型,几乎可以实现关系型数据库单表查询的绝大部分功能,另外还支持索引,最新的版本还将增加事物;MongoDB的主要特点有:1.面向集合存储,容易存储对象类型的数据,2.模式自由,采用无结构存储,3.支持完全索引,4.查询丰富,可以完成大部分类似sql的查询操作5.强大的聚合,MapReduce可以完成非常复杂...
Python安全攻防-从入门到入狱
热门推荐
Yasso的博客
01-31 1万+
Python安全攻防-从入门到入狱
领域驱动设计-原理心得篇
冰公主我女神 的博客
02-08 601
“最初我给本文起的标题是《领域驱动设计-理论入门篇》，但是文中掺杂了太多的个人理解，入门篇就显得太官方了，为了避免错误的理解把读者带偏，所以改成《领域驱动设计-理论心得篇》，期待你能发现其中的错误，并可以一同探讨。文章发布前邀请了拥有丰富领域驱动设计实战经验的大佬校正，所以我有理由相信，这篇文章一定可以给你带来一些有用的入门指导建议” 01 写在前面 领域驱动设计（Domain-Driven Design，DDD）是一个有关软件开发的方法论，他提出基于领域开发的开发模式，基于DDD理论...
Spring Boot入门(05)：学习如何使用starter来简化项目配置 | 详细解释，值得收藏
**My Coding Family**
08-14 1万+
Spring Boot的starter入门是Spring Boot中非常重要的概念。通过使用starter，我们可以快速地集成和配置各种第三方框架和库，使我们的应用程序变得更加易于开发和维护。本文将深入探讨Spring Boot的starter入门，为读者介绍starter的概念、原理和用法，并提供详细的示例代码和操作流程，使读者能够轻松地上手使用Spring Boot的starter功能。无论你是初学者还是有经验的开发者，本文都会对你有所帮助，建议收藏！
MongoDB的学习
ungoing的博客
03-31 1006
1. MongoDB概述 1. MongoDB是什么? 是一种非关系型数据库（NoSQL）（即not only sql）。 2. 为什么需要学习？ 企业需求 爬取数据到一个量级，使用MongoDB比mysql要好一些。 3. MongoDB的特点 无数据结构（方便爬虫）（没有固定表结构的约束） 高性能（具有非常高的读写能力） 良好支持（有完善的文档，跨平台，稳定） 2. MongoDB的安装 1. 进入官网，选择版本安装（建议安装4.4版本的） MongoDB官网：https://www.mon
MongoDB 学习
yy139926的博客
06-01 1394
MongoDB是一种非关系型数据库，MongoDB中的记录是一个文档，它是一个由字段和值对组成的数据结构。
mongodb学习
li11261221的博客
05-10 394
一、MongoDB简介 1、NoSQL简介 NoSQL(NoSQL = Not Only SQL)，意即反SQL运动，指的是非关系型的数据库，是一项全新的数据库革命性运动，早期就有人提出，发展至2009年趋势越发高涨。NoSQL的拥护者们提倡运用非关系型的数据存储，相对于目前铺天盖地的关系型数据库运用，这一概念无疑是一种全新的思维的注入 为什幺使用NoSQL : 1、对数据库高并发读写。 2、对海量数据的高效率存储和访问。 3、对数据库的高可扩展性和高可用性。 弱点： 1、数据库事务一致..
MongoDB数据库入门
小小本科生
07-27 401
MongoDB数据库一：什么是MongoDB？二：MongoDB 特点三：Mongo中基础概念1、数据库2、文档3、集合3、MongoDB 数据类型四：MongoDB的使用场景五：MongoDB的常用操作1、INSERT2、Query3、Update4、Remove5、常见的聚合表达式6、索引 一：什么是MongoDB？ MongoDB 是由 C++语言编写的，是一个基于分布式文件存储的开源数据库系统。在高负载的情况下，添加更多的节点，可以保证服务器性能。MongoDB 旨在为 WEB 应用提供可扩展的高性
MongoDB学习
weixin_51504662的博客
01-29 1805
自学的一些关于mongodb和mongoose的安装和操作命令
四.MongoDB 概念解析
Jian Sun_的博客
01-30 324
1.MongoDB 概念解析 不管我们学习什么数据库都应该学习其中的基础概念，在mongodb中基本的概念是文档、集合、数据库，下面我们依次介绍。 下表将帮助您更容易理解Mongo中的一些概念： SQL术语/概念 MongoDB术语/概念 解释/说明 database database 数据库 table collection 数据库表/集合 row document 数据记录行/文档 column field 数据字段/域
No package mongodb-mongodb-org available
最新发布
09-12
当你看到这样的错误信息"No package mongodb-mongodb-org available"，通常意味着你在 CentOS 或 RHEL 类型的操作系统中找不到预配置的 MongoDB 社区版软件包 `mongodb-mongodb-org`。这可能是由于以下原因： 1. **软件仓库未更新**：确保你的 `yum` 或 `dnf` 包管理器已更新到最新版本，因为新版本的软件包可能会添加该包。运行 `sudo yum update` 或 `sudo dnf check-update`。 2. **缺少基础依赖**：检查系统是否已经安装了必要的基础依赖项，如开发库等，因为某些包可能需要它们才能安装。你可以尝试先安装 `epel-release` 或者 `remi-release` 等第三方仓库，然后重新搜索 MongoDB 的包。 3. **官方镜像不包含该包**：MongoDB 的官方软件包列表可能有变动，你可能需要从 MongoDB 官方文档推荐的特定仓库下载并安装。 4. **使用 MongoDB 官方安装程序**：如果官方仓库找不到，你可以直接访问 [MongoDB官网](https://docs.mongodb.com/manual/tutorial/install-mongodb-on-red-hat/) 下载适合的二进制文件，并手动安装。 5. **查找其他社区镜像**：有些社区维护了自己的 MongoDB 镜像列表，如 `ius`, `alt`, 或者 `remi`。尝试替换默认的源查找包。 建议查阅官方文档或联系系统管理员获取正确的安装方法。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

舔猫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值