exp_blog

MongoDB - Query Document 

조회 (find()) //db.COLLECTION_NAME.find(query, projection)

Document 를 조회하는 find() 메소드

find() 메소드의 인자로 query 와 projection 이 들어옵니다.

두 값 모드 Optional 파라메터입니다.

query 의 데이터 타입은 document(객체) 입니다. 이는 다큐먼트를 조회하는 기준을 정하는 파라메터입니다. 이 값이 생략되거나 비어있는 객체 {} 를 전달하면 해당 컬렉션의 모든 다큐먼트들을 조회합니다.

projection 의 데이터 타입 역시 document 로, 조회한 다큐먼트의 표시할 field 를 지정하는 것 입니다.

실습 위해 컬렉션 만들어보고 삽입!

>db.articles.insert([

  {

    "title": "article01",

    "content": "content01",

    "writer": "Velopert",

    "likes": 0,

    "comments": []

  },

  {

    "title": "article02",

    "content": "content02",

    "writer": "Alpha",

    "likes": 23,

    "comments": [

      {

        "name": "Bravo",

        "message": "Hey Man!"

      }

    ]

  },

  {

    "title": "article03",

    "content": "content03",

    "writer": "Bravo",

    "likes": 40,

    "comments": [

      {

        "name": "Charlie",

        "message": "Hey Man!"

      },

      {

        "name": "Delta",

        "message": "Hey Man!"

      }

    ]

  }

])
BulkWriteResult({
        "writeErrors" : [ ],
        "writeConcernErrors" : [ ],
        "nInserted" : 3,
        "nUpserted" : 0,
        "nMatched" : 0,
        "nModified" : 0,
        "nRemoved" : 0,
        "upserted" : [ ]
})

> db.articles.find().pretty()
{
        "_id" : ObjectId("5d80289f790e7a86104506af"),
        "title" : "article01",
        "content" : "content01",
        "writer" : "Velopert",
        "likes" : 0,
        "comments" : [ ]
}
{
        "_id" : ObjectId("5d80289f790e7a86104506b0"),
        "title" : "article02",
        "content" : "content02",
        "writer" : "Alpha",
        "likes" : 23,
        "comments" : [
                {
                        "name" : "Bravo",
                        "message" : "Hey Man!"
                }
        ]
}
{
        "_id" : ObjectId("5d80289f790e7a86104506b1"),
        "title" : "article03",
        "content" : "content03",
        "writer" : "Bravo",
        "likes" : 40,
        "comments" : [
                {
                        "name" : "Charlie",
                        "message" : "Hey Man!"
                },
                {
                        "name" : "Delta",
                        "message" : "Hey Man!"
                }
        ]
}

• articles 의 다큐먼트 중 writer 가 Bravo 인 다큐먼트를 검색

특정 field 의 정확한 값으로 다큐먼트를 조회할 때는 find 의 query 로 찾을 document 를 객체 형식으로 지정

> db.articles.find({ "writer" : "Bravo" }).pretty()
{
        "_id" : ObjectId("5d80289f790e7a86104506b1"),
        "title" : "article03",
        "content" : "content03",
        "writer" : "Bravo",
        "likes" : 40,
        "comments" : [
                {
                        "name" : "Charlie",
                        "message" : "Hey Man!"
                },
                {
                        "name" : "Delta",
                        "message" : "Hey Man!"
                }
        ]
}

Query 연산자

• 비교 연산자

articles 콜렉션 안의 다큐먼트 중 like 필드의 값이 10보다 크고 30보다 작은 다큐먼트를 조회

> db.articles.find( { "likes" : { $gt : 10, $lt : 30 } } ).pretty()
{
        "_id" : ObjectId("5d80289f790e7a86104506b0"),
        "title" : "article02",
        "content" : "content02",
        "writer" : "Alpha",
        "likes" : 23,
        "comments" : [
                {
                        "name" : "Bravo",
                        "message" : "Hey Man!"
                }
        ]
}

•  논리(Logical) 연산자

-title 의 값이 "article01" 이거나 writer 의 값이 "Alpha" 인 도큐먼트를 조회

> db.articles.find( { $or : [ { title : "article01" }, { writer : "Alpha" } ] } ).pretty()
{
        "_id" : ObjectId("5d80289f790e7a86104506af"),
        "title" : "article01",
        "content" : "content01",
        "writer" : "Velopert",
        "likes" : 0,
        "comments" : [ ]
}
{
        "_id" : ObjectId("5d80289f790e7a86104506b0"),
        "title" : "article02",
        "content" : "content02",
        "writer" : "Alpha",
        "likes" : 23,
        "comments" : [
                {
                        "name" : "Bravo",
                        "message" : "Hey Man!"
                }
        ]
}

-writer 의 값이 "Alpha" 이고, like 의 값이 20 이상인 다큐먼트를 조회

> db.articles.find( { $and : [ { writer : "Alpha" }, { likes : { $gt : 20 } } ] } ).pretty()
{
        "_id" : ObjectId("5d80289f790e7a86104506b0"),
        "title" : "article02",
        "content" : "content02",
        "writer" : "Alpha",
        "likes" : 23,
        "comments" : [
                {
                        "name" : "Bravo",
                        "message" : "Hey Man!"
                }
        ]
}
>

-$and 연산자는 하나의 query 객체로 표현하는 것과 같음.

db.articles.find( { $and : [ { writer : "Alpha" }, { likes : { $gt : 20 } } ] } ).pretty()

=

db.articles.find( { writer : "Alpha", likes : { $gt : 20 } } ).pretty()

Update() //db.콜렉션명.update(SELECTION_CRITERIA, UPDATED_DATA)

>db.mycol.update({'title' : 'MONGO DB'}, {$set  :{'title' : 'new mongo'}})

>db.mycol.update({'title' : 'MONGO DB'}, {$set  :{'title' : 'new mongo'}}, {multi : true})

Save() //db.콜렉션명.save({_id : 객체id(), new_data})

save()는 동일 id값이 들어오면 update. 그리고 save() 함수 변경시 변경/추가 여부를 결과값으로 알려줌

> db.user.save({ "_id" : 5, "name" : "matt", "part" : "staf", "title" : "lab" })
WriteResult({ "nMatched" : 0, "nUpserted" : 1, "nModified" : 0, "_id" : 5 })

> db.user.save({ "_id" : 5, "name" : "matt", "part" : "staff", "title" : "lab" })
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

> db.user.find()
{ "_id" : 5, "name" : "matt", "part" : "staff", "title" : "lab" }

Remove() //db.콜렉션명.remove(delete_creiteria)

>db.mycol.remove({'title' : 'mongo'})

Projection

일반적인 SQL 쿼리문에서 "select" 구문에 해당하는 Projection은 find() 메소드의 두번째 인자값에 해당.

/* sample query */ db.tbl.find( { num: { $gt: 29} }, { val1: 1, val2: 1 } ◀ projection ).limit(10)

위의 코드에서 "projection"으로 표시된 부분
만약 _id 필드를 projection에서 제외하면 추후에 projection을 합칠 때 문제가 생김.

위 구문에서 val1 필드 값인 1은 추출한 콜렉션에서 val1 필드를 포함하고 반대로 val1 필드 값이 0이라면 추출한 콜렉션에서 val1 필드를 제외. 따라서 위 구문은 val1과 val2 필드를 포함하겠다는 뜻.

1.추출할 콜렉션에서 특정 필드를 제외 쿼리 예시

db.t_col.find({ "view_count": { $gt: 29 }, { "title":0 })

위의 쿼리를 실행하면 view_count값이 29보다 큰 document들을 선택하고, 선택된 document들의 필드 중 "title" 필드를 제외.

2 .2개의 필드와 _id 필드를 포함하는 쿼리.

db.t_col.find({ "view_count": { $gt: 29 }, { "title":1, "cont":1 })

위의 쿼리를 실행하면 view_count값이 29보다 큰 document들을 선택하고, 선택된 document들의 필드 중 "title", "cont", "_id" 필드만 가져옴.

3. 2개의 필드를 포함하고 _id 필드를 제외하는 쿼리.

db.t_col.find({ "view_count": { $gt: 29 }, { "title":1, "cont":1, "_id":0 })

위의 쿼리를 실행하면 view_count값이 29보다 큰 document들을 선택하고, 선택된 document들의 필드 중 "_id"필드를 제외하고 "title", "cont" 필드만 가져옴

1.조인이란?

-> 데이터베이스를 연결하여 데이터를 검색하는 방법

-> PK 혹은 FK로 두 테이블을 연결

-> 적어도 하나의 칼럼은 서로 공유되고 있어야함

2.INNER JOIN = 교집합 

• 기준테이블과 JOIN 한 테이블의 중복된 값을 보여줌
• 결과값 : A의 테이블과 B테이블이 모두 가지고 있는 데이터만 검색
• ON 절에서는 WHERE 절에서 사용할 수 있는 모든 조건을 사용할 수 있음
• 표준 SQL과는 달리 MySQL에서는 JOIN, INNER JOIN, CROSS JOIN이 모두 같은 의미로 사용.

--문법--
SELECT *
FROM 첫번째 테이블 이름
INNER JOIN 두번쨰 테이블 이름
ON 조건

SELECT *
FROM 첫번째 테이블 이름
JOIN 두번째 테이블 이름
ON 조건

SELECT *
FROM 첫번째 테이블 이름 AS 별칭 , 
            두번째 테이블 이름 AS 별칭
WHERE 조건

--예제--
Reservation 테이블의 Name 필드와 Customer 테이블의 Name 필드가 서로 일치하는 레코드만 
INNER JOIN 으로 가져옴

1. 
SELECT *
FROM Reservation
INNER JOIN Customer
ON Reservation.Name = Customer.Name;

2. 
SELECT *
FROM Reservation
JOIN Customer
ON Reservation.Name = Customer.Name;

3.
SELECT *
FROM Reservation AS r, Customer AS c
WHERE r.Name = c.Name;

결과

3. LEFT OUTER , RIGHT OUTER 조인

• 하나의 테이블 기준으로 합치는 조인

• LEFT JOIN
  • 왼쪽 테이블을 중심으로 오른쪽의 테이블을 매치
  • 왼쪽 테이블의 한 개의 레코드에 여러개의 오른쪽 테이블 레코드가 일치할 경우
    >>> 해당 왼쪽 레코드를 여러번 표시
  • 왼쪽은 무조건 표시, 매치되는 레코드가 오른쪽에 없으면 null
  • ON 절의 조건을 만족하지 않는 경우, 첫 번째 테이블 필드(왼쪽)값은 그대로 가져옴.

--문법--
SELECT *
FROM 첫번째 테이블 이름
LEFT JOIN 두번째 테이블 이름
ON 조건

--예제--
Reservation 테이블의 Name 필드를 기준으로 Customer 테이블의 Name 필드와 일치하는 레코드만 LEFT JOIN으로 가져온 후, 그 중 ReserveDate 필드 값이 2019.09.13 이후인 레코드만 선택

SELECT *
FROM Reservation
LEFT JOIN Customer
ON Reservation.Name = Customer.Name
WHERE ReserveDate > '2019-09-13';

결과

• RIGHT JOIN
  • 오른쪽 테이블 중심으로 왼쪽 테이블을 매치
  • LEFT JOIN 에서 방향을 오른쪽으로만 바꾼 것
    >>> 해당 레코드가 여러번 표시되거나, null 표시

--문법--
SELECT *
FROM 첫번째 테이블 이름
RIGHT JOIN 두번째 테이블 이름
ON 조건

--예제--
Customer 테이블의 Name 필드를 기준으로 Reservation 테이블의 Name 필드와 일치하는 레코드만을 RIGHT JOIN으로 가져오는 예제

SELECT * 
FROM Reservation
RIGHT JOIN Customer
ON Reservation.Name = Customer.Name;

결과

데이터베이스 기본 쿼리

데이터베이스 생성

create database 데이터베이스이름;

데이터베이스 삭제

drop database 데이터베이스이름;

데이터베이스 조회

show databases;

데이터베이스 사용

use 데이터베이스이름;

테이블

테이블 정보

desc 테이블이름;

테이블 삭제

drop table 테이블이름;

레코드

레코드 추가

insert into 테이블이름 value('A','B','C');

insert into 테이블이름(FieldA,FieldB,FieldC) value('A','B','C');

레코드 조회

select * from 테이블이름;

select FieldA, FieldB from 테이블이름;

select * from 테이블이름 where FieldA = 'Content';

select distinct FieldA 테이블이름;                      중복제거

select * from 테이블이름 where FieldB between 00:00:00 and 12:00;00   //00시~12시 사이

select * from 테이블이름 where FieldB in (A, B);                                //A와 B 중에서

select * from 테이블이름 where FieldB LIKE '%단어%';                       //단어가 포함된 레코드 조회

select * from 테이블이름 where FieldB is null;    not is null                 //null일때

레코드 삭제

delete from 테이블이름 where Field = 'Content';

레코드 수정

update 테이블이름 set FieldA='바꿀내용' where FieldA='기존데이터';

내장함수

1. 숫자 관련 함수 
▶ ABS(숫자) - 절대값 출력. 
▶ CEILING(숫자) - 값보다 큰 정수 중 가장 작은 수. 
▶ FLOOR(숫자) - 값보다 작은 정수 중 가장 큰 수[실수를 무조건 버림(음수일 경우는 제외)]. 
▶ ROUND(숫자,자릿수) - 숫자를 소수점 이하 자릿수에서 반올림.(자릿수는 양수,0,음수를 갖을 수 있다.) 
▶ TRUNCATE(숫자,자릿수) - 숫자를 소수점 이하 자릿수에서 버림. 
▶ POW(X,Y) or POWER(X,Y) - X의 Y승 
▶ MOD (분자, 분모) - 분자를 분모로 나눈 나머지를 구한다.(연산자 %와 같음) 
▶ GREATEST(숫자1,숫자2,숫자3...) - 주어진 수 중 제일 큰 수 리턴. 
▶ LEAST(숫자1,숫자2,숫자3...) - 주어진 수 중 제일 작은 수 리턴. 
▶ INTERVAL(a,b,c,d.....) - a(숫자)의 위치 반환 

2. 문자 관련 함수 
▶ ASCII(문자) - 문자의 아스키 코드값 리턴. 
▶ CONCAT('문자열1','문자열2','문자열3'...) - 문자열들을 이어준다. 
▶ INSERT('문자열','시작위치','길이','새로운문자열') - 문자열의 시작위치부터 길이만큼 새로운 문자열로 대치 
▶ REPLACE('문자열','기존문자열','바뀔문자열') - 문자열 중 기존문자열을 바뀔 문자열로 바꾼다. 
▶ INSTR('문자열','찾는문자열') - 문자열 중 찾는 문자열의 위치값을 출력 
▶ LEFT('문자열',개수) - 문자열 중 왼쪽에서 개수만큼을 추출.
▶ RIGHT('문자열',개수) - 문자열 중 오른쪽에서 개수만큼을 추출. 
▶ MID('문자열',시작위치,개수) - 문자열 중 시작위치부터 개수만큼 출력 
▶ SUBSTRING('문자열',시작위치,개수) - 문자열 중 시작위치부터 개수만큼 출력 
▶ LTRIM('문자열') - 문자열 중 왼쪽의 공백을 없앤다. 
▶ RTRIM('문자열') - 문자열 중 오른쪽의 공백을 없앤다. 
▶ TRIM('문자열') - 양쪽 모두의 공백을 없앤다. 
▶ LCASE('문자열') or LOWER('문자열') - 소문자로 바꾼다. 
▶ UCASE('문자열') or UPPER('문자열') - 대문자로 바꾼다. 
▶ REVERSE('문자열') - 문자열을 반대로 나열한다. 

3. 논리 관련 함수 
▶ IF(논리식,참일 때 값,거짓일 때 값) - 논리식이 참이면 참일 때 값을 출력하고 논리식이 거짓이면 거짓일 때 출력한다. 
▶ IFNULL(값1,값2) - 값1이 NULL 이면 값2로 대치하고 그렇지 않으면 값1을 출력 

4. 집계 함수 
▶ COUNT(필드명) - NULL 값이 아닌 레코드 수를 구한다. 
▶ SUM(필드명) - 필드명의 합계를 구한다. 
▶ AVG(필드명) - 각각의 그룹 안에서 필드명의 평균값을 구한다. 
▶ MAX(필드명) - 최대값을 구한다. 
▶ MIN(필드명) - 최소값을 구한다. 

5. 날짜 관련 함수 
▶ NOW() or SYSDATE() or CURRENT_TIMESTAMP() - 현재 날짜와 시간 출력 
▶ CURDATE() or CURRENT_DATE() -현재 날짜 출력 
▶ CURTIME() or CURRENT_TIME() -현재 시간 출력 
▶ DATE_ADD(날짜,INTERVAL 기준값) -날짜에서 기준값 만큼 더한다. 
※ 기준값 : YEAR, MONTH, DAY, HOUR, MINUTE, SECOND 
▶ DATE_SUB(날짜,INTERVAL 기준값) -날짜에서 기준값 만큼 뺸다. 
※ 기준값 : YEAR, MONTH, DAY, HOUR, MINUTE, SECOND 
▶ YEAR(날짜) -날짜의 연도 출력. 
▶ MONTH(날짜) -날짜의 월 출력. 
▶ MONTHNAME(날짜) -날짜의 월을 영어로 출력. 
▶ DAYNAME(날짜) -날짜의 요일일 영어로 출력. 
▶ DAYOFMONTH(날짜) -날짜의 월별 일자 출력. 
▶ DAYOFWEEK(날짜) -날짜의 주별 일자 출력(월요일(0),화요일(1)...일요일(6)) 
▶ WEEKDAY(날짜) -날짜의 주별 일자 출력(월요일(0),화요일(1)...일요일(6)) 
▶ DAYOFYEAR(날짜) -일년을 기준으로 한 날짜까지의 날 수. 
▶ WEEK(날짜) -일년 중 몇 번쨰 주. 
▶ FROM_DAYS(날 수) --00년 00월 00일부터 날 수 만큼 경과한 날의 날짜 출력. 
▶ TO_DAYS(날짜) --00 년 00 월 00일 부터 날짜까지의 일자 수 출력. 
▶ DATE_FORMAT(날짜,'형식') : 날짜를 형식에 맞게 출력 

JOIN

항상 몽고shell을 부른다고 생각 ,그 안에서 명령어를 사용

-mongodb 시작(cmd)

cmd 두개 돌려서 서버 먼저 돌리고

>mongod --dbpath c:\data\db

>mongo

로 들어감

C:\Users\USER>mongo localhost:27017

Database 생성: use

>use mydb
switched to db mydb
>db //현재 사용중인 데이터 베이스 확인
mydb

-콜렉션 자동 생성

> db.movie.insert({"name":"korea"})
WriteResult({ "nInserted" : 1 })
> show dbs
admin 0.000GB
config 0.000GB
local 0.000GB
mydb 0.000GB

movie라는 컬렉션을 자동으로 생성해주고 키와 value 값을 넣어줌

Database 제거: db.dropDatabase()

>db.dropDatabase()
{ "dropped" : "mongodb_tutorial", "ok" : 1 }

Collection 생성: db.createCollection()

>db.createCollection(name,options)

name 은 생성하려는 컬렉션의 이름이며 option 은 document 타입으로 구성된 해당 컬렉션의 설정값

options 매개변수는 선택적인(Optional) 매개변수로서 생략하셔도 되고, 필요에따라 사용

Option

> use test
switched to db test
> db.createCollection("mycollection") //콜렉션생성("콜렉션이름")
{ "ok" : 1 }
> show collections
mycollection

Collection 제거: db.COLLECTION_NAME.drop()

>db.COLLECTION_NAME.DROP

MongoDB에서는 하나의 Document 저장 시 3가지 메서드 사용

1. INSERT() : Collection에 하나의 Document 최초 저장

2. UPDATE() : 하나의 Collection에서 특정 필드만 수정할 때 사용(필드 단위로 변경)

3. SAVE() : 하나의 Document에서 특정 필드만 변경하더라도, Document 단위로 데이터를 변경

JSON 타입과 BSON 타입

자바스크립트 형식의 오브젝트 표기법

; Javascript Obect Notation

ex) p = {

eno : 1

,job : "developer"

,company : "xx"

}

db.insert(p)

BSON ; Binary Serial Object Notation)

 데이터 베이스 내에 저장될때 BSON 데이터로 변환되어 저장

데이터 타입
null형 { "name" : null }

undefined형 { "name" : undefined }

boolean형 { "name" : true }

64비트 부동소숫점 { "age" : 21 }

string형 { "name" : "neo" }

objectId형 { "oid" : ObjectId() }

date형 { "regdate" : new Date() }

정규식형 { "name" : /neo/i }

javascript형 { "func" : function() { /- ... *- } }

array형 { "array" : [ 1, 2, 3 ] }

문서형 { "person" : { "name" : "neo" } }

Read

> db.person.findOne()
처음 문서 하나를 조회

> db.person.find()
저장된 문서의 전체를 조회

Update

> person1.desc = []
> db.person.update({ name : "neo" }, person1)

> var person2 = db.person.findOne({"name" : "neo"});
> person2.desc = {"blood", "B"}

Delete

> db.person.remove({ name : "neo" })
컬렉션 내에 이름이 neo인 문서를 삭제

> db.person.remove()
모든 컬렉션의 문서를 삭제

-mongodb CRUD

Document 추가: db.COLLECTION_NAME.insert(document)

>db.COLLECTION_NAME.insert(document)

> db.books.insert({"name": "NodeJS Guide", "author": "Velopert"})
WriteResult({ "nInserted" : 1 })

> db.books.insert([
... {"name": "Book1", "author": "Velopert"},
... {"name": "Book2", "author": "Velopert"}
... ]);
BulkWriteResult({
      "writeErrors" : [ ],
     "writeConcernErrors" : [ ],
     "nInserted" : 2,
      "nUpserted" : 0,
     "nMatched" : 0,
      "nModified" : 0,
      "nRemoved" : 0,
      "upserted" : [ ]
})

> db.books.find() //컬렉션이 다큐먼트 리스트 확인 명령어

명령어 사용 전 데이터를 추가 할 데이터베이스를 선택

배열형식의 인자를 전달해주면 여러 다큐먼트를 동시에 추가 할 수 있음

Document 제거: db.COLLECTION_NAME.remove(criteria, justOne)

두 가지 매개변수

> db.books.find({"name": "Book1"})
{ "_id" : ObjectId("56c097f94d6b67aafdeb88ac"), "name" : "Book1", "author" : "Velopert" }
> db.books.remove({"name": "Book1"})
WriteResult({ "nRemoved" : 1 })
> db.books.find()
{ "_id" : ObjectId("56c08f3a4d6b67aafdeb88a3"), "name" : "MongoDB Guide", "author" : "Velopert" }
{ "_id" : ObjectId("56c08f474d6b67aafdeb88a4"), "name" : "NodeJS Guide", "author" : "Velopert" }
{ "_id" : ObjectId("56c097f94d6b67aafdeb88ad"), "name" : "Book2", "author" : "Velopert" }

.pretty() : display 모양이 예쁘게 나옴 ㅎㅎ

ex)

학생 필드에 이름, 학과, 나이, 취미(배열)로 삽입

> db.stu.insert({"name" : "kim", "dept" : "computer", "age" : 20, "hobby":["kkk","ttt","yyy"]})
WriteResult({ "nInserted" : 1 })
> db.stu.find().pretty()
        { "_id" : ObjectId("5d770c463b5ad95f3a6bdb43"),
          "name" : "kim",
          "dept" : "computer",
          "age" : 20,
          "hobby" : [
                         "kkk",
                         "ttt",
                         "yyy"
           ]
}
> db.stu.find()
{ "_id" : ObjectId("5d770c463b5ad95f3a6bdb43"), "name" : "kim", "dept" : "computer", "age" : 20, "hobby" : [ "kkk", "ttt", "yyy" ] }

-문서 검색 메소드 

예제1: 모든 다큐먼트 조회

> db.articles.find()

예제2: 다큐먼트를 예쁘게 깔끔하게 조회

> db.articles.find().pretty()

예제3: writer 값이  “Velopert” 인 Document 조회

> db.articles.find( { “writer”: “Velopert” } ).pretty()

예제4: likes 값이 30 이하인 Document 조회

> db.articles.find( { “likes”: { $lte: 30 } } ).pretty()

 Query 연산자

• mongoDB 에서도 원하는 데이터를 찾기 위해 연산자를 사용. 
• 연산자의 종류는 비교(Comparison), 논리(Logical), 요소(Element), 배열(Array) 등 
• <키>:<값> / <키>:{<연산자>:<값>}
•  

예제5: likes 값이 10보다 크고 30보다 작은 Document 조회

> db.articles.find( { “likes”: { $gt: 10, $lt: 30 } } ).pretty()

예제6: writer 값이 배열 [“Alpha”, “Bravo”] 안에 속하는 값인 Document 조회

> db.articles.find( { “writer”: { $in: [ “Alpha”, “Bravo” ] } } ).pretty()

논리 연산자

예제7: title 값이 “article01” 이거나, writer 값이 “Alpha” 인 Document 조회

> db.articles.find({ $or: [ { “title”: “article01” }, { “writer”: “Alpha” } ] })

예제8: writer 값이 “Velopert” 이고 likes 값이 10 미만인 Document 조회

> db.articles.find( { $and: [ { “writer”: “Velopert” }, { “likes”: { $lt: 10 } } ] } )

> db.articles.find( { “writer”: “Velopert”, “likes”: { $lt: 10 } } )