몽고db 실습예제

//MongoDB
//Aggregation
 
//외부파일 importk, log data도 가능
//employees, zipcode를 import
//mongo bin폴더에 복사 붙여넣기 후 cmd 창 열기
//mongoimport --db hellomongo --collection employees --type json -drop --file "employees.json"
//mongoimport --db hellomongo --collection zipcode --type json --file "zipcode.json"
// mongoimport --db hellomongo --collection employees --type json --file "employees.json"
//in - 일부만 만족
//부서가 10, 20에 포함된 결과를 출력
db.employees.find(
  {
    deptno:{$in:[10, 20]}
  }
)
 
//all - 모두 다 만족
//10과 20을 모두 포함
db.employees.find(
  {
    deptno:{$all:[10,20]}
  }
)
 
//exist : true - 존재하는 document를 뽑아내라 (필드 존재 유무 검사)
db.employees.find(
  {
    comm:{$exists: true}
  }
)
 
//type 검사 (1 double, 2 String, 3 Object, 4 array, ...20가지)
db.employees.find(
  {
    comm:{$type: 1}
  }
)
 db.employees.find({ename:{$type:2}})
//Aggregate : 집계 (RDBMS 에서의 sum, min, group by, ... )
// - 내부 문서 검색 시 빠른 속도.
// - 프레임워크 Map-Reduce 를 포함하는 형태.
// - 외부 데이터를 불러오기가 쉽지 않음.
//Map-Reduce : 매핑-리듀스 (최초의 집계 방식)
//Map : 집계 대상 분리 (조건에 맞춘 대상 선정. emit 함수 활용)
//Reduce : 집계 진행 (emit에 의해 나온 대상을 집계)
 
//[RDBMS]     [Aggregate]
//where       $match
//group by    $group
//having      $match
//select      $project
//order by    $sort
//limit       $limit
//sum()       $sum
 
//부서 번호가 30인 직원의 이름과 부서 출력
db.employees.aggregate([
  {$match: {deptno: 30}}, //match: where, having
  {$project: {_id:false, ename: true, deptno:true}} //project: select
])
 
//부서별 급여 합계
db.employees.aggregate(
  //group by deptno        sum(sal) AS total_sal
  {$group: {_id:"$deptno", total_sal: {$sum:"$sal"}}},
  {$project: {_id: true, total_sal: true}}
)
 
//부서번호가 30인 직업별 총 급여
db.employees.aggregate([
    {$match: {deptno: 30}},
    {$group: {_id:"$job", total_sal: {$sum:"$sal"}}},
    {$project: {_id: true, total_sal:true}}
])
 
// 주가 NY이면서, 도시가 NEW YORK
db.zipcode.find(
    { state: "NY", city: "NEW YORK" }
)
 
//도시별 인구 수의 합계
db.zipcode.aggregate([
    {$group: {_id:"$city", total_pop: {$sum: "$pop"}}}
])
 
//주별 인구 수의 합계가 50만 이하인 주의 인구 수를 집계
db.zipcode.aggregate([
    {$group: {_id:"$state", total_pop: {$sum:"$pop"}}},
    {$match: {total_pop: {$lte: 500000}}}
])
 
//Aggregate Q1
//1. 주별 인구가 가장 많은 곳과 가장 적은 곳을 집계
//(hint: $max, $min)
db.zipcode.aggregate([
    {$group:{_id:"$state", max_pop:{$max:"$pop"}, min_pop:{$min:"$pop"}}},
    {$project: {_id: true, max_pop:true, min_pop: true}}
])
//2. 주별 인구 수의 합이 제일 많은 곳과 적은 곳의 차를 집계
//(hint: $subtract-차)
db.zipcode.aggregate([
    {$group:{_id:"$state", sum_pop: {$sum: "$pop"}}},
    {$group:{_id: 0, max_pop:{$max: "$sum_pop"}, min_pop:{$min: "$sum_pop"}}},
    {$project:{_id:new ObjectId(), subtract_pop:{$subtract:["$max_pop", "$min_pop"]}}}
])
//3. NEW YORK 에서 인구수가 가장 많은 곳의 zipcode(id)
db.zipcode.aggregate([
    {$match: {city: "NEW YORK"}},
    {$project: {pop: "$pop", zipcode:"$_id"}},
    {$sort: {pop: -1}},
    {$limit: 1}
])
//4. 주별 인구수의 평균
db.zipcode.aggregate([
    {$group: {_id: {state: "$state", city: "$city"}, pop: {$sum: "$pop"}}},
    {$group: {_id: "$_id.state", avgCityPop: {$avg: "$pop"}}}
])
 
//employees collection aggregation
//1. 부서번호가 10이고, 급여가 500이상 3000이하인 직원이면서,
//   직업이 CLERK 이거나 SALEMAN 인 사람의,
//   empno, ename, job, sal, deptno를 출력하세요
db.employees.aggregate([
    {$match: {$and:[{deptno:10}, {sal:{$gte:500}}, {sal:{$lte:3000}}]}},
    {$match: {$or:[{job:"CLERK"}, {job:"SALESMAN"}]}},
    {$project: {_id: true, empno: true, job: true, sal: true, deptno: true}}
])
//2. 부서번호가 30인 사람의
//      empno, ename, sal, comm 을 출력하되,
//      comm이 없으면 0으로 표시, sal + comm 을 total_sal로 출력하시오.
//(또한, comm이 없으면 0 더하기)
db.employees.aggregate([
    {$match: {deptno: 30}},
    {$project: {empno: true, ename: true, sal: true,
        comm:{$ifNull:["$comm", 0]},
        total_sal: {$add:["$sal", {$ifNull:["$comm", 0]} ]}
    }}
])
 
//zipcode aggregation exam
// 1. NEW YORK 의 인구수를 구하시오.
    db.zipcode.aggregate([
        {$match:{city:"NEW YORK"}},
        {$group:{_id:true, total_pop:{$sum:"$pop"}}}
    ])
 
// 2. MA 주의 모든 도시를 구하시오.
    db.zipcode.aggregate([
        {$match:{state:"MA"}},
        {$group:{_id:{state:"state", city:"$city"}}},
        {$project: {_id:false, city:"$_id.city"}}
    ])
 
// 3. 인구수가 많은 순으로 10개의 도시 및 인구수를 구하시오
    db.zipcode.aggregate([
        {$group:{_id:"$city", sum_pop:{$sum:"$pop"}}},
        {$sort: {sum_pop: -1}},
        {$limit: 10}
    ])
 
// 4. MA주의 도시 중 인구가 1000이하인 도시를 구하시오
    db.zipcode.aggregate([
        {$match:{state:"MA"}},
        {$group:{_id:{city:"$city"}, sum_pop:{$sum:"$pop"}}},
        {$match:{sum_pop:{$lte:1000}}},
        {$project:{_id:false, city:"$_id.city", sum_pop:true}}
    ])
 
// GeoMetry_index
// $near : 기준점으로 가장 가까운 좌표
// $center : 기준이 원으로
// $within : 범위 내의 자료들을 포함할 때
// $box : 네모
// $polygon : 다각형
    //2d 형태의 좌표 인덱스 지정
    db.position.createIndex({ loc: "2dsphere"})
    //type과 coordinates는 고정적 -> loc의 indexing
    db.position.insert({_id:"m239092", datatype:NumberLong(1), loc:{type:"Point", coordinates:[127.1058431, 37.5164113]},
pos_name:["name = 잠실역 2호선", "trans_type=지하철"]})
    db.position.insert({_id:"m239091", datatype:NumberLong(1), loc:{type:"Point", coordinates:[127.0980748, 37.5301228]},
pos_name:["name = 동서울 터미널", "trans_type=버스터미널"]})
    db.position.insert({_id:"m239090", datatype:NumberLong(1), loc:{type:"Point", coordinates:[127.0952154, 37.5398467]},
pos_name:["name = 강변역 2호선", "trans_type=지하철"]})
    db.position.insert({_id:"m239089", datatype:NumberLong(1), loc:{type:"Point", coordinates:[127.0742172, 37.5419541]},
pos_name:["name = 건대역 2호선", "trans_type=지하철"]})
 
//위치 찾기
    db.position.find({
        loc:{$near: {       //중심좌표를 기준으로 가까운 곳을 찾겠다.
            $geometry : {   //어떠한 타입으로, 어디에서 찾아 낼 건지
                type: "Point",
                coordinates: [127.1058431, 37.5164113]
            },
            $maxDistance:3000 //거리(m) : 3000-> 3km
        }}
    })
 
// 경로상 위치하고 있는 장소 검색
// LineString type
    db.position.insert({
        _id : "m23903",
        datatype : "NumberLong(1)",
        loc : {type: "Point", coordinates:[127.084660, 37.52120906]},
        pos_name : ["name=신천역 2호선", "trans_type=지하철"]
    })
 
    db.position.insert({
        _id : "m23904",
        datatype : "NumberLong(1)",
        loc : {type: "Point", coordinates:[127.0740075, 37.5133497]},
        pos_name : ["name=종합운동장 2호섡", "trans_type=지하철"]
    })
 
    db.position.insert({
        _id : "m23905",
        datatype : "NumberLong(1)",
        loc : {type: "Point", coordinates:[127.0847829, 37.5105344]},
        pos_name : ["name=삼성역 2호선", "trans_type=지하철"]
    })
 
    db.position.find({ //Line은 근처, Point는 정확하게 찾아낼 때
        loc : { $geoIntersects : {  //경로 찾기
                $geometry : {   //geoJSON 상의 경로 검색
                    type : "LineString", //경로상의 위치
                    coordinates: [
                        //사용자가 이동하는 위치
                        [127.1058435, 37.5164113],
                        [127.084660, 37.5120906],
                        [127.0740075, 37.5133497],
                        [127.0847829, 37.5105344]
                    ]
                }
            }
        }
    }).pretty()
 
    //polygon_geometry
    db.position.insert({_id:"m12901", loc: {type:"Point", coordinates:[127.1224773, 37.5239739]},
    pos_name:["addr_name=올림픽 수영장", "addr_type = Public Sport"]
})
db.position.insert({_id:"m12902", loc: {type:"Point", coordinates:[127.1224773, 37.5239739]},
pos_name:["addr_name=카페", "addr_type = Cafe"]
})
 
db.position.find({
    loc:{
        $geoWithin:{ //범위 내부의 데이터 탐색
            $geometry:{
                type:"Polygon", //면 형태로 검색
                coordinates:[[
                    [127.1261076, 37.5191452], //Start Point
                    [127.1220412, 37.5221428],
                    [127.1224733, 37.5239739],
                    [127.1269535, 37.5231093],
                    [127.1290333, 37.5179105],
                    [127.1239271, 37.5116750],
                    [127.1261076, 37.5191452]   //end point (*eq Start Point)
                ]]
            }
        }
    }
})
/////////////////////////////////////////////////////////////////////////////////
 
//Link_DBRef
//일반 ID 링크 방식
db.ord.insert({
    ord_id:"2018-01-01-012345",
    customer_name: "Bit Academy",
    emp_name : "HeeJoon Jo",
    total : "55000",
    payment_type: "Cash"
})
//상위 것 하나만 꺼내라.
o = db.ord.findOne({ord_id:"2018-01-01-012345"})
 
db.ord_detail.insert({
    ord_id: o.ord_id,
    item_id: [
    {
        item_id: "1",
        product_name: "Monami",
        item_price: 500,
        qty: 100,
        price : 50000
    },
    {
        item_id:"2",
        product_name: "A4",
        item_price : 50,
        qty : 100,
        price : 5000
    }
],
    order_id: o._id //pk의 역할, ord_id 보다 더 빠름
                    //(인덱스로만 이루어진 객체이므로)
})
 
db.ord.findOne()
//1) ObjectID를 이용한 주문 상세 검색
db.ord_detail.find({order_id:o._id})
//2) 일반 ord_id 필드를 활용한 검색
db.ord_detail.find({ord_id:o.ord_id})
 
//Look_up
db.dept.insert({deptno:10, dname: "전산실", loc:1})
db.dept.insert({deptno:20, dname: "영업팀", loc:2})
db.dept.insert({deptno:30, dname: "관리팀", loc:1})
db.dept.insert({deptno:40, dname: "인사팀", loc:3})
 
db.location.insert({loc:1, loc_name:"서울"})
db.location.insert({loc:2, loc_name:"대전"})
db.location.insert({loc:3, loc_name:"대구"})
db.location.insert({loc:4, loc_name:"부산"})
 
// select emp.empno, dept.dname
// from emp, dept
// where emp.deptno = dept.deptno
 
db.employees.aggregate(
    {$match : {deptno: 10}}, //10번 부서에서
    {$project: {empno:1, ename: 1, job: 1, deptno: 1}},
    {$lookup: {
        from: "dept", //dept 테이블에서
        localField : "deptno", //employees.deptno와
        foreignField: "deptno", // dept.deptno를 조인
        as : "dept_info" // dept_info 필드에 있는 배열을 풀어서
                         // 각각 다른 document로 만들기
    }},
    {$unwind : "$dept_info"}, //배열풀기
    {$lookup : {
        from : "location",
        localField : "dept_info.loc",
        foreignField: "loc",
        as : "loc_info"
    }}
)
 
//homework
//zipcode aggregate exam
// 5. 주마다 몇 개의 도시가 있는지 집계하시오.
db.zipcode.aggregate([
    {$group:{_id:{state:"$state", city:"$city"}}} ,
    {$group:{_id:{state:"$_id.state"}, count: { $sum: 1 }}}
])
db.zipcode.aggregate([
    {$group:{_id:{state:"$state", city:"$city"}, count: { $sum: 1 }}},
    {$group:{_id:{state:"$_id.state"}, count2:{$sum:"$count"}}}
])
    {$group:{_id:{state:"$_id.state"}, count2:{$sum:"$count"}}}
{$project: {_id:false, city:"$_id.city"}}
db.zipcode.aggregate([
    {$group:{_id:{state:"$state", city:"$city"}, count: { $sum: 1 }}} ,
    {$group:{_id:{state:"$_id.state"}, total_sum:{$sum:"$count"}}}
])
{$group:{_id:{state:"$_id.state"}, total_sum:{$sum:"$count"}}}
// 6. 인구수가 1000만 이상인 주를 집계하시오.
db.zipcode.aggregate([
    {$group:{_id:{state:"$state"}, total_pop:{$sum:"$pop"}}},
    {$match:{total_pop:{$gte:10000000}}}
])
//geometry exam
// * 127.027604, 37.494609 -> 기준좌표 (비트빌)
// 127.027085, 37.495294 -> CU편의점
// 127.030869, 37.495240 -> GS편의점
// 127.029348, 37.495563 -> 세븐일레븐 편의점
// 127.028250, 37.493110 -> CU편의점
// 127.005537, 37.486390 -> 동우 유치원
// 127.008625, 37.490949 -> 현대 ESA 2차
// 127.099201, 37.505501 -> 원각사
// 126.988043, 37.569958 -> 종로 버거킹
// 126.962380, 37.393048 -> 평촌 CGV
// Q. 비트빌 기준으로 3마일 내에 어떤 시설물이 있는지 탐색
// 100 / 3963.2 -> 100mile
db.bitville.insert({
    datatype: "NumberLong(1)",
    loc : {type: "Point", coordinates:[127.027085, 37.495294]},
    pos_name : ["name=CU편의점"]
})
db.bitville.insert({
    datatype: "NumberLong(1)",
    loc : {type: "Point", coordinates:[127.030869, 37.495240]},
    pos_name : ["name=GS편의점"]
})
db.bitville.insert({
    datatype: "NumberLong(1)",
    loc : {type: "Point", coordinates:[127.029348, 37.495563]},
    pos_name : ["name=세븐일레븐 편의점"]
})
db.bitville.insert({
    datatype: "NumberLong(1)",
    loc : {type: "Point", coordinates:[127.028250, 37.493110]},
    pos_name : ["name=CU편의점"]
})
db.bitville.insert({
    datatype: "NumberLong(1)",
    loc : {type: "Point", coordinates:[127.005537, 37.486390]},
    pos_name : ["name=동우 유치원"]
})
db.bitville.insert({
    datatype: "NumberLong(1)",
    loc : {type: "Point", coordinates:[127.008625, 37.490949]},
    pos_name : ["name=현대 ESA 2차"]
})
db.bitville.insert({
    datatype: "NumberLong(1)",
    loc : {type: "Point", coordinates:[127.099201, 37.505501]},
    pos_name : ["name=원각사"]
})
db.bitville.insert({
    datatype: "NumberLong(1)",
    loc : {type: "Point", coordinates:[126.988043, 37.569958]},
    pos_name : ["name=종로 버거킹"]
})
db.bitville.insert({
    datatype: "NumberLong(1)",
    loc : {type: "Point", coordinates:[126.962380, 37.393048]},
    pos_name : ["name=평촌 CGV"]
})
db.bitville.createIndex({ loc: "2dsphere"})
db.bitville.find({
    loc:{$near: {       //중심좌표를 기준으로 가까운 곳을 찾겠다.
        $geometry : {   //어떠한 타입으로, 어디에서 찾아 낼 건지
            type: "Point",
            coordinates: [127.027604, 37.494609]
        },
        $maxDistance:4828
    }}
})
db.bitville.find({
    loc:{$geoWithin: { $centerSphere: [ [ 127.027604, 37.494609 ], 3/3963.2 ] }}
})