몽고db 2일차

1. createCollection()

db.createCollection(name, options)

//name : 생성할 컬렉션의 이름 

//options : (선택)메모리 관련 옵션 지정

// {

capped (Boolean) : true인 경우 고정된 크기의 컬렉션, size option을 필수 설정, size over시 오래된 항목을 덮어씌움.

autoIndexID (Boolean) : true시 자동으로 _id Field 값 지정

size (number) : capped의 크기를 지정 (capped가 true)

max (number) : 최대 document의 개수

// }

2. drop()

db.COLLECTION_NAME.drop()

3. MongoDB DataType

String : UTF-8

Boolean

Integer

Double

Max/Min Keys : 최대/최소 값과 비교하는 사용

Arrays

Timestamp

Object

Null

Symbol : String과 비슷하나, 고정기호 유형을 사용할 때

Date

object ID - 자동으로 부여된 값

Binary data

Code : JS code를 저장하는데 사용

Regular Expression : 정규 표현식 저장하는데 사용

4. insert()

db.COLLECTION_NAME.insert(document)

5. find()

db.COLLECTION_NAME.find()

pretty()

db.COLLECTION_NAME.find().pretty()

6. 조건 연산자

Equality {<key>:<value>}

db.COLLECTION_NAME.find({"name":"latte"}).pretty()

SQL : WHERE name = "latte";

Less Than {<key>:($lt:<value>)}

db.COLLECTION_NAME.find({"age":{$lt:3}}).pretty()

SQL : WHERE age < 3;

Less Than Equals {<key>:{$lte:<value>}}

db.COLLECITON_NAME.find({"age": {$lte:3}}).pretty()

SQL : WHERE age <= 3;

...

Not Equals {<key>:{$ne:<value>}}

db.COLLECTION_NAME.find({"age":{$ne:3}})

SQL : WHERE age != 3;

7. update()

db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATE)

db.animals.update({"name":"coffee"},{$set:{"name":"Mocha"}})

8. save() : 새문서로 기존문서를 덮어씌움, 해당 id값에대해 새로운 속성을 생성가능 update는 있는 속성을 수정

db.COLLECTION_NAME.save({ _id:ObjectID(), NEW_DATA})

db.animals.save({ "_id":ObjectId("5a444f2b11a9b9b50f834f9d"), "name":"latte", "color":"white"})

9. remove()

db.COLLECITON_NAME.remove(DELLETION_CRITERIA)

db.animals.remove({"name":"Mocha"})

db.animals.remove({"name":"Mocha"}, 1) //같은 데이터의 가장 상위 데이터에서 1개만 지움

db.animals.remove({ }) //모두 삭제

10. find() **프로젝션

db.COLLECTION_NAME.find({ },{KEY:1})

db.members.find({ }, {"gender":0}) //gender를 제외하고

db.members.find({ }, {"salary":1})

db.members.find({ }, {"member.gender":1}) //member.gender 를 포함

11. limit()

db.COLLECTION_NAME.find().limit(NUMBER)

db.members.find().limit(2)

12. skip()

db.COLLECITON_NAME.find().skip(NUMBER)

db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

db.members.find().skip(2)

db.members.find().limit(2).skip(2)

13. sort()

db.COLLECTION_NAME.find().sort({key:SORT_NUMBER})

  db.members.find().sort({"age":1})

db.members.find({ }, {"age":true, _id:false}).sort({"age":-1}) 

db.members.find({ }, {"age":1, _id:0}).sort({"age":-1})

Indexing : 수많은 데이터를 효과적으로 다루기 위한 방법

1. ensureIndex()

db.COLLECTION_NAME.ensureIndex({KEY:1})

db.members.ensureIndex({"member.name":1})

//첫 번째 인자 : background(Boolean) : Background에 Index를 구축(다른 데이터베이스에서도 사용가능)

//default false, (선택) true

//두 번째 인자 : unique(Boolean) : 고유 인덱스, _id처럼 컬렉션의 단 한개의 값만 존재하도록

2. createIndex() 

db.COLLECTION_NAME.createIndex({KEY:1}) -> (<key and index type>, <option>)

- index _id : 따로 지정하지 않으면, 자동으로 ObjectId를 설정. unique로 되어있어 중복추가를 방지한다.

- Single Field : _id index 외에 MongoDB가 제공하는 문서 단일 필드

사용자 정의 오름차순/내림차순 (정렬)을 지원

- Compound Field : 나열된 필드의 순서를 따른다. (중요) 첫 필드를 정렬 후 해당 기준으로 다음 필드를 정렬

- Multikey index : 배열 값을 가진 필드의 indexing. 배열의 각 요소에 대한 index key를 생성

collection

{

userid:"abc"

addr:

[

{"basic":"서울"},

{"detail":"서초구"}

]

}  

  db.COLLECTION_NAME.createIndex({"field.key" : 1 or -1})

- GeoSpatial Index : Map의 xPos, yPos같은 좌표를 효율적으로 처리하기 위함.

ex)특정 좌표의 반경 데이터를 찾을 때 

- Text Index : 텍스트 데이터를 효율적으로 하기 위함

Text 검색 쿼리를 지원 (문자열, 문자열 요소의 배열) 

단, Collection에는 최대 하나의 Text Index만 가능!

      - 가중치 지정 : A에 대한 가중치 점수를 통해 필드 간의 상대적 중요성을 표시

- 와일드 카드 Text Index : Text의 여러 필드에 indexing할 때 사용

   Collection의 각 Document에 대한 

   문자열 데이터가 존재하는 모든 필드를 indexing하게 해준다.

db.COLLECTION_NAME.createIndex({"$**":"text"})

- Hash Index : B_Tree가 아닌 Hash Data Struct를 사용한다.

db.members.createIndex({"age":1})

db.members.find({"age":{$gt:45}})

db.members.createIndex({"age":1, "salary": -1})

db.members.find({"age":{$gt:45}})

3. getIndexes()

db.COLLECTION_NAME.getIndexes() : 인덱스 조회

db.members.getIndexes()

4. dropIndex()

db.COLLECTION_NAME.dropIndexes() : _id를 제외한 모든 index 제거

db.COLLECTION_NAME.dropIndex({KEY:1}) : 해당 index 제거

db.members.dropIndexes()

Ex1)

- 10명의 employees Document를 저장하는 Collection을 만들어

age는 내림차순, salary는 오름차순으로 인덱싱하여라.

[Field] : name, age, salary

-> db.employees.find(($조건)) 출력 시 정렬된 상태로 표시.

use employees

db.employees.insert([

{"name":"Kim", "age":30, "salary":14000},

{"name":"Lee", "age":41, "salary":43000},

{"name":"Park", "age":33, "salary":21000},

{"name":"Yang", "age":54, "salary":54000},

{"name":"Hong", "age":20, "salary":32000},

{"name":"Choi", "age":62, "salary":65000},

{"name":"Cho", "age":43, "salary":15000},

{"name":"Ma", "age":23, "salary":34000},

{"name":"Seo", "age":36, "salary":76000},

])

db.employees.createIndex({"age": 1, "salary": -1})

db.employees.createIndex({"age": -1, "salary": 1}) 반대로해서 비교해보기

5. Index Properties

- Unique Indexes : _id 처럼 Collection에 단 하나만 존재할 수 있는 속성

indexing field의 중복 값을 저장하지 않도록 한다. (고유성 적용)

db.COLLECTION_NAME.createIndex(

{"KEY":1}, {"unique":true})

db.employees.createIndex({"age":1}, {unique:true})

db.employees.createIndex({"age":1, salary:-1}, {unique:true})

<제한 사항>

이미 중복된 document data가 존재한다면 indexing을 허용하지 않는다.

- Partial Indexes : 필터 표현식에 따라 일부 document에만 indexing 

db.employees.createIndex({"name":1, "age":1}, {partialFilterExpression:{"salary":{$gt:24000}}})

db.employees.find({age:{$gt:28}, salary:{$gt:0}})

- TLL Indexes : document의 생명 시간을 설정 (expire) 속성 설정 시 해당 시간이 지나면 컬렉션에서 제거

db.COLLECTION_NAME.createIndex({"age":1},{expireAfterSeconds : 1800})

db.employees.createIndex({"age":1},{expireAfterSeconds : 1800})

EX2) 

db.emp.insertMany([

{empno:1, ename:"nah", job:"CLERK", deptno:40, sal:5600},

{empno:2, ename:"kim", job:"SALEMAN", deptno:20, sal:2400},

{empno:3, ename:"jeong", job:"CLERK", deptno:30, sal:3500},

{empno:4, ename:"han", job:"SALEMAN", deptno:10, sal:6600},

{empno:5, ename:"yang", job:"SALEMAN", deptno:40, sal:4600},

{empno:6, ename:"nah", job:"CLERK", deptno:50, sal:2600},

{empno:7, ename:"joo", job:"CLERK", deptno:30, sal:3600},

{empno:8, ename:"lee", job:"CLERK", deptno:40, sal:6600},

{empno:9, ename:"yeo", job:"CLERK", deptno:20, sal:8600}

])

1)SELECT * FROM employees WHERE job = "CLERK" AND sal >= 1000

>db.emp.find({$and:[{"job":"CLERK"}, {"sal": {$gte:1000}}]})

2)SELECT * FROM employees WHERE job = "SALEMAN" AND deptno = 10

>db.emp.find({$and:[{"job":"SALEMAN"}, {"deptno":10}]})

3)SELECT empno, ename, sal FROM employees WHERE sal <= 4000;

>db.emp.find({"sal":{$lte:4000}},{"_id":false,"empno":true, "ename":true, "sal":true})

4)SELECT empno, ename, sal FROM employees WHERE sal >= 1500 AND sal <= 5000

>db.emp.find({$and:[{"sal":{$gte:1500}}, {"sal":{$lte:5000}}]},{"_id":false,"empno":true, "ename":true, "sal":true})

5)SELECT empno, ename, job FROM employees WHERE deptno = 10 OR deptno = 30

>db.emp.find({$or:[{"deptno":10},{"deptno":30}]})

6)SELECT * FROM employees WHERE (deptno = 10 OR deptno = 30) AND sal >= 1500

>db.emp.find({$and:[{$or:[{"deptno":10},{"deptno":30}]},{"sal":{$gte:1500}}]})

7)SELECT * FROM employees WHERE job != 'SALEMAN' order by empno ASC

>db.emp.find({"job":{$not:/^SALEMAN/}}).sort({"empno":1}) 

>db.emp.find({"job":{$ne:"SALEMAN"}}).sort({"empno":1}) 

8)SELECT empno, ename, sal, job, FROM employees WHERE (job='SALEMAN' OR job='CLERK') AND sal >= 1000 AND sal <= 3500

>db.emp.find({$and:[{$and:[{$or:[{job:"SALEMAN"},{job:"CLERK"}]},{"sal":{$gte:1000}}]},{"sal":{$lte:3500}}]})

9)SELECT * FROM employees

>db.emp.find()

10)SELECT * FROM employees WHERE sal > 1000 AND deptno < 30

>db.emp.find({$and:[{"sal":{$gt:1000}},{"deptno":{$lt:30}}]})

11)SELECT * FROM employees WHERE deptno = 30 ORDER BY ename DESC;

>db.emp.find({"deptno":30}).sort({"ename":-1})

12)SELECT * FROM employees WHERE deptno IN(10, 30)

>db.emp.find({"deptno":{$in:[10,30]}})

13)SELECT * FROM employees WHERE ename LIKE '%n'

>db.emp.find({"ename":/n/}) 

14)SELECT * FROM emp WHERE ename LIKE 'n%'

>db.emp.find({"ename":/^n/}) 

15)SELECT * FROM emp WHERE ename LIKE '%g'

>db.emp.find({"ename": /g$/})