测试综合技能的期末预测

测试综合技能

选择，填空，判断

1. NoSQL数据库的四大类型：键值数据库、列族数据库、文档数据库、图数据库
2. NoSQL的特点：灵活的可扩展性、灵活的数据模型、和云计算的紧密集合
3. NoSQL的三大基石（理论基础）：CAP、BASE、最终一致性
4. 文档是MongoDB的核心单元
5. 关系型数据库中的表，相当于MongoDB的collection
6. 可遍历性是MongoDB将BSON作为数据存储的主要原因
7. 查看数据库命令show dbs，查看所有文档数据db.dept.find()，查看单独的一个文档db.dept.findOne()，删除当前数据库db.dropDatabase()，删除指定文档db.dept.remove({deptno:1}),关闭数据库：db.shutdownServer()；更新文档db.dept.update({deptno:2},{$set:{location:”Shenzhen”}}) 删除集合db.cl.drop()
8. MongoDB的写安全机制：非确认式写入、确认式写入、日志写入、复制确认式写入
9. 数据库索引是对数据库表中一列或多列的值进行排序的一种数据结构，单独开辟的数据结构，使用的是BTree的结构
10. MongoDB中支持的三种聚合方式：聚合管道、单目的聚合、MapReduce
11. Redis的特性：开源免费、支持持久化、存储类型丰富、支持数据备份
12. Redis的五大数据类型：String、list、set、Zset、hash
13. Redis是一个持久化的内存数据库，提供了不同级别的持久化方式，分别是RDB（指定时间间隔对数据进行快照存储）、AOF（记录每次对服务器写的操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据）
14. RDB有三种触发机制：save、bgsave、自动触发，AOF也有三种触发机制：每修改同步always、每秒同步everysec、不同no
    简答
    NoSQL数据库和关系型数据库的优劣势？
    传统的关系数据库：非常完备的关系理论基础、具有事务性机制的支持、高效的查询优化机制，有非常严格的标准，缺陷：无法满足海量数据的管理需求，数据模型不够灵活，无法满足高并发需求，无法满足高扩展性和高可用性的需求
    NoSQL数据库的优势：支持超大规模的数据存储，数据模型比较灵活，缺点：缺乏底层基础理论做支撑，很多NoSQL数据库都不支持事务的强一致性
    MongoDB有哪些特点？
    1）提供了一个面向文档存储，操作起来比较简单和容易2）可以设置任何属性的索引来实现更快的排序3）具有较好的水平可扩展性4）支持丰富的查询表达式，可以轻易查询文档中内嵌的对象及数组5）可以实现替换已完成文档的一些指定的数据字段6）MongoDB中的Map\Reduce主要是用来对数据进行批量处理和聚合操作7）支持各种编程语言8）安装简单
    内嵌文档和引用文档各有什么优势？
    内嵌文档好处：非扁平化的数据模式，使得信息的表示方式更加自然，还有可以保证对子文档进行原子性更新，从而实现关系型数据库中数据的特征，除此之外，嵌套文档模式，数据读取速度变快，只需要一次查询可以获得相应的数据。缺点：一方面子文档数据量大，整个文档加载更新的速度变慢，从而影响系统的效率，，如果这种情况下，子文档更细很频繁，会严重影响系统的性能，另一方面，子文档会造成大量的数据重复，如果子文档比较小，或者更新不是很频繁，建议选择内嵌文档模式。
    子文档比较大，文档大小经常改变时，应该考虑引用文档模式
    复制集的优势作用：
    复制集提供了冗余，并提高了数据的可用性；复制集增强了服务器的可读能力；复制集可以实现数据的备份，允许灾难恢复；复制集可以监控服务器的状态。
    Redis主从复制的作用，特点？
    特点：1）master可以拥有多个slave；2）多个slave可以连接同一个master外，还可以互相连接；3）主从复制不会阻塞master，在同步数据时，master可以继续处理client请求；4）提高系统的伸缩性
    作用：1）故障恢复：当主节点宕机，其他节点依然可以提供服务；2）负载均衡：Master节点提供写服务，slave节点提供读服务，分担压力；3）高可用基石：是哨兵和cluster实施的基础，是高可用的基石
    Redis是怎么来同步数据的？
    第一次从主库全量复制；主从库网络断开重连同步；主从正常运行期间的同步
    哨兵（Sentinel）机制？
    哨兵主要是为了解决在主从复制架构中出现宕机的情况，用于管理多个Redis服务器，执行三个任务：监控（不断的检查主服务器和从服务器是否正常运行）、提醒（当被监控的某个Redis服务器出现故障的时候，Sentinel可以通过API向管理员或其他应用程序发送通知）、自动故障转移（当一个主服务器出现故障时，Sentinel会开始一次自动故障迁移操作，它会将失效主服务器的其中一个从服务器升级为新的主服务器，并让失效主服务器的其他从服务器改为复制新的主服务器；当客户端试图连接失效的主服务器时，集群也会向客户端返回新主服务器的地址，使得集群可以使用新主服务器代替失效服务器）。实现目标：1）实现Redis故障转移的自动化2）自动发现，自动转移3）不需要人工参与
    大题 shell命令
    查询：
    1、查询comments字段不存在的文档
    db.bai.find({comments:{KaTeX parse error: Expected 'EOF', got '}' at position 13: exists:false}̲}); 2、查询favorit…all:[“头号玩家”,“肖生克的救赎”]}});
    3、查询name存在”bu”字符，并且age小于20或者大于24（要求使用regex操作符）
    db.bai.find({KaTeX parse error: Expected '}', got 'EOF' at end of input: and:[{name:{regex:“bu”}},{KaTeX parse error: Expected '}', got 'EOF' at end of input: or:[{age:{lt:20}},{age:{KaTeX parse error: Expected 'EOF', got '}' at position 6: gt:24}̲}]}]}); 4、查询use…elemMatch:{“userId”:“101”,“content”:“评论1”}}});
    5、查询name=”xiaobu”的文档，并且只显示comments前三条数据
    db.bai.find({“name”:“xiaobu”},{“comments”:{KaTeX parse error: Expected 'EOF', got '}' at position 12: slice:[0,3]}̲}); 6、查询所有name=…slice":[1,1]},“KaTeX parse error: Expected 'EOF', got '}' at position 6: id":1}̲); 7、查询被userId=…in:[“101”,“001”]}});
    或者db.users.find({KaTeX parse error: Expected 'EOF', got '}' at position 57: …userId":"001"}]}̲) 更新操作: 1、为name…set:{“country”:“China”}});
    2、为所有文档的favorites字段中 增加一个字段fruit 值为一个数组[apple,banana]
    db.bai.update({},{KaTeX parse error: Expected 'EOF', got '}' at position 43: …ple","banana"]}}̲,false,true); 3…or:[{age:{KaTeX parse error: Expected 'EOF', got '}' at position 6: lt:18}̲},{age:{gt:24}}]},{KaTeX parse error: Expected 'EOF', got '}' at position 27: …ites.movies":1}}̲,{multi:true});…push:{“favorites.fruit”:{$each:["grapes","watermelon"],$slice:-3}}});
    5、向存在favorites.books数组字段的文档中，在books数组的第二个元素位置添加元素“MongoDB”,“NoSQL”，并且数组元素按照升序排序
    db.bai.update({“favorites.books”:{KaTeX parse error: Expected 'EOF', got '}' at position 12: exists:true}̲},{push:{“favorites.books”:{$each:["MongoDB","NoSQL"],$position:1,KaTeX parse error: Expected 'EOF', got '}' at position 7: sort:1}̲}}); 聚合操作 1、根据姓…group:{_id:“KaTeX parse error: Expected '}', got 'EOF' at end of input: name",total:{sum:1}}}])
    2、根据姓名分组，并统计人数，过滤人数大于1的学生
    db.class1.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: group:{_id:"name”,num:{KaTeX parse error: Expected 'EOF', got '}' at position 6: sum:1}̲}},{match:{num:{KaTeX parse error: Expected 'EOF', got '}' at position 5: gt:1}̲}}]) 3、统计每名学生在考…group:{_id:“KaTeX parse error: Expected '}', got 'EOF' at end of input: sno",score:{sum:{$sum:["$score.chinese”,“$score.math","$score.english”]}}}}])
    或者
    db.class1.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …{sno:1,scores:{add:[“$score.chinese","$score.math”,“KaTeX parse error: Expected 'EOF', got '}' at position 16: score.english"]}̲}},{group:{_id:“KaTeX parse error: Expected '}', got 'EOF' at end of input: sno",score:{sum:“KaTeX parse error: Expected 'EOF', got '}' at position 8: scores"}̲}}]) 4、统计每名男生在考…match:{sex:0}},{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roject:{grade:{sum:[“$score.chinese","$score.math”,“KaTeX parse error: Expected 'EOF', got '}' at position 16: score.english"]}̲}}]) 或者 db.clas…match:{sex:0}},{KaTeX parse error: Expected '}', got 'EOF' at end of input: …,sex:1,scores:{sum:[“$score.chinese","$score.math”,“KaTeX parse error: Expected 'EOF', got '}' at position 16: score.english"]}̲}}]) 5、统计每名男生在考…match:{sex:0}},{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roject:{grade:{sum:[“$score.chinese","$score.math”,“KaTeX parse error: Expected 'EOF', got '}' at position 16: score.english"]}̲}},{sort:{grade:-1}}])
    或者
    db.class1.aggregate([{KaTeX parse error: Expected 'EOF', got '}' at position 14: match:{sex:0}}̲,{project:{_id:0,sex:1,totalnum:{$sum:["$score.chinese”,“$score.math","$score.english”]}}},{KaTeX parse error: Expected 'EOF', got '}' at position 19: …t:{totalnum:-1}}̲]) 6、统计总分最高与总分最…group:{_id:“KaTeX parse error: Expected '}', got 'EOF' at end of input: sno",score:{sum:{$sum:["$score.chinese”,“$score.math","$score.english”]}}}},{KaTeX parse error: Expected 'EOF', got '}' at position 15: sort:{score:1}}̲,{group:{_id:””,maxSno:{$first:"$_id”},maxScore:{$first:"$score”},minSno:{$last:"$_id”},minScore:{$last:"$score”}}},{KaTeX parse error: Expected 'EOF', got '}' at position 62: …o:1,minScore:1}}̲]) 7、统计每名的学生的平均…project:{_id:0,sno:1,name:1,arr:{$avg:["$score.chinese",“$score.math","$score.english”]}}}])
    8、统计所有学生总分的平均分数
    db.class1.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …id:null,score:{avg:{KaTeX parse error: Expected '}', got 'EOF' at end of input: sum:{sum:[“$score.chinese","$score.math”,“KaTeX parse error: Expected 'EOF', got '}' at position 16: score.english"]}̲}}}}]) 大题 Java …gte”, 2) .append(“$lt",5)).append("categories","Bakery"))3、collection.find(regex("name",{"}^{t}om"));遍历输出结果FindIterable<Document>iterable=collection.find()MongoCursor<Document>mongoCursor=iterable.iterator();while(mongoCursor.hasNext())System.out.println(mongoCursor.next());聚合操作collection.aggregate(Arrays.asList(Aggregates.match(eq("categories","Bakery")),Aggregates.group("$stars”, Accumulators.sum(“count”, 1))
    )
    );
    增加
    List documents = new ArrayList(); documents.add(doc1);
    documents.add(doc2);
    collection.insertMany(documents);
    collection.insertOne(document);
    修改
    import static com.mongodb.client.model.Updates.*;
    collection.updateMany( eq(“stars”, 2),
    combine(set(“stars”, 0), currentDate(“lastModified”)));

collection.updateOne( eq("_id", 1), combine(set(“name”, “Fresh Breads and Tulips”), currentDate(“lastModified”)),new UpdateOptions().upsert(true).bypassDocumentValidation(true));

删除：
collection.deleteMany(eq(“stars”, 4));
collection.deleteOne(eq("_id", 12)));

封装：
public class MongoUtil {
private MongoClient mongoclient;
private MongoDatabase mongodatabase;
private MongoCollection grade1;

// 连接数据库并获取collection的集合
public MongoUtil(String db, String collection) {
	// 连接到mongodb服务器
	mongoclient = new MongoClient("localhost", 27017);
	// 连接到数据库
	mongodatabase = mongoclient.getDatabase(db);
	// 获取集合
	grade1 = mongodatabase.getCollection(collection);
}

// 打印结果
public void printResult(FindIterable<Document> iterable) {
	MongoCursor<Document> cursor = iterable.iterator();
	// 循环输出
	while (cursor.hasNext()) {
		System.out.println(cursor.next());
	}
}

// 插入一条文档
public void insert(Document doc) {
	grade1.drop();
	grade1.insertOne(doc);
	System.out.println("插入成功");
}

// 插入多条文档
public void insert(List list) {
	grade1.drop();
	grade1.insertMany(list);
	System.out.println("插入成功");
}

// 过滤器的方法更新一个文档
public void updateOne(Bson filter, Document doc, UpdateOptions options) {
	UpdateResult re;
	if (options == null) {
		re = grade1.updateOne(filter, doc);
	} else {
		re = grade1.updateOne(filter, doc, options);
	}
	System.out.println(filter.toString()+"更新的结果是："+re.toString());
}

// 过滤器的方法更新所有的文档
public void updateMany(Bson filter, Document doc, UpdateOptions options) {
	UpdateResult re;
	if (options == null) {
		re = grade1.updateMany(filter, doc);
	} else {
		re = grade1.updateMany(filter, doc, options);
	}
	System.out.println(filter.toString()+"更新的结果是："+re.toString());
}

// 删除一条符合条件文档
public void deleteOne(Bson filter) {
	DeleteResult re = grade1.deleteOne(filter);
	System.out.println(filter.toString()+"删除的结果是："+re.toString());
}

// 删除符合条件的所有文档
public void deleteMany(Bson filter) {
	DeleteResult re = grade1.deleteMany(filter);
	System.out.println(filter.toString()+"删除的结果是："+re.toString());
}

// 聚合操作
public void aggregate(List<? extends Bson> arrays) {
	AggregateIterable<Document> iterable = grade1.aggregate(arrays);
	MongoCursor<Document> mongoCursor = iterable.iterator();

	while (mongoCursor.hasNext()) {
		System.out.println(mongoCursor.next());
	}
}

//遍历所有的
public void findAll() {
	//生成文档的迭代对象
	FindIterable<Document> find = grade1.find();
	//调用自己写的printResult()函数，打印结果
	printResult(find);
}

//根据条件遍历
public void findAll(Document doc) {
	FindIterable<Document> find = grade1.find().sort(doc);
	MongoCursor<Document> cursor = find.iterator();
	while(cursor.hasNext()) {
		System.out.println(cursor.next());
	}
}

// 有查询条件，以文档的形式查询
public void findFilter(Document doc) {
	FindIterable<Document> find = grade1.find(doc);
	printResult(find);
}

// 过滤器的形式查询
public void findFilter(Bson filter) {
	FindIterable<Document> find = grade1.find(filter);
	printResult(find);
}

}

public class MongoTest {

public static void main(String[] args) {
	//连接test数据库,并使用javatest集合
	MongoUtil mo = new MongoUtil("test","javatest");
	//定义插入的文档list
	List<Document> lists =new ArrayList<Document>();
	Document doc = null;
	//循环添加数据到集合javatest
	for(int i=1;i<=10;i++) {
		doc = new Document();
		Document doc1= new Document();
		doc.append("name", "zhangsan"+i);
		doc.append("sex", Math.round(Math.random() * 10) % 2);
		doc.append("age", Math.round(Math.random() * 6) + 3);
		doc.append("hobby", doc1);
		lists.add(doc);
		System.out.println(doc);
	}
	//插入数据到集合
	mo.insert(lists);

// 2、grade1中，追加zhangsan7`学生兴趣爱好为唱歌
Bson filter2 = Filters.eq(“name”, “zhangsan7”);
Document doc2 = new Document("$set",new Document(“hobby”,“唱歌”));
mo.updateOne(filter2,doc2,null);

// 3、 给grade1所有学生的年龄都增加一岁
Bson filter3 = Filters.exists("_id");
Document doc3 = new Document("$inc",new Document(“age”,1));
mo.updateMany(filter3,doc3,null);

// 4、grade1中删除zhangsan7学生的sex字段
Bson filter4 = Filters.eq(“name”,“zhangsan7”);
Document doc4 = new Document("$unset",new Document(“sex”,""));
mo.updateOne(filter4,doc4,null);

// 5、查看grade1的学生，按年纪升序
Document doc5 = new Document(“age”,1);
mo.findAll(doc5);

// 6、统计sex为0 的学生的个数以及所有学生的平均年龄
List list6 = Arrays.asList(Aggregates.match(Filters.eq(“sex”,0)),Aggregates.group("$sex",Accumulators.avg(“count”,1)));
mo.aggregate(list6);

// 7、删除sex为0并且age大于5的学生
Bson filter7 = Filters.and(Filters.eq(“sex”,0),Filters.gt(“age”, 5));
mo.deleteMany(filter7);
}
}