MongoDB

qq_30364013
于 2019-10-11 21:57:15 发布
阅读量323
点赞数
本文链接：https://blog.csdn.net/qq_30364013/article/details/102511083
版权
Mongodb 的document  16M   Memcached 的value  1M   Redis 的value  512M
ACID  ：(Atomicity) 原子性 、 (Consistency) 一致性、 (Isolation) 独立性、 (Durability) 持久性
CAP：一致性（Consistency）、可用性（Availability）、分区容错性（Partition tolerance）
SQL术语		MongoDB术语	解释/说明
database 		database 	数据库
table 		collection 	数据库表/集合
row 		document 	数据记录行/文档
column 		field 		数据字段/域
index 		index 		索引
joins 	  	lookup		表连接
primary key 	primary key 	主键,MongoDB自动将_id字段设置为主键

collection:
db.createCollection(<name>, { capped: <boolean>,
                              autoIndexId: <boolean>,
                              size: <number>,//是整个集合空间大小，单位为【KB】
                              max: <number>,//是集合文档个数上线，单位是【个】
                              storageEngine: <document>,
                              validator: <document>,
                              validationLevel: <string>,
                              validationAction: <string>,
                              indexOptionDefaults: <document> } )
两个参数上限判断取的是【与】的逻辑
如果空间大小到达上限，则插入下一个文档时，会覆盖第一个文档;
如果文档个数到达上限，同样插入下一个文档时，会覆盖第一个文档;


ObjectId
ObjectId("5789fb58631178e7844d11d8")   生成规则
4byte：  5789fb58   =>   时间 1468660568   2016-07-16 17:16:08   
3byte:   631178     =>   机器的唯一标识码
2byte：  e784       =>   进程ID
3byte：  4d11d8     =>   随机数


JSON：
数字（整数或浮点数） 
字符串（在双引号中） 
逻辑值（true 或 false）
数组（在方括号中） 
对象（在花括号中） 
null


BSON：
类型 		    对应数字 	别名 		    
Double 			1 	double 	 {“x”：3} 默认使用浮点型数值
String 			2 	string 	 {“x”：“呵呵”}
Object 			3 	object 	 {“x”:{“y”:3 }}
Array 			4 	array 	 {“x”： [“a“，“b”,”c”]}
Binary data 		5 	binData 	 
Undefined 			6 	undefined 弃用
ObjectId 			7 	objectId  {“x”: objectId()}
Boolean 			8 	“bool” 	  {“x”:true} 
Date 			9 	“date” 	  {“x”:new Date()}
Null 			10 	“null” 	  {“x”:null}
Regular Expression 	11 	“regex”   {“x”:/[abc]/}
DBPointer 			12 	“dbPointer” 	 
JavaScript 		13 	“javascript” {“x”:function(){/*…*/}} 
Symbol 			14 	“symbol” 	 
JavaScript(with scope) 	15 	“javascriptWithScope” 	 
32-bit integer 		16 	“int” 	 {“x”:NumberInt(“3”)}
Timestamp 			17 	“timestamp” 	 	
64-bit integer 		18 	“long” 	 {“x”:NumberLong(“3”)}
Min key 			-1 	“minKey” 	 
Max key 			127 	“maxKey”


Shell:
var mongo=new Mongo("10.4.82.150:27017");
var db=mongo.getDB("local");
var collection=db.getCollection("startup_log");
var list= collection.find().toArray();
printjson(list);

var array = {17964:17963}
for(var name in array){
 db.instanceIndex.update(
 {'processKey':{$in:
 ['carInspectDataSecondVersionFlow','carInspectAssetSecondVersionFlow']},
  'index.shopId':NumberInt(name)},
    {$set:{'index.companyId':NumberInt(array[name])}},
     {
      upsert: false,
      multi: true
    }
 );
}

db.taskIndex.aggregate([
{$lookup: { 
    from: "processData", 
    localField: "instanceId", 
    foreignField: "_id",
    as:"work"}
 },
{$match: {
        'processKey': "carInspectAssetSecondVersionFlow",
        'operatorName':"wei.zuo@renren-inc.com",
        'instanceStartTime':{$gte:ISODate('2019-04-15')}
        }
},
{$count:'count'}]).pretty();


CRUD:
Insert,Find[One,Many,Replace],Bulk,Update,Delete[One,Many]

db.collection.insert(
   <document or array of documents>,
   {
     writeConcern: <document>,
     ordered: <boolean>
   }
)

db.col.find({'name':'www'}).sort({'age':1}).limit(4).skip(2).pretty()
sort()方法可以通过参数指定排序的字段
limit()方法来读取指定数量的数据
skip()方法来跳过指定数量的数据
pretty()方法以格式化的方式来显示所有文档

db.collection.update(
   <filter>,//find()
   <update>,//$set, $unset, or $rename
   {
     upsert: <boolean>,
     multi: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ]
   }
)
# 输出信息
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })   

db.collection.delete(
   <filter>,
   {
      writeConcern: <document>,
      collation: <document>
   }
)
remove() 方法已经过时了，现在官方推荐使用 deleteOne() 和 deleteMany() 方法
remove() 方法 并不会真正释放空间,需要继续执行 db.repairDatabase() 来回收磁盘空间



比较运算符
$eq                    =        { <field>: { $eq: <value> } }
$gt   (greater than )  > 
$gte                   >=  
$lt   (less than)      <        {<field> : {$lt :200, $gt :100} }
$lte                   <= 
$ne   (not equal)      !=
$in                    in       { <field>: { $in:["A","E"]} }
$nin  (not in)         !in

逻辑运算符  
$or     $or: [ { <expression1> }, { <expression2> } , { <expressionN> }]
$and
$not
$nor
$exists   { field: { $exists: <boolean> } }
$type     { field: { $type: <BSON type number> | <String alias> } }
db.col.find({"title" : {$type : 2}})  //{"title" : {$type : 'string'}}

评估运算符
$mod       { field: { $mod: [ divisor, remainder ] } }
$regex     { <field>: { $regex: /pattern/, $options: '<options>' } }
$text
$where     { $where: function() {........} }
$all       { <field>: { $all: [ <value1> , <value2> ... ] } }
$elemMatch
$size      { field: { $size: 2 } }
$expr      { $expr: { <expression> } }

update运算符 
$inc,$mul,$rename,$setOnInsert,$set,$unset,$min,$max,$currentDate

数组操作运算符
$addToSet,$pop,$pull,$pullAll,$pushAll,$push,$each,
$slice,$sort,$position,$bit
limit 




aggregation
aggregation:可以多机器跨越查询
语法：db.collection.aggregate(pipeline, options)
pipeline
$project      select
$match        where
$limit        limit
$skip     
$unwind       将数据拆解成每一个document
$group        分组计算
$sample       随机选择文档
$sort         desc asc
$geoNear     经纬度
$lookup      join操作
$out         将最后的结果输出到指定的collection中去 
$indexStats  查询过程中的索引情况
$redact:     决定内嵌文档是否keep

options
allowDiskUse：group和sort都有内存100M的限制，如果为true，就没有100M的限制了

example
db.orders.aggregate([
    {$lookup:{
          from: "inventory",
          localField: "item",
          foreignField: "sku",
          as: "inventory_docs"
          }
   },   
   {   $match:{"price":{$gt:0}}  },
   {
       $group:{"_id":"$item",
               "totalprice":{$sum:"$price"},
               "quantityAvg":{$avg:"$quantity"}
               }
   },
   {   $project:{"_id":1,"totalprice":1}  },
   {   $limit:1  },
   {  $out:"myaggregate"  }], {"allowDiskUse":true}  )
    


gropu：
不可以多机器跨越查询，同时还有100m的限制
example
db.runCommand(
   {group:
       { ns: 'inventory',            //集合
         //key: { "description":1 },   //分组的key
         $keyf:function(doc){
             return {"description":1}      //doc: 当前的文档
          },
         cond: { "_id":{$gt:1} },    //where条件
         $reduce: function (curr, result) {//聚合进行中的每个操作
            //curr:   当前得到的document
            //result: 第一次就是我们目前的initial
                   result.count++;
            return result.total+=curr.instock;
         },
         initial: {"total":0,"count":0 },//聚合的初始文档
         finalize:function(result){      //在某一个groupkey结束后插入点
            result.avg=result.total/result.count;
         }
       }
   }
)



mapReduce：
db.runCommand(
               {
                 mapReduce: <collection>,
                 map: <function>,
                 reduce: <function>,
                 finalize: <function>,
                 out: <output>,
                 query: <document>,
                 sort: <document>,
                 limit: <number>,
                 scope: <document>,
                 jsMode: <boolean>,
                 verbose: <boolean>,
                 bypassDocumentValidation: <boolean>
               }
             )
example
var map=function() {emit(this.description,this.instock);  };
var reduce=function(key,values){return {"values":values};};
var myfinallize=function(key, reducedValue) {
    reducedValue.avg=reducedValue.values && reducedValue.values.length;
    return reducedValue;
}
db.runCommand({
                 mapReduce: "inventory",
                 map: map,
                 reduce: reduce,
                 finalize:myfinallize,
                 out: {inline:1}                 
               }
             )  
 result            
 "counts" : {
        "input" : 6,   //输入了6个文档
        "emit" : 6,    //映射了6个
        "reduce" : 2,  //reduce执行了2次
        "output" : 4   //最终输出是4个。
    }                      


Index索引：
Single Field     单键索引
Compound Index   复合索引
Multikey Index   多键值索引
Geospatial Index 地理索引
Text Indexes     全文索引 
Hashed Indexes   hash索引  O（1）的查找
Unique Indexes   唯一索引
Sparse Indexes   稀疏索引  
TTL  Indexes     过期索引

db.collection.createIndex(keys, options)  //创建索引
db.collection.getIndexes()                //查看集合索引
db.collection.totalIndexSize()            //查看集合索引大小
db.collection.dropIndexes()               //删除集合所有索引
db.collection.dropIndex("indexName")     //删除集合指定索引

options
background	建索引过程会阻塞其它数据库操作，background可指定以后台方式创建索引, 默认值为false。
unique	建立的索引是否唯一。指定为true创建唯一索引。默认值为false.
name	索引的名称。如果未指定，MongoDB的通过连接索引的字段名和排序顺序生成一个索引名称。
dropDups	在建立唯一索引时是否删除重复记录,指定 true 创建唯一索引。默认值为 false. 3.0+版本已废弃
sparse	对文档中不存在的字段数据不启用索引。默认值为 false.
expireAfterSeconds	指定一个以秒为单位的数值，完成 TTL设定，设定集合的生存时间。
v	        索引的版本号。默认的索引版本取决于mongod创建索引时运行的版本。
weights	引权重值，数值在 1 到 99,999 之间，表示该索引相对于其他索引字段的得分权重。
default_language	对于文本索引，该参数决定了停用词及词干和词器的规则的列表。 默认为英语
language_override	对于文本索引，该参数指定了包含在文档中的字段名，默认值为 language.

db.col.createIndex({"title":1,"desc":-1}) //复合索引 1指定按升序创建索引


存储引擎：
wiredtiger
1. Document Level Concurrency  文档级别的并发
2. Snapshots and Checkpoints   快照和（生成快照点） 
   checkpoint: 触发时机：  60s triiger, up to 2G
3. journal: 记录“checkpoint” 和 “checkpoint”的日志记录。
4. compression: wiredtiger会对collection，indexes进行压缩
5. memory use：wiretiger： internal，memorys 

mmapv1  内存文件隐射
In the default configuration for the MMAPv1 storage engine,
MongoDB writes to the data files on disk every 60 seconds 
and writes to the journal files roughly every 100 milliseconds。

in-memory enterpirse 基于内存的存储引擎
指定的方式：--storageEngine
设置占用的内容上限  --inMemorySizeGB



集群：
 master-slave  主从集群
slave会一直读取master的oplog.$main
slave中有一个sources集合，这个集合保存了master的信息
主从有一个10s的延迟

 replica set   副本集  【冗余性和高可用】
1. 初始化集群        rs.initiate() 
2. 查看集群的配置    rs.conf()  
3. 集群中添加members
rs.add("192.168.161.138:27001")
rs.add("192.168.161.138:27002")
rs.status()
rs.addArb("192.168.161.138:27003")   

{
    "set" : "ctrip",
    "date" : ISODate("2016-07-26T22:13:11.565+08:00"),
    "myState" : 1,
    "term" : NumberLong(1),
    "heartbeatIntervalMillis" : NumberLong(2000),
    "members" : [ 
        {
            "_id" : 0,
            "name" : "192.168.161.138:27000",
            "health" : 1.0,
            "state" : 1,
            "stateStr" : "PRIMARY",
            "uptime" : 376,
            "optime" : {
                "ts" : Timestamp(6311636496545742, 1),
                "t" : NumberLong(1)
            },
            "optimeDate" : ISODate("2016-07-26T22:13:08.000+08:00"),
            "electionTime" : Timestamp(6311635401329082, 1),
            "electionDate" : ISODate("2016-07-26T22:08:53.000+08:00"),
            "configVersion" : 4,
            "self" : true
        }, 
        {
            "_id" : 1,
            "name" : "192.168.161.138:27001",
            "health" : 1.0,
            "state" : 2,
            "stateStr" : "SECONDARY",
            "uptime" : 153,
            "optime" : {
                "ts" : Timestamp(6311636496545742, 1),
                "t" : NumberLong(1)
            },
            "optimeDate" : ISODate("2016-07-26T22:13:08.000+08:00"),
            "lastHeartbeat" : ISODate("2016-07-26T22:13:10.546+08:00"),
            "lastHeartbeatRecv" : ISODate("2016-07-26T22:13:08.557+08:00"),
            "pingMs" : NumberLong(0),
            "syncingTo" : "192.168.161.138:27000",
            "configVersion" : 4
        }, 
        {
            "_id" : 2,
            "name" : "192.168.161.138:27002",
            "health" : 1.0,
            "state" : 2,
            "stateStr" : "SECONDARY",
            "uptime" : 153,
            "optime" : {
                "ts" : Timestamp(6311636496545742, 1),
                "t" : NumberLong(1)
            },
            "optimeDate" : ISODate("2016-07-26T22:13:08.000+08:00"),
            "lastHeartbeat" : ISODate("2016-07-26T22:13:10.547+08:00"),
            "lastHeartbeatRecv" : ISODate("2016-07-26T22:13:08.550+08:00"),
            "pingMs" : NumberLong(0),
            "syncingTo" : "192.168.161.138:27000",
            "configVersion" : 4
        }, 
        {
            "_id" : 3,
            "name" : "192.168.161.138:27003",
            "health" : 1.0,
            "state" : 7,
            "stateStr" : "ARBITER",
            "uptime" : 1,
            "lastHeartbeat" : ISODate("2016-07-26T22:13:10.547+08:00"),
            "lastHeartbeatRecv" : ISODate("2016-07-26T22:13:08.562+08:00"),
            "pingMs" : NumberLong(0),
            "syncingTo" : "192.168.161.138:27000",
            "configVersion" : 4
        }
    ],
    "ok" : 1.0
}

sharding   分片  【负载均衡】
开启config服务器
开启mongos服务器
开启shard服务器【mongod进程】
//将mongod进程添加到sharding中
sh.addShard("192.168.161.138:27001")
sh.addShard("192.168.161.138:27002")
//在ctrip这个db上面启动分片功能
sh.enableSharding("ctrip") 
//在ctrip.plane上面开启分片功能，shard key 是 主键ID
sh.shardCollection("ctrip.plane",{"_id":1});

sh.status()
  sharding version: {
	"_id" : 1,
	"minCompatibleVersion" : 5,
	"currentVersion" : 6,
	"clusterId" : ObjectId("5798bcf3105de4fa3269d5c1")
}
  shards:
	{  "_id" : "shard0000",  "host" : "192.168.161.138:27001" }
	{  "_id" : "shard0001",  "host" : "192.168.161.138:27002" }
  active mongoses:
	"3.2.8" : 1
  balancer:
	Currently enabled:  yes
	Currently running:  no
	Failed balancer rounds in last 5 attempts:  0
	Migration Results for the last 24 hours: 
		No recent migrations
  databases:
	{  "_id" : "ctrip",  "primary" : "shard0000",  "partitioned" : true }
		ctrip.plane
			shard key: { "_id" : 1 }
			unique: false
			balancing: true
			chunks:
				shard0000	1
			{ "_id" : { "$minKey" : 1 } }
qq_30364013
关注
0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MongoDB

Mongodb 的document 16M Memcached 的value 1M Redis 的value 512MACID ：(Atomicity) 原子性、 (Consistency) 一致性、 (Isolation) 独立性、 (Durability) 持久性CAP：一致性（Consistency）、可用性（Availability）、分区容错性（Partition ...
复制链接

扫一扫