科研部建设中，覆盖歌云端实验平台对于Neoj4、MongoDB 的实验项目

目录

目录

​编辑

Neo4j  实验一、二

MonGoDB实验三、四

实验五六、redis

Neo4j  实验一、二

//NoSQL专项
1. 第1关：创建第一个Neo4j数据库节点
      CREATE (
       TomC:Person 
       {
         name:'Tom Cruise', 
         born:1962
       }
     )
2. 第2关：一次创建多个演员节点
   UNWIND [
        {name:'Tom Hanks',born:1956}, 
        {name:'Keanu Reeves',born:1964},
        {name:'Tom Cruise',born:1962}
    ] AS row
    CREATE (p:Person) 
    SET p.name=row.name, p.born=row.born 
3. 第3关：一次创建多个电影节点
UNWIND [
    {title:"You've Got Mail",       released:1998,tagline:'At odds in life... in love on-line.'}, 
    {title:'Sleepless in Seattle',  released:1993,tagline:'What if someone you never met, someone you never saw, someone you never knew was the only someone for you?'}, 
    {title:'The Da Vinci Code',     released:2006,tagline:'Break The Codes'}
] AS row
CREATE (m:Movie) SET m.title=row.title, m.released=row.released , m.tagline=row.tagline 

4. 第4关：查找所有标签为Person的节点
    MATCH (n:Person) 
    RETURN n
5. 第5关：查找名字为Tom Cruise的节点
    MATCH (n) 
    WHERE n.name = 'Tom Cruise' 
    RETURN n
6. 第6关：查找数据库中发行年在1990与2000之间的电影
    MATCH (n:Movie) 
    WHERE n.released > 1900 and n.released <2000
    RETURN n
查找数据库中发行年在1990与2000之间的电影。
7. 第7关：修改节点的属性
    MATCH(n)
    WHEREID(n)= 116  
    SET n.age = 40
    RETURN n
在数据库中查找   ID为116    的节点，修改或新建age属性，并赋值为40。
    MATCH(n)
    WHERE name(n)= 'Tom Cruise' 
    SET n.gender = 'male'
    SET n.roles = 'Forrest Gump' 
修改   名字为Tom Cruise的节点    的gender属性为male，roles属性为Forrest Gump。
    MATCH(n)
    WHERE n.name= 'Tom Cruise' 
    SET n.gender = 'male'
    SET n.roles = 'Forrest Gump' 
8. 第8关：为节点增加标签
    MATCH (n) 
    WHERE ID(n)= 116  
    SET n : Actor 
    RETURN n
在数据库中查找ID为116的节点，为节点n增加Actor标签。
    MATCH (n) 
    WHERE n.name = 'Tom Cruise'
    SET n : Actor 
为Tom Cruise节点增加标签Actor。

9. 第9关：删除节点属性
    MATCH (yyds{name:’Tiger’}) 
    REMOVE yyds.age 
    return yyds
在数据库中查找name为Tiger的节点，删除其age属性。
    MATCH (t) 
    where t.name = 'Tom Cruise'
    REMOVE t.gender
删除Tom Cruise节点的gender属性。

10. 第10关：删除节点标签
    MATCH (n)
    WHERE ID(n)= 116  
    REMOVE n : Actor
    RETURN n
在数据库中查找ID为116的节点，删除节点n的Actor标签。
    MATCH (n)
    WHERE n.name = 'Tom Cruise' 
    REMOVE n : Actor
删除Tom Cruise节点的Actor标签。


1. 第1关：增加节点与联系
    CREATE  
        (:)-
            [:]->
        (:)
    RETURN 
功能：创建一个新节点node1,node2，并在两个节点间建立联系relationship1。
    CREATE
     (fb1:Student{name:"Tom"})-
        [like:LIKES]->
    (fb2:Student{name:"Jerry"})
在数据库中创建名称为Tom标签是Student的节点、名称为Jerry标签是Student的节点，并在Tom和Jerry两个节点之间建立了联系，该联系的标签为LIKES。
    CREATE
     (fb1:Person{name:"Tom Hanks",born:1956})-
        [like:ACTED_IN]->
    (fb2:Movie{title:'The Da Vinci Code', released:2006 , tagline:'Break The Codes'})
1）增加标签为Person的节点，其name值为Tom Hanks，born值为1956。
2）增加标签为Movie的节点，其title为'The Da Vinci Code', released值为2006, tagline为'Break The Codes'。
3）在这两个节点之间建立标签为ACTED_IN的联系。

2. 第2关：为已有节点增加联系
    MATCH  
        (:), (:)
    WHERE 
        
    CREATE 
        (node1)-[:]->(node2)
功能：匹配节点node1,node2，并在两个节点间建立联系relationship1。
    MATCH
        (fb1:Student{name:"Tom"}),(fb2:Student{name:"Jerry"})
    CREATE 
        (fb1)-[like:LIKES]->(fb2)
在数据库中查找名称为Tom标签是Student的节点、名称为Jerry标签是Student的节点，并在Tom和Jerry两个节点之间建立了联系，该联系的标签为LIKES。
    MATCH
        (fb1:Person{name:"Tom Hanks"}),(fb2:Movie{title:'The Da Vinci Code'})
    CREATE 
        (fb1)-[like:ACTED_IN]->(fb2)
1）查找标签为Person的节点，其name值为Tom Hanks。
2）查找标签为Movie的节点，其title为'The Da Vinci Code'。
3）在这两个节点之间建立标签为ACTED_IN的联系。


3. 第3关：查找节点间联系
    MATCH  
    (:)-
        [:]->
    (:)
    WHERE 
    RETURN node1,node2,relationship1
功能：先匹配节点node1,node2及联系relationship1，然后返回node1,node2,relationship1。
示例如下：
    MATCH
        (fb1:Student{name:"Tom"})-
            [like:LIKES]->
        (fb2:Student{name:"Jerry"})
     RETURN fb1,fb2,like;
在数据库中查找名称为Tom标签是Student的节点、名称为Jerry标签是Student的节点
以及Tom和Jerry两个节点之间的联系like，然后返回节点及联系
    MATCH
        (fb1:Person{})-
            [r:ACTED_IN]->
        (fb2:Movie{})
    where fb1.name = "Tom Hanks"
    RETURN r;
1）匹配标签为Person的节点，其name值为Tom Hanks。
2）匹配标签为Movie的节点。
3）返回符合条件节点之间标签为ACTED_IN的联系。
4. 第4关：删除节点间联系
    MATCH 
        (fb1:Student{name:"Tom"})- 
            [r:LIKES]-> 
        (fb2:Student{name:"Jerry"}) 
    DELETE r;
在数据库中查找名称为Tom标签是Student的节点、名称为Jerry标签是Student的节点，以及Tom和Jerry两个节点之间的联系like，然后删除该联系。
    MATCH 
        (fb1:Person{name:"Tom Hanks"})- 
            [r:ACTED_IN]-> 
        (fb2:Movie{title:'The Da Vinci Code'}) 
    DELETE r;
请使用MATCH-CREATE语句，
1）查找标签为Person的节点，其name值为Tom Hanks。
2）查找标签为Movie的节点，其title为'The Da Vinci Code'。
3）删除这两个节点之间标签为ACTED_IN的联系。

5. 第5关：为联系增加属性
    MATCH  
       (:), (:)
    WHERE 
    CREATE (node1)-[:
      {property1:value1},
      ...
      {propertyn:valuen}]->
      (node2)
功能：匹配节点node1,node2，并在两个节点间建立联系relationship1。
    MATCH
        (fb1:Student{name:"Tom"}),(fb2:Student{name:"Jerry"})
     CREATE 
        (fb1)-
            [like:LIKES{startdate:'2000-1-1'}]->
        (fb2)
在数据库中查找名称为Tom标签是Student的节点、名称为Jerry标签是Student的节点
并在Tom和Jerry两个节点之间建立了联系，该联系的标签为LIKES,开始时间是2000-1-1。
    MATCH
        (fb1:Person{name:"Tom Hanks"}),(fb2:Movie{title:'The Da Vinci Code'})
     CREATE 
        (fb1)-
            [r1:ACTED_IN{roles:['Dr. Robert Langdon']}]->
        (fb2)
请使用MATCH-CREATE语句，
1）查找标签为Person的节点，其name值为Tom Hanks。
2）查找标签为Movie的节点，其title为'The Da Vinci Code'。
3）在这两个节点之间建立标签为ACTED_IN的联系，联系属性是roles:['Dr. Robert Langdon']。

6. 第6关：修改联系属性
    MATCH  
       (:)-[:]->(:)
    WHERE 
    SET r.property1 = value1,
      ...
      r.propertyn = valuen;
功能：匹配节点node1,node2及联系r，并未联系r设置一组属性及值
    MATCH
        (fb1:Student{name:"Tom"})-
            [r1:LIKES]->
        (fb2:Student{name:"Jerry"})
    SET
      r1.startdate = '2000-1-1'
在数据库中查找名称为Tom标签是Student的节点、名称为Jerry标签是Student的节点及联系like
该联系的标签为LIKES,设置like联系的属性开始时间是2000-1-1。
    MATCH
        (fb1:Person{name:"Tom Hanks"})-
            [r1:ACTED_IN]->
        (fb2:Movie{title:'The Da Vinci Code'})
    SET
      r1.roles = ['Dr. Robert Langdon']
1）查找标签为Person的节点，其name值为Tom Hanks。
2）查找标签为Movie的节点，其title为'The Da Vinci Code'。
3）查找两个节点之间标签为ACTED_IN的联系。
4）设置联系属性roles的值为['Dr. Robert Langdon']。

7. 第7关：删除联系属性
示例如下：
    MATCH
        (fb1:Student{name:"Tom"})-
            [like:LIKES]->
        (fb2:Student{name:"Jerry"})
    REMOVE
        like.startdate 
在数据库中查找名称为Tom标签是Student的节点、
名称为Jerry标签是Student的节点及联系like，
该联系的标签为LIKES,删除like联系的属性开始时间。
题目要求
    MATCH
        (fb1:Person{name:"Tom Hanks"})-
            [r1:ACTED_IN]->
        (fb2:Movie{title:'The Da Vinci Code'})
    REMOVE
        r1.roles
请使用MATCH-CREATE语句，
1）查找标签为Person的节点，其name值为Tom Hanks。
2）查找标签为Movie的节点，其title为'The Da Vinci Code'。
3）查找两个节点之间标签为ACTED_IN的联系。
4）删除联系属性roles。
8. 第8关：查找节点的邻接节点
查找联系的一般语法如下：
    MATCH  
       (:)-[:]->(:)
    WHERE 
    RETURN node1,node2
功能：先匹配节点node1,node2及联系relationship1，然后返回node1,node2。
node2即是node1的邻接节点。
示例如下：
    MATCH
    (fb1:Person{name:"Tom Hanks"})
        -[s:Study]->
    (fb2:Database)
    RETURN fb2;
在数据库中查找名称为Tom、标签是Student的节点,再查找Tom所学的数据库课程
    MATCH
        (n:Person{name:"Tom Hanks"})
            -[r1:ACTED_IN]->
        (m:Movie)
    RETURN m.title,r1.roles
    order by m.title
    limit 10
查询Tom Hanks参演过电影
返回电影title、及其角色roles
并按照title排序
最终结果返回前10个

9. 查找节点的共同邻接节点
    MATCH
        (fb1:Student{name:"Tom"})
            -[s:Study]->
                (r1:Database{name:"Neo4j"})
            <-[s:Study]-
        (fb2:Student)
     RETURN fb1,r1,fb2;
在数据库中查找名称为Tom、标签是Student的节点
再查找与Tom一起学习neo4j的学生。
    MATCH
        (fb1:Person{name:"Tom Hanks"})
            -[s1:ACTED_IN]->
                (m:Movie{})
            <-[r2:ACTED_IN]-
        (fb2:Person)
     RETURN m.title , fb2.name , r2.roles
     order by m.title , fb2.name
     limit 10
查询和Tom Hanks共同参演过电影的演员
返回电影title、共同参演的演员name及其角色roles
并按照title，name排序，最终结果返回前10个
10. 最短路径
    MATCH
        p=shortestPath(
            (fb1:Student{name:"Tom"})
                -[*1..4]-
            (fb2:Student{name:"Jerry"})
        )
    RETURN p;
在数据库中查找Tom和Jerry之间的最短路径。
    MATCH
        P=shortestPath(
            (fb1:Person{name:"Tom Hanks"})
                -[*1..4]-
            (fb2:Person{name:"Tom Cruise"})
        )
    RETURN P;
1）查询Tom Hanks和Tom Cruise之间5步之内的最短路径。

MonGoDB实验三、四

第1关：数据库创建
    创建或切换  use Testdb
    删除        db.dropDatabase()
    插入        db.Testdb.insert({_id:1,name:"王小明"})
在命令行操作
mongo
use mydb
db.mydb.insert({_id:1,name:"李小红"})

第2关：创建集合
先进入指定数据库，在 Testdb 数据库中创建创建固定集合 test ，整个集合空间大小512000KB，文档最大个数为1000个
    use Testdb
    db.createCollection("test", { capped : true, autoIndexId : true, size : 512000, max : 1000 } )
创建集合命令（推荐）：db.集合名.insert()
（注意：一条数据用大括号“ {} ”括起来，多条数据用“ [] ”将所有数据括起来）
    db.mytest2.insert([{"name" : "王小明","sex":"男"},{"name" : "李小红","sex":"女"}])
MongoDB 中存储的文档 必须 有一个_id键
查询集合命令：db.集合名.find()
删除集合命令：db.集合名.drop()
创建数据库 Testdb2，创建集合 t_stu ，内容如图3所示
    mongo
    use Testdb2
    db.createCollection("t_stu", { capped : true, autoIndexId : true, size : 512000, max : 1000 } )    
    db.testdb2.insert([
        {"_id" :1,"name" : "小明","sex":"男","hobbies":["乒乓球","羽毛球"]},
        {"_id" :2,"name" : "小红","sex":"女","hobbies":["画画","唱歌"]}
    ])

第3关：文档操作一
插入文档命令：db.集合名.insert(文档)
数据定义为一个变量，之后再插入
    document=({_id:1,
        name: '王小明',
        sex: '男',
        hobbies: ['乒乓球','羽毛球'],
        birthday: '1996-02-14'
    });
    db.person.insert(document)  
update方法    
    db.person2.update({birthday:"1996-02-14"},{$set:{birthday:"1996"}})
.find(). pretty() 可以保持整齐格式输出
save方法
    db.person3.save({
        "_id" :1,
        "name" : "李小红",
        "sex" : "女",
        "hobbies" : [
                "画画",
                "唱歌",
                "跳舞"
        ],
        "birthday" : "1996-06-14"
    })
如果 save() 法也指定了_id，则对文档进行更新;
未指定_id则会执行插入功能，MongoDB 默认自动生成一个不重复的_id
    update() 方法仅适用于修改某条数据中的某个键值；
    save() 方法适用于修改整条数据。
mongo
use Testdb3 
    document=({
        _id:1,
        name: '张小华',
        sex: '男',
        phone: '12356986594',
        hobbies: [
                "打篮球",
                "踢足球",
                "唱歌"
        ]
    });
    db.stu1.insert(document)  
    db.stu2.insert(document)  
    db.stu3.insert(document)  
db.stu2.update({phone:"12356986594"},{$set:{phone:"18356971462"}})
    db.stu3.save({
        _id:1,
        name: '张晓晓',
        sex: '女',
        phone: '12365498704',
        hobbies: [
                "跳舞",
                "羽毛球",
                "唱歌"
        ]
    });
第4关：文档操作二
db.集合名称.find().pretty()
操作 	格式 	                        范例 	                                    关系数据库中类似的语句
等于 	{:} 	            db.stu1.find({"name":"李小红"}).pretty() 	where name = '李小红'
小于 	{:{$lt:}} 	        db.stu1.find({"age":{$lt:18}}).pretty() 	where age < 18
小于等于{:{$lte:}} 	        db.stu1.find({"age":{$lte:18}}).pretty() 	where age <= 18
大于 	{:{$gt:}} 	        db.stu1.find({"age":{$gt:18}}).pretty() 	where age > 18
大于等于{:{$gte:}} 	        db.stu1.find({"age":{$gte:18}}).pretty() 	where age >= 18
不等于 	{:{$ne:}} 	        db.stu1.find({"age":{$ne:18}}).pretty() 	where age != 18
and      db.stu1.find({"age":20, "sex":"男"}).pretty()
删除指定的数据                          db.stu1.remove({'age':20})
删除全部数据但是保留集合                 db.remove({})
定义多个数据
    document=([{
        name:'张小华',
        sex:'男',
        age:20,
        phone:'12356986594',
        hobbies:['打篮球','踢足球','唱歌']
    },{
        name:'李小红',
        sex:'女',
        age:18,
        phone:'12355487536',
        hobbies:['跳舞','唱歌']
    }])
插入集合    db.stu1.insert(document)
测试开始  放入echo内
echo "
document=([{
        _id:1,
        name:'西西',
        sex:'女',
        age:23,
        national:'汉族'
    },{
        _id:2,
        name:'东东',
        sex:'男',
        age:20,
        national:'苗族'
    },{
        _id:3,
        name:'北北',
        sex:'男',
        age:19,
        national:'汉族'
    },{
        _id:4,
        name:'南南',
        sex:'女',
        age:15,
        national:'傣族'
    }]);
db.stu1.insert(document);
db.stu2.insert(document);
db.stu1.find({'age':{\$gte:15},'sex':'女'});
db.stu1.find({'national':'苗族'});
db.stu1.find({'age':{\$lt:20},'sex':'男'});
db.stu2.remove({});
"
上述操作共有六条命令，请按要求填入右侧代码栏 Begin-End 中
每条命令以英文分号“ ;”号隔开
（由于测试需要，请在“ $ ” 前加 “ \ ” （转义符））。

第1关：数据的导入导出
导入数据
    mongoimport -d Testdb1 -c score --type csv --headerline --ignoreBlanks --file test.csv
-d Testdb1 ：指定将数据导入到 Testdb1 数据库；
-c score ：将数据导入到集合 score ，如果这个集合之前不存在，会自动创建一个
    （如果省略 --collection 这个参数，那么会自动新建一个以  CSV 文件名为名的集合）；
--type csv ：文件类型，这里是 CSV；
--headerline ：这个参数很重要，加上这个参数后创建完成后的内容会以 CSV 文件第一行的内容为字段名
    （导入json文件不需要这个参数）
--ignoreBlanks ：这个参数可以忽略掉 CSV 文件中的空缺值（导入json文件不需要这个参数）；
--file 1.csv ：这里就是 CSV 文件的路径了，需要使用绝对路径
导出数据
    mongoimport -d Testdb1 -c score --type csv --headerline --ignoreBlanks --file test.csv
    -d Testdb1 ：指定将数据导入到 Testdb1 数据库；
    -c score ：将数据导入到集合 score ，如果这个集合之前不存在，会自动创建一个
（如果省略 --collection 这个参数，那么会自动新建一个以  CSV 文件名为名的集合）；
    --type csv ：文件类型，这里是 CSV；
    --headerline ：这个参数很重要，加上这个参数后创建完成后的内容会以 CSV 文件第一行的内容为字段名
（导入json文件不需要这个参数）
    --ignoreBlanks ：这个参数可以忽略掉 CSV 文件中的空缺值（导入json文件不需要这个参数）；
    --file 1.csv ：这里就是 CSV 文件的路径了，需要使用绝对路径。
导出 json 格式文件：
        mongoexport -d Testdb1 -c score -o /file.json --type json
        -o /file.json ：输出的文件路径/（根目录下）和文件名；
        --type json ：输出的格式，默认为 json。
导出 csv 格式的文件：
        mongoexport -d Testdb1 -c score -o /file.json --type csv -f "_id,name,age,sex,major"
        -f ：当输出格式为 csv 时，需要指定输出的字段名。
    將 /home/example 路径下的文件 student.csv 导入到数据库 mydb1 的 test 集合中；
mongoimport -d mydb1 -c test --type csv --headerline --ignoreBlanks --file /home/example/student.csv
    将数据库 mydb1 的 test 集合以 json 格式导出到 /home/test1.json 的 json 文件中；
mongoexport -d mydb1 -c test -o /home/test1.json --type json
    将数据库 mydb1 的 test 集合以 csv 格式导出到 /home/test1.csv 的 CSV 文件中。
mongoexport -d mydb1 -c test -o /home/test1.csv --type csv -f "_id,name,age,sex,major"


第2关：高级查询（一）
匹配所有    db.hobbies.find({hobbies:{$all:["唱歌","羽毛球"]}})
判断存在    $exists
mod运算     db.hobbies.find({age:{$mod:[7,4]}})
包含        db.hobbies.find({age:{$in:[17,20]}})
不包含      db.hobbies.find({age:{$nin:[17,20]}})
长度查询    db.hobbies.find({hobbies:{$size:2}})
结果排序    db.collection.find().sort({_id:1})     #将查询结果按照_id升序排序
           db.collection.find().sort({_id:-1})    #将查询结果按照_id降序排序
将 /home/example/person.json 文件导入到数据库 mydb2 中的 test 集合中
mongoimport -d mydb2 -c test --type json --file /home/example/person.json  
执行查询命令，查找  所有喜欢唱歌和跳舞的人的信息，      并按照_id升序排序
执行查询命令，查找  所有喜欢羽毛球和跳舞的人的信息，    并按照_id升序排序
执行查询命令，查找  有3个爱好的人的信息，               并按照_id升序排序
执行查询命令，查找  文档中存在 hobbies 字段的人的信息， 并按照_id升序排序
执行查询命令，查找  19岁和23岁的人的信息，              并按照_id升序排序
执行查询命令，查找  不是20岁的人的信息，                并按照_id升序排序
执行查询命令，查找  age 取模9等于2的人的信息，          并按照_id升序排序
echo "
db.test.find({hobbies:{\$all:['唱歌','跳舞']}})          .sort({_id:1});
db.test.find({hobbies:{\$all:['羽毛球','跳舞']}})        .sort({_id:1});
db.test.find({hobbies:{\$size:3}})                      .sort({_id:1});
db.test.find({hobbies:{\$exists:true}})                 .sort({_id:1});
db.test.find({age:{\$in:[19,23]}})                      .sort({_id:1});
db.test.find({age:{\$nin:[20]}})                        .sort({_id:1});
db.test.find({age:{\$mod:[9,2]}})                       .sort({_id:1}); 
"


第3关：高级查询（二）
或查询    db.student.find({$or:[{sex:"男"},{age:18}]})db.student.find({$or:[{sex:"男"},{age:18}]})
且查询    db.student.find({$and:[{age:{$gt:18}},{age:{$lt:21}}]})
取反      db.student.find({age:{$not:{$gte:20}}})
匹配      db.student.find({major:{$not:/^计.*/}})
数数      db.student.find({major:{$not:/^计.*/}}).count()
将 /home/example/person.json 文件导入到数据库 mydb3 中的 test 集合中。
    执行查询命令，查找  年龄为20岁男生的信息            ，并按照_id升序排序
    执行查询命令，查找  年龄为20岁或者性别为男生的信息   ，并按照_id升序排序
    执行查询命令，查找  name = 韩*开头的人的信息        ，并按照_id升序排序
    执行查询命令，查找  年龄19 =< age < 22的人的信息    ，并按照_id升序排序
    执行查询命令，查找  年龄age < 19或age >21的信息     ，并按照_id升序排序
    执行查询命令，查找  name != 韩*开头的人的信息       ，并按照_id升序排序
    执行查询命令，查找  name != 韩*开头的人             的个数
    执行查询命令，查找  年龄19 =< age < 22的人          的个数
mongoimport -d mydb3 -c test --type json --file /home/example/person.json
echo "
db.test.find({$and:[{age:20},{sex:'男'}]})                     .sort({_id:1}); 
db.test.find({$or: [{age:20},{sex:'男'}]})                     .sort({_id:1});
db.test.find({name:/^韩.*/})                                    .sort({_id:1}); 
db.test.find({$and:[{age:{$gte:19}},{age:{$lt:22}}]})        .sort({_id:1});
db.test.find({$or: [{age:{$lt:19}} ,{age:{$gt:21}}]})        .sort({_id:1});
db.test.find({name:{$not:/^韩.*/}})                            .sort({_id:1}); 
db.test.find({name:{$not:/^韩.*/}})                            .count();
db.test.find({$and:[{age:{$gte:19}},{age:{$lt:22}}]})        .count();
"

第4关：游标
使用循环插入数据
    for(var i=0;i<10000;i++)db.items.insert({_id:i,text:"Hello MongoDB"+i})
申明游标，ind 的查询结果（_id<=5）赋值给了游标 cursor 变量
    var cursor=db.items.find({_id:{$lte:5}})
mongo
use mydb4
for(var i=0;i<10000;i++)db.test.insert({_id:i,title:"MongoDB"+i,content:"hello"+i});
exit
mongoexport -d mydb4 -c test -f _id.title,content -o /home/test/test4.csv --type csv

实验五六、redis

【实验5】
1.聚合管道操作符将文档定制格式输出（一）
mongo
use test1
db.educoder.insert({_id:1,course:'Python表达式问题求解实训',author:'李暾',tags:['Python基础','求解'],learning_num:1882})
db.educoder.insert({_id:2,course:'Java语言之基本语法',author:'余跃',tags:['Java基础','语法'],learning_num:814})
db.educoder.insert({_id:3,course:'Python面向对象编程实训',author:'李暾',tags:['Python基础','面向对象'],learning_num:143})
db.educoder.insert({_id:4,course:'Android综合实训之物联网移动应用开发（1）',author:'prophet5',tags:['Android','物联网','移动开发'],learning_num:207})
db.educoder.aggregate({$project:{_id:0,course:1,learning_num:1}});
db.educoder.aggregate({$match:{learning_num:1882}});

2.聚合管道操作符将文档定制格式输出（二）?
use test2
db.educoder.insert({_id:1,course:'Python表达式问题求解实训',author:'李暾',tags:['Python基础','求解'],learning_num:1882}) 
db.educoder.insert({_id:2,course:'Java语言之基本语法',author:'余跃',tags:['Java基础','语法'],learning_num:814}) 
db.educoder.insert({_id:3,course:'Python面向对象编程实训',author:'李暾',tags:['Python基础','面向对象'],learning_num:143}) 
db.educoder.insert({_id:4,course:'Android综合实训之物联网移动应用开发（1）',author:'prophet5',tags:['Android','物联网','移动开发'],learning_num:207}) 
db.educoder.aggregate({$limit:3});
db.educoder.aggregate({$sort:{learning_num:1}});
db.educoder.aggregate({$skip:2});

3.第3关：聚合表达式对文档数据进行统计
use test3
 
db.educoder.insert([
{_id:1,course:'Python表达式问题求解实训',author:'李暾',tags:['Python基础','求解'],learning_num:1882},
{_id:2,course:'Java语言之基本语法',author:'余跃',tags:['Java基础','语法'],learning_num:814},
{_id:3,course:'Python面向对象编程实训',author:'李暾',tags:['Python基础','面向对象'],learning_num:143},
{_id:4,course:'Android综合实训之物联网移动应用开发（1）',author:'prophet5',tags:['Android','物联网','移动开发'],learning_num:207}])
BulkWriteResult({
        "writeErrors" : [ ],
        "writeConcernErrors" : [ ],
        "nInserted" : 4,
        "nUpserted" : 0,
        "nMatched" : 0,
        "nModified" : 0,
        "nRemoved" : 0,
        "upserted" : [ ]
})
db.educoder.aggregate([{$group:{_id:'$author',first_course:{$first:'$course'}}}]);
db.educoder.aggregate([{$group:{_id:'$author',learning_avg:{$avg:'$learning_num'}}}]);
db.educoder.aggregate([{$unwind:'$tags'},{$group:{_id:'$tags',course_num:{$sum:1}}}]);


【实验6】  redis-cli启动服务器
1.Redis中的数据结构
set hello redis
lpush educoder-list hello
rpush educoder-list educoder
rpush educoder-list bye
rpop educoder-list
sadd educoder-set c
sadd educoder-set python
sadd educoder-set redis
srem educoder-set c
hset educoder-hash python language
hset educoder-hash ruby language
hset educoder-hash redis database
hdel educoder-hash ruby
zadd educoder-zset 200 jack
zadd educoder-zset 400 rose
zadd educoder-zset 100 lee
2. 使用 Python 与 Redis 交互
import redis
pool= redis.ConnectionPool(host='localhost',port=6379,decode_responses=True)
r=redis.Redis(connection_pool=pool)
def write_redis():
    r.set("test1", "hello")
    r.set("test2", "Redis")
3. 字符串、列表与集合
import redis
conn = redis.Redis()
def task_empty():
    return int(conn.llen("task_list"))==0
def get_task():
    task = conn.rpop("task_list")
    conn.set("current_task",task)
def get_unallocated_staff():
    staff=conn.srandmember("unallocated_staff")
    conn.smove("unallocated_staff","allocated_staff",staff)
    return staff
def allocate_task(staff):
    conn.append("current_task",':'+str(staff))
    conn.lpush("task_queue",conn.get("current_task"))
    conn.set("current_task","None")
4. 哈希与有序集合
import redis
conn = redis.Redis()
def set_task_info(task_id):
    conn.hset("task_status",task_id,"init")
def add_task_to_queue(task_id, priority):
    conn.zadd("task_queue",task_id,int(priority))
    set_task_info(task_id)
def get_task():
    task_list_by_priority=conn.zrevrange('task_queue',0,-1)
    current_task=task_list_by_priority[0]
    conn.zrem('task_queue',current_task)
    conn.hset("task_status",current_task,"processing")
    return current_task