MongoDB-퀵 가이드

MongoDB는 고성능, 고 가용성 및 손쉬운 확장 성을 제공하는 크로스 플랫폼 문서 지향 데이터베이스입니다. MongoDB는 수집 및 문서의 개념으로 작동합니다.

데이터 베이스

데이터베이스는 컬렉션을위한 물리적 컨테이너입니다. 각 데이터베이스는 파일 시스템에서 고유 한 파일 세트를 가져옵니다. 단일 MongoDB 서버에는 일반적으로 여러 데이터베이스가 있습니다.

수집

컬렉션은 MongoDB 문서 그룹입니다. RDBMS 테이블과 동일합니다. 컬렉션은 단일 데이터베이스 내에 있습니다. 컬렉션은 스키마를 적용하지 않습니다. 컬렉션 내의 문서는 다른 필드를 가질 수 있습니다. 일반적으로 컬렉션의 모든 문서는 유사하거나 관련된 목적입니다.

문서

문서는 키-값 쌍의 집합입니다. 문서에는 동적 스키마가 있습니다. 동적 스키마는 동일한 컬렉션의 문서가 동일한 필드 또는 구조 집합을 가질 필요가 없으며 컬렉션 문서의 공통 필드가 다른 유형의 데이터를 보유 할 수 있음을 의미합니다.

다음 표는 RDBMS 용어와 MongoDB의 관계를 보여줍니다.

RDBMS MongoDB
데이터 베이스 데이터 베이스
수집
튜플 / 행 문서
기둥
테이블 조인 포함 된 문서
기본 키 기본 키 (mongodb 자체에서 제공하는 기본 키 _id)
데이터베이스 서버 및 클라이언트
Mysqld / Oracle 몽고
mysql / sqlplus 몽고

샘플 문서

다음 예제는 단순히 쉼표로 구분 된 키 값 쌍인 블로그 사이트의 문서 구조를 보여줍니다.

{
   _id: ObjectId(7df78ad8902c)
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100, 
   comments: [	
      {
         user:'user1',
         message: 'My first comment',
         dateCreated: new Date(2011,1,20,2,15),
         like: 0 
      },
      {
         user:'user2',
         message: 'My second comments',
         dateCreated: new Date(2011,1,25,7,45),
         like: 5
      }
   ]
}

_id모든 문서의 고유성을 보장하는 12 바이트 16 진수입니다. 문서를 삽입하는 동안 _id를 제공 할 수 있습니다. 제공하지 않으면 MongoDB는 모든 문서에 대해 고유 한 ID를 제공합니다. 이 12 바이트는 현재 타임 스탬프의 경우 처음 4 바이트, 머신 ID의 경우 다음 3 바이트, MongoDB 서버의 프로세스 ID의 경우 다음 2 바이트, 나머지 3 바이트는 단순 증분 VALUE입니다.

모든 관계형 데이터베이스에는 테이블 수와 이러한 테이블 간의 관계를 보여주는 일반적인 스키마 디자인이 있습니다. MongoDB에는 관계 개념이 없습니다.

RDBMS에 비해 MongoDB의 장점

  • Schema less− MongoDB는 하나의 컬렉션이 다른 문서를 보유하는 문서 데이터베이스입니다. 문서의 필드 수, 내용 및 크기는 문서마다 다를 수 있습니다.

  • 단일 개체의 구조가 명확합니다.

  • 복잡한 조인이 없습니다.

  • 깊은 쿼리 기능. MongoDB는 SQL만큼 강력한 문서 기반 쿼리 언어를 사용하여 문서에 대한 동적 쿼리를 지원합니다.

  • Tuning.

  • Ease of scale-out − MongoDB는 확장하기 쉽습니다.

  • 응용 프로그램 개체를 데이터베이스 개체로 변환 / 매핑 할 필요가 없습니다.

  • (윈도우) 작업 세트를 저장하기 위해 내부 메모리를 사용하여 데이터에 더 빠르게 액세스 할 수 있습니다.

MongoDB를 사용하는 이유

  • Document Oriented Storage − 데이터는 JSON 스타일 문서 형식으로 저장됩니다.

  • 모든 속성에 대한 색인

  • 복제 및 고 가용성

  • Auto-sharding

  • 풍부한 쿼리

  • 빠른 내부 업데이트

  • MongoDB의 전문적인 지원

MongoDB를 어디에서 사용합니까?

  • 빅 데이터
  • 콘텐츠 관리 및 제공
  • 모바일 및 소셜 인프라
  • 사용자 데이터 관리
  • 데이터 허브

이제 Windows에 MongoDB를 설치하는 방법을 살펴 보겠습니다.

Windows에 MongoDB 설치

Windows에 MongoDB를 설치하려면 먼저 다음 사이트에서 MongoDB의 최신 릴리스를 다운로드하십시오. https://www.mongodb.org/downloads. Windows 버전에 따라 올바른 버전의 MongoDB를 얻었는지 확인하십시오. Windows 버전을 얻으려면 명령 프롬프트를 열고 다음 명령을 실행하십시오.

C:\>wmic os get osarchitecture
OSArchitecture
64-bit
C:\>

32 비트 버전의 MongoDB는 2GB 미만의 데이터베이스 만 지원하며 테스트 및 평가 목적으로 만 적합합니다.

이제 다운로드 한 파일을 c : \ 드라이브 또는 다른 위치에 추출하십시오. 압축을 푼 폴더의 이름이 mongodb-win32-i386- [버전] 또는 mongodb-win32-x86_64- [버전]인지 확인합니다. 여기 [version]은 MongoDB 다운로드 버전입니다.

그런 다음 명령 프롬프트를 열고 다음 명령을 실행하십시오.

C:\>move mongodb-win64-* mongodb
   1 dir(s) moved.
C:\>

MongoDB를 다른 위치에 추출한 경우 명령을 사용하여 해당 경로로 이동하십시오. cd FOLDER/DIR 이제 위의 주어진 프로세스를 실행하십시오.

MongoDB는 파일을 저장할 데이터 폴더가 필요합니다. MongoDB 데이터 디렉토리의 기본 위치는 c : \ data \ db입니다. 따라서 명령 프롬프트를 사용하여이 폴더를 만들어야합니다. 다음 명령 시퀀스를 실행하십시오.

C:\>md data
C:\md data\db

MongoDB를 다른 위치에 설치해야하는 경우에는 다음에 대한 대체 경로를 지정해야합니다. \data\db 경로를 설정하여 dbpathmongod.exe. 동일하게 다음 명령을 실행하십시오.

명령 프롬프트에서 MongoDB 설치 폴더에있는 bin 디렉터리로 이동합니다. 내 설치 폴더가D:\set up\mongodb

C:\Users\XYZ>d:
D:\>cd "set up"
D:\set up>cd mongodb
D:\set up\mongodb>cd bin
D:\set up\mongodb\bin>mongod.exe --dbpath "d:\set up\mongodb\data"

이것은 보여줄 것입니다 waiting for connections mongod.exe 프로세스가 성공적으로 실행 중임을 나타내는 콘솔 출력에 메시지가 표시됩니다.

이제 MongoDB를 실행하려면 다른 명령 프롬프트를 열고 다음 명령을 실행해야합니다.

D:\set up\mongodb\bin>mongo.exe
MongoDB shell version: 2.4.6
connecting to: test
>db.test.save( { a: 1 } )
>db.test.find()
{ "_id" : ObjectId(5879b0f65a56a454), "a" : 1 }
>

이것은 MongoDB가 성공적으로 설치되고 실행되었음을 보여줍니다. 다음에 MongoDB를 실행할 때 명령 만 실행하면됩니다.

D:\set up\mongodb\bin>mongod.exe --dbpath "d:\set up\mongodb\data" 
D:\set up\mongodb\bin>mongo.exe

Ubuntu에 MongoDB 설치

다음 명령을 실행하여 MongoDB 공개 GPG 키를 가져옵니다.

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10

다음 명령을 사용하여 /etc/apt/sources.list.d/mongodb.list 파일을 만듭니다.

echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' 
   | sudo tee /etc/apt/sources.list.d/mongodb.list

이제 다음 명령을 실행하여 저장소를 업데이트하십시오.

sudo apt-get update

다음 명령을 사용하여 MongoDB를 설치하십시오-

apt-get install mongodb-10gen = 2.2.3

위 설치에서 2.2.3은 현재 MongoDB 버전으로 출시되었습니다. 항상 최신 버전을 설치하십시오. 이제 MongoDB가 성공적으로 설치되었습니다.

MongoDB 시작

sudo service mongodb start

MongoDB 중지

sudo service mongodb stop

MongoDB 다시 시작

sudo service mongodb restart

MongoDB를 사용하려면 다음 명령을 실행하십시오.

mongo

실행중인 MongoDB 인스턴스에 연결됩니다.

MongoDB 도움말

명령 목록을 얻으려면 다음을 입력하십시오. db.help()MongoDB 클라이언트에서. 그러면 다음 스크린 샷에 표시된대로 명령 목록이 제공됩니다.

MongoDB 통계

MongoDB 서버에 대한 통계를 얻으려면 다음 명령을 입력하십시오. db.stats()MongoDB 클라이언트에서. 이것은 데이터베이스 이름, 컬렉션 및 데이터베이스의 문서 수를 표시합니다. 명령의 출력은 다음 스크린 샷에 표시됩니다.

MongoDB의 데이터에는 동일한 컬렉션에 유연한 schema.documents가 있습니다. 동일한 필드 또는 구조 집합을 가질 필요는 없으며 컬렉션 문서의 공통 필드에는 다른 유형의 데이터가 포함될 수 있습니다.

MongoDB에서 스키마를 설계 할 때 고려해야 할 몇 가지 사항

  • 사용자 요구 사항에 따라 스키마를 디자인합니다.

  • 함께 사용할 경우 개체를 하나의 문서로 결합합니다. 그렇지 않으면 분리하십시오 (그러나 조인이 필요하지 않은지 확인하십시오).

  • 계산 시간에 비해 디스크 공간이 저렴하므로 데이터를 복제하십시오 (제한적 임).

  • 읽을 때가 아니라 쓰는 동안 조인하십시오.

  • 가장 빈번한 사용 사례에 맞게 스키마를 최적화합니다.

  • 스키마에서 복잡한 집계를 수행하십시오.

클라이언트가 자신의 블로그 / 웹 사이트에 대한 데이터베이스 디자인을 필요로하고 RDBMS와 MongoDB 스키마 디자인의 차이점을 확인한다고 가정합니다. 웹 사이트에는 다음과 같은 요구 사항이 있습니다.

  • 모든 게시물에는 고유 한 제목, 설명 및 URL이 있습니다.
  • 모든 게시물에는 하나 이상의 태그가있을 수 있습니다.
  • 모든 게시물에는 게시자 이름과 총 좋아요 수가 있습니다.
  • 모든 게시물에는 이름, 메시지, 데이터 시간 및 좋아요와 함께 사용자가 제공 한 댓글이 있습니다.
  • 각 게시물에는 0 개 이상의 댓글이있을 수 있습니다.

RDBMS 스키마에서 위 요구 사항에 대한 설계에는 최소 3 개의 테이블이 있습니다.

MongoDB 스키마에서 디자인은 하나의 컬렉션 포스트와 다음 구조를 갖습니다.

{
   _id: POST_ID
   title: TITLE_OF_POST, 
   description: POST_DESCRIPTION,
   by: POST_BY,
   url: URL_OF_POST,
   tags: [TAG1, TAG2, TAG3],
   likes: TOTAL_LIKES, 
   comments: [	
      {
         user:'COMMENT_BY',
         message: TEXT,
         dateCreated: DATE_TIME,
         like: LIKES 
      },
      {
         user:'COMMENT_BY',
         message: TEXT,
         dateCreated: DATE_TIME,
         like: LIKES
      }
   ]
}

따라서 데이터를 표시하는 동안 RDBMS에서는 세 개의 테이블을 조인해야하고 MongoDB에서는 데이터가 하나의 컬렉션에서만 표시됩니다.

이 장에서는 MongoDB에서 데이터베이스를 만드는 방법을 살펴 보겠습니다.

사용 명령

MongoDB use DATABASE_NAME데이터베이스를 만드는 데 사용됩니다. 이 명령은 존재하지 않는 경우 새 데이터베이스를 만들고, 그렇지 않으면 기존 데이터베이스를 반환합니다.

통사론

기본 구문 use DATABASE 진술은 다음과 같습니다-

use DATABASE_NAME

이름이있는 데이터베이스를 사용하려는 경우 <mydb>, 다음 use DATABASE 진술은 다음과 같습니다-

>use mydb
switched to db mydb

현재 선택한 데이터베이스를 확인하려면 다음 명령을 사용하십시오. db

>db
mydb

데이터베이스 목록을 확인하려면 다음 명령을 사용하십시오. show dbs.

>show dbs
local     0.78125GB
test      0.23012GB

생성 된 데이터베이스 (mydb)가 목록에 없습니다. 데이터베이스를 표시하려면 최소한 하나의 문서를 삽입해야합니다.

>db.movie.insert({"name":"tutorials point"})
>show dbs
local      0.78125GB
mydb       0.23012GB
test       0.23012GB

MongoDB에서 기본 데이터베이스는 test입니다. 데이터베이스를 생성하지 않은 경우 컬렉션은 테스트 데이터베이스에 저장됩니다.

이 장에서는 MongoDB 명령을 사용하여 데이터베이스를 삭제하는 방법을 살펴 봅니다.

dropDatabase () 메서드

MongoDB db.dropDatabase() 명령은 기존 데이터베이스를 삭제하는 데 사용됩니다.

통사론

기본 구문 dropDatabase() 명령은 다음과 같습니다-

db.dropDatabase()

선택한 데이터베이스가 삭제됩니다. 데이터베이스를 선택하지 않은 경우 기본 '테스트'데이터베이스가 삭제됩니다.

먼저 다음 명령을 사용하여 사용 가능한 데이터베이스 목록을 확인합니다. show dbs.

>show dbs
local      0.78125GB
mydb       0.23012GB
test       0.23012GB
>

새 데이터베이스를 삭제하려는 경우 <mydb>, 다음 dropDatabase() 명령은 다음과 같습니다-

>use mydb
switched to db mydb
>db.dropDatabase()
>{ "dropped" : "mydb", "ok" : 1 }
>

이제 데이터베이스 목록을 확인하십시오.

>show dbs
local      0.78125GB
test       0.23012GB
>

이 장에서는 MongoDB를 사용하여 컬렉션을 만드는 방법을 살펴 봅니다.

createCollection () 메서드

MongoDB db.createCollection(name, options) 컬렉션을 만드는 데 사용됩니다.

통사론

기본 구문 createCollection() 명령은 다음과 같습니다-

db.createCollection(name, options)

명령에서 name 만들 컬렉션의 이름입니다. Options 문서이며 컬렉션 구성을 지정하는 데 사용됩니다.

매개 변수 유형 기술
이름 만들 컬렉션의 이름
옵션 문서 (선택 사항) 메모리 크기 및 인덱싱에 대한 옵션 지정

옵션 매개 변수는 선택 사항이므로 컬렉션의 이름 만 지정하면됩니다. 다음은 사용할 수있는 옵션 목록입니다.

유형 기술
모자를 씌운 부울 (선택 사항) true 인 경우 제한 컬렉션을 활성화합니다. 제한 컬렉션은 최대 크기에 도달하면 가장 오래된 항목을 자동으로 덮어 쓰는 고정 크기 컬렉션입니다.If you specify true, you need to specify size parameter also.
autoIndexId 부울 (선택 사항) true 인 경우 _id 필드에 자동으로 인덱스를 만듭니다. 기본값은 false입니다.
크기 번호 (선택 사항) 제한 컬렉션의 최대 크기 (바이트)를 지정합니다. If capped is true, then you need to specify this field also.
최대 번호 (선택 사항) 제한 컬렉션에 허용되는 최대 문서 수를 지정합니다.

문서를 삽입하는 동안 MongoDB는 먼저 capped collection의 size 필드를 확인한 다음 max 필드를 확인합니다.

기본 구문 createCollection() 옵션이없는 방법은 다음과 같습니다.

>use test
switched to db test
>db.createCollection("mycollection")
{ "ok" : 1 }
>

다음 명령을 사용하여 생성 된 컬렉션을 확인할 수 있습니다. show collections.

>show collections
mycollection
system.indexes

다음 예는 다음의 구문을 보여줍니다. createCollection() 몇 가지 중요한 옵션이있는 방법-

>db.createCollection("mycol", { capped : true, autoIndexId : true, size : 
   6142800, max : 10000 } )
{ "ok" : 1 }
>

MongoDB에서는 컬렉션을 만들 필요가 없습니다. MongoDB는 문서를 삽입하면 컬렉션을 자동으로 생성합니다.

>db.tutorialspoint.insert({"name" : "tutorialspoint"})
>show collections
mycol
mycollection
system.indexes
tutorialspoint
>

이 장에서는 MongoDB를 사용하여 컬렉션을 삭제하는 방법을 살펴 봅니다.

drop () 메서드

MongoDB db.collection.drop() 데이터베이스에서 컬렉션을 삭제하는 데 사용됩니다.

통사론

기본 구문 drop() 명령은 다음과 같습니다-

db.COLLECTION_NAME.drop()

먼저 사용 가능한 컬렉션을 데이터베이스로 확인하십시오. mydb.

>use mydb
switched to db mydb
>show collections
mycol
mycollection
system.indexes
tutorialspoint
>

이제 이름으로 컬렉션을 삭제하십시오. mycollection.

>db.mycollection.drop()
true
>

다시 데이터베이스로 컬렉션 목록을 확인하십시오.

>show collections
mycol
system.indexes
tutorialspoint
>

drop () 메서드는 선택한 컬렉션이 성공적으로 삭제되면 true를 반환하고 그렇지 않으면 false를 반환합니다.

MongoDB는 많은 데이터 유형을 지원합니다. 그들 중 일부는-

  • String− 이것은 데이터를 저장하기 위해 가장 일반적으로 사용되는 데이터 유형입니다. MongoDB의 문자열은 유효한 UTF-8이어야합니다.

  • Integer−이 유형은 숫자 값을 저장하는 데 사용됩니다. 정수는 서버에 따라 32 비트 또는 64 비트가 될 수 있습니다.

  • Boolean −이 유형은 부울 (true / false) 값을 저장하는 데 사용됩니다.

  • Double −이 유형은 부동 소수점 값을 저장하는 데 사용됩니다.

  • Min/ Max keys −이 유형은 최저 및 최고 BSON 요소와 값을 비교하는 데 사용됩니다.

  • Arrays −이 유형은 배열, 목록 또는 여러 값을 하나의 키에 저장하는 데 사용됩니다.

  • Timestamp− ctimestamp. 이것은 문서가 수정되거나 추가되었을 때 기록 할 때 편리 할 수 ​​있습니다.

  • Object −이 데이터 유형은 포함 된 문서에 사용됩니다.

  • Null −이 유형은 Null 값을 저장하는 데 사용됩니다.

  • Symbol−이 데이터 유형은 문자열과 동일하게 사용됩니다. 그러나 일반적으로 특정 기호 유형을 사용하는 언어 용으로 예약되어 있습니다.

  • Date −이 데이터 유형은 현재 날짜 또는 시간을 UNIX 시간 형식으로 저장하는 데 사용됩니다. Date 객체를 생성하고 그 안에 일, 월, 연도를 전달하여 나만의 날짜 시간을 지정할 수 있습니다.

  • Object ID −이 데이터 유형은 문서의 ID를 저장하는 데 사용됩니다.

  • Binary data −이 데이터 유형은 바이너리 데이터를 저장하는 데 사용됩니다.

  • Code −이 데이터 유형은 JavaScript 코드를 문서에 저장하는 데 사용됩니다.

  • Regular expression −이 데이터 유형은 정규 표현식을 저장하는 데 사용됩니다.

이 장에서는 MongoDB 컬렉션에 문서를 삽입하는 방법을 배웁니다.

insert () 메서드

MongoDB 컬렉션에 데이터를 삽입하려면 MongoDB의 insert() 또는 save() 방법.

통사론

기본 구문 insert() 명령은 다음과 같습니다-

>db.COLLECTION_NAME.insert(document)

>db.mycol.insert({
   _id: ObjectId(7df78ad8902c),
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
})

여기 mycol이전 장에서 만든 컬렉션 이름입니다. 컬렉션이 데이터베이스에 없으면 MongoDB는이 컬렉션을 만든 다음 문서를 삽입합니다.

삽입 된 문서에서 _id 매개 변수를 지정하지 않으면 MongoDB는이 문서에 고유 한 ObjectId를 할당합니다.

_id는 컬렉션의 모든 문서에 대해 고유 한 12 바이트 16 진수입니다. 12 바이트는 다음과 같이 나뉩니다.

_id: ObjectId(4 bytes timestamp, 3 bytes machine id, 2 bytes process id, 
   3 bytes incrementer)

단일 쿼리에 여러 문서를 삽입하려면 insert () 명령에서 문서 배열을 전달할 수 있습니다.

>db.post.insert([
   {
      title: 'MongoDB Overview', 
      description: 'MongoDB is no sql database',
      by: 'tutorials point',
      url: 'http://www.tutorialspoint.com',
      tags: ['mongodb', 'database', 'NoSQL'],
      likes: 100
   },
	
   {
      title: 'NoSQL Database', 
      description: "NoSQL database doesn't have tables",
      by: 'tutorials point',
      url: 'http://www.tutorialspoint.com',
      tags: ['mongodb', 'database', 'NoSQL'],
      likes: 20, 
      comments: [	
         {
            user:'user1',
            message: 'My first comment',
            dateCreated: new Date(2013,11,10,2,35),
            like: 0 
         }
      ]
   }
])

사용할 수있는 문서를 삽입하려면 db.post.save(document)또한. 지정하지 않으면_id 문서에서 save() 방법은 다음과 동일하게 작동합니다. insert()방법. _id를 지정하면 save () 메서드에 지정된대로 _id가 포함 된 문서의 전체 데이터를 대체합니다.

이 장에서는 MongoDB 컬렉션에서 문서를 쿼리하는 방법을 배웁니다.

find () 메서드

MongoDB 컬렉션에서 데이터를 쿼리하려면 MongoDB의 find() 방법.

통사론

기본 구문 find() 방법은 다음과 같습니다-

>db.COLLECTION_NAME.find()

find() 메소드는 구조화되지 않은 방식으로 모든 문서를 표시합니다.

pretty () 메서드

형식화 된 방식으로 결과를 표시하려면 다음을 사용할 수 있습니다. pretty() 방법.

통사론

>db.mycol.find().pretty()

>db.mycol.find().pretty()
{
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}
>

find () 메서드 외에도 findOne() 하나의 문서 만 반환하는 메서드입니다.

MongoDB에서 조항이 동일한 RDBMS

특정 조건을 기준으로 문서를 쿼리하려면 다음 작업을 사용할 수 있습니다.

조작 통사론 RDBMS 상당
평등 {<키> : <값>} db.mycol.find ({ "by": "튜토리얼 포인트"}). pretty () 여기서 = '튜토리얼 포인트'
보다 작음 {<키> : {$ lt : <값>}} db.mycol.find ({ "likes": {$ lt : 50}}). pretty () 좋아요 <50
보다 작음 {<키> : {$ lte : <값>}} db.mycol.find ({ "likes": {$ lte : 50}}). pretty () 좋아요 <= 50
보다 큰 {<키> : {$ gt : <값>}} db.mycol.find ({ "likes": {$ gt : 50}}). pretty () 좋아요> 50 개
같음보다 큼 {<키> : {$ gte : <값>}} db.mycol.find ({ "likes": {$ gte : 50}}). pretty () 좋아요> = 50
같지 않음 {<키> : {$ ne : <값>}} db.mycol.find ({ "likes": {$ ne : 50}}). pretty () 좋아요! = 50

그리고 MongoDB에서

통사론

에서 find() ''로 구분하여 여러 키를 전달하면 MongoDB는이를 다음과 같이 처리합니다. AND질환. 다음은 기본 구문입니다.AND

>db.mycol.find(
   {
      $and: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

다음 예제는 'tutorials point'가 작성하고 제목이 'MongoDB Overview'인 모든 튜토리얼을 보여줍니다.

>db.mycol.find({$and:[{"by":"tutorials point"},{"title": "MongoDB Overview"}]}).pretty() {
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}

위의 주어진 예에서 동등한 where 절은 ' where by = 'tutorials point' AND title = 'MongoDB Overview' '. find 절에서 원하는 수의 키, 값 쌍을 전달할 수 있습니다.

또는 MongoDB에서

통사론

OR 조건을 기반으로 문서를 쿼리하려면 다음을 사용해야합니다. $or예어. 다음은 기본 구문입니다.OR

>db.mycol.find(
   {
      $or: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

다음 예제는 'tutorials point'로 작성되었거나 제목이 'MongoDB Overview'인 모든 튜토리얼을 보여줍니다.

>db.mycol.find({$or:[{"by":"tutorials point"},{"title": "MongoDB Overview"}]}).pretty()
{
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}
>

AND 및 OR 함께 사용

다음 예제는 좋아요가 10 개 이상이고 제목이 'MongoDB Overview'이거나 by가 'tutorials point'인 문서를 보여줍니다. 절이있는 동등한 SQL'where likes>10 AND (by = 'tutorials point' OR title = 'MongoDB Overview')'

>db.mycol.find({"likes": {$gt:10}, $or: [{"by": "tutorials point"},
   {"title": "MongoDB Overview"}]}).pretty()
{
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}
>

MongoDB update()save()메서드는 문서를 컬렉션으로 업데이트하는 데 사용됩니다. update () 메서드는 기존 문서의 값을 업데이트하는 반면 save () 메서드는 기존 문서를 save () 메서드에 전달 된 문서로 바꿉니다.

MongoDB Update () 메서드

update () 메서드는 기존 문서의 값을 업데이트합니다.

통사론

기본 구문 update() 방법은 다음과 같습니다-

>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)

mycol 컬렉션에 다음 데이터가 있다고 가정합니다.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

다음 예제는 제목이 'MongoDB Overview'인 문서의 새 제목 'New MongoDB Tutorial'을 설정합니다.

>db.mycol.update({'title':'MongoDB Overview'},{$set:{'title':'New MongoDB Tutorial'}})
>db.mycol.find()
{ "_id" : ObjectId(5983548781331adf45ec5), "title":"New MongoDB Tutorial"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}
>

기본적으로 MongoDB는 단일 문서 만 업데이트합니다. 여러 문서를 업데이트하려면 'multi'매개 변수를 true로 설정해야합니다.

>db.mycol.update({'title':'MongoDB Overview'},
   {$set:{'title':'New MongoDB Tutorial'}},{multi:true})

MongoDB Save () 메서드

그만큼 save() 메서드는 기존 문서를 save () 메서드에 전달 된 새 문서로 바꿉니다.

통사론

MongoDB의 기본 구문 save() 방법은 다음과 같습니다-

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

다음 예제는 문서를 _id '5983548781331adf45ec5'로 바꿉니다.

>db.mycol.save(
   {
      "_id" : ObjectId(5983548781331adf45ec5), "title":"Tutorials Point New Topic",
      "by":"Tutorials Point"
   }
)
>db.mycol.find()
{ "_id" : ObjectId(5983548781331adf45ec5), "title":"Tutorials Point New Topic",
   "by":"Tutorials Point"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}
>

이 장에서는 MongoDB를 사용하여 문서를 삭제하는 방법을 배웁니다.

remove () 메서드

MongoDB remove()메서드는 컬렉션에서 문서를 제거하는 데 사용됩니다. remove () 메서드는 두 개의 매개 변수를받습니다. 하나는 삭제 기준이고 두 번째는 justOne 플래그입니다.

  • deletion criteria − (선택 사항) 문서에 따른 삭제 기준이 제거됩니다.

  • justOne − (선택 사항) true 또는 1로 설정된 경우 하나의 문서 만 제거합니다.

통사론

기본 구문 remove() 방법은 다음과 같습니다-

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

mycol 컬렉션에 다음 데이터가 있다고 가정합니다.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

다음 예제는 제목이 'MongoDB Overview'인 모든 문서를 제거합니다.

>db.mycol.remove({'title':'MongoDB Overview'})
>db.mycol.find()
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}
>

하나만 제거

여러 개의 레코드가 있고 첫 번째 레코드 만 삭제하려면 justOne 매개 변수 remove() 방법.

>db.COLLECTION_NAME.remove(DELETION_CRITERIA,1)

모든 문서 제거

삭제 기준을 지정하지 않으면 MongoDB는 컬렉션에서 전체 문서를 삭제합니다. This is equivalent of SQL's truncate command.

>db.mycol.remove({})
>db.mycol.find()
>

MongoDB에서 프로젝션은 문서의 전체 데이터를 선택하는 것이 아니라 필요한 데이터 만 선택하는 것을 의미합니다. 문서에 5 개의 필드가 있고 3 개만 표시해야하는 경우 여기에서 3 개의 필드 만 선택합니다.

find () 메서드

MongoDB find()MongoDB 쿼리 문서에 설명 된 메서드 는 검색하려는 필드 목록 인 두 번째 선택적 매개 변수를 허용합니다. MongoDB에서 실행할 때find()메서드를 사용하면 문서의 모든 필드가 표시됩니다. 이를 제한하려면 값이 1 또는 0 인 필드 목록을 설정해야합니다. 1은 필드를 표시하는 데 사용되고 0은 필드를 숨기는 데 사용됩니다.

통사론

기본 구문 find() 투영 방법은 다음과 같습니다-

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

mycol 컬렉션에 다음과 같은 데이터가 있습니다.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

다음 예제는 문서를 쿼리하는 동안 문서의 제목을 표시합니다.

>db.mycol.find({},{"title":1,_id:0})
{"title":"MongoDB Overview"}
{"title":"NoSQL Overview"}
{"title":"Tutorials Point Overview"}
>

참고 _id 필드는 실행 중에 항상 표시됩니다. find() 이 필드를 원하지 않으면 0으로 설정해야합니다.

이 장에서는 MongoDB를 사용하여 레코드를 제한하는 방법을 배웁니다.

Limit () 메서드

MongoDB에서 레코드를 제한하려면 다음을 사용해야합니다. limit()방법. 이 메소드는 표시 할 문서 수인 하나의 숫자 유형 인수를 허용합니다.

통사론

기본 구문 limit() 방법은 다음과 같습니다-

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

myycol 컬렉션에 다음 데이터가 있다고 가정합니다.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

다음 예제는 문서를 쿼리하는 동안 두 개의 문서 만 표시합니다.

>db.mycol.find({},{"title":1,_id:0}).limit(2)
{"title":"MongoDB Overview"}
{"title":"NoSQL Overview"}
>

숫자 인수를 지정하지 않은 경우 limit() 메소드는 컬렉션의 모든 문서를 표시합니다.

MongoDB Skip () 메서드

limit () 메서드 외에도 하나 이상의 메서드가 있습니다. skip() 또한 숫자 유형 인수를 허용하며 문서 수를 건너 뛰는 데 사용됩니다.

통사론

기본 구문 skip() 방법은 다음과 같습니다-

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

다음 예제는 두 번째 문서 만 표시합니다.

>db.mycol.find({},{"title":1,_id:0}).limit(1).skip(1)
{"title":"NoSQL Overview"}
>

의 기본값은 skip() 방법은 0입니다.

이 장에서는 MongoDB에서 레코드를 정렬하는 방법을 배웁니다.

sort () 메서드

MongoDB에서 문서를 정렬하려면 다음을 사용해야합니다. sort()방법. 이 메서드는 정렬 순서와 함께 필드 목록이 포함 된 문서를받습니다. 정렬 순서를 지정하려면 1과 -1이 사용됩니다. 1은 오름차순에 사용되고 -1은 내림차순에 사용됩니다.

통사론

기본 구문 sort() 방법은 다음과 같습니다-

>db.COLLECTION_NAME.find().sort({KEY:1})

myycol 컬렉션에 다음 데이터가 있다고 가정합니다.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

다음 예제는 내림차순으로 제목별로 정렬 된 문서를 표시합니다.

>db.mycol.find({},{"title":1,_id:0}).sort({"title":-1})
{"title":"Tutorials Point Overview"}
{"title":"NoSQL Overview"}
{"title":"MongoDB Overview"}
>

정렬 기본 설정을 지정하지 않으면 sort() 메소드는 문서를 오름차순으로 표시합니다.

인덱스는 쿼리의 효율적인 해결을 지원합니다. 인덱스가 없으면 MongoDB는 쿼리 문과 일치하는 문서를 선택하기 위해 컬렉션의 모든 문서를 스캔해야합니다. 이 스캔은 매우 비효율적이며 대량의 데이터를 처리하려면 MongoDB가 필요합니다.

인덱스는 데이터 세트의 작은 부분을 탐색하기 쉬운 형식으로 저장하는 특수 데이터 구조입니다. 인덱스는 인덱스에 지정된 필드 값에 따라 정렬 된 특정 필드 또는 필드 세트의 값을 저장합니다.

ensureIndex () 메서드

인덱스를 생성하려면 MongoDB의 ensureIndex () 메소드를 사용해야합니다.

통사론

기본 구문 ensureIndex() 메서드는 다음과 같습니다 ().

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

여기서 key는 인덱스를 만들려는 필드의 이름이고 1은 오름차순입니다. 내림차순으로 인덱스를 생성하려면 -1을 사용해야합니다.

>db.mycol.ensureIndex({"title":1})
>

ensureIndex() 여러 필드에 색인을 생성하기 위해 여러 필드를 전달할 수 있습니다.

>db.mycol.ensureIndex({"title":1,"description":-1})
>

ensureIndex()메서드는 옵션 목록 (선택 사항)도 허용합니다. 다음은 목록입니다-

매개 변수 유형 기술
배경 부울 인덱스를 빌드해도 다른 데이터베이스 활동이 차단되지 않도록 백그라운드에서 인덱스를 빌드합니다. 백그라운드에서 빌드하려면 true를 지정하십시오. 기본값은false.
독특한 부울 인덱스 키가 인덱스의 기존 값과 일치하는 문서의 삽입을 컬렉션에서 허용하지 않도록 고유 인덱스를 만듭니다. 고유 색인을 작성하려면 true를 지정하십시오. 기본값은false.
이름 색인의 이름입니다. 지정되지 않은 경우 MongoDB는 인덱싱 된 필드의 이름과 정렬 순서를 연결하여 인덱스 이름을 생성합니다.
dropDups 부울 중복이있을 수있는 필드에 고유 인덱스를 만듭니다. MongoDB는 키의 첫 번째 항목 만 인덱싱하고 해당 키의 후속 항목을 포함하는 컬렉션에서 모든 문서를 제거합니다. 고유 색인을 작성하려면 true를 지정하십시오. 기본값은false.
부족한 부울 true 인 경우 인덱스는 지정된 필드가있는 문서 만 참조합니다. 이러한 인덱스는 공간을 덜 사용하지만 일부 상황 (특히 정렬)에서 다르게 작동합니다. 기본값은false.
expireAfterSeconds 정수 MongoDB가이 컬렉션에 문서를 보관하는 기간을 제어하는 ​​TTL로 값 (초)을 지정합니다.
V 색인 버전 인덱스 버전 번호입니다. 기본 인덱스 버전은 인덱스를 생성 할 때 실행중인 MongoDB 버전에 따라 다릅니다.
무게 문서 가중치는 1에서 99,999 사이의 숫자이며 점수 측면에서 다른 인덱싱 된 필드와 관련된 필드의 중요성을 나타냅니다.
기본 언어 텍스트 인덱스의 경우 불용어 목록과 형태소 분석기 및 토크 나이저의 규칙을 결정하는 언어입니다. 기본값은english.
language_override 텍스트 색인의 경우 기본 언어를 대체 할 언어를 포함하는 문서의 필드 이름을 지정하십시오. 기본값은 언어입니다.

집계 작업은 데이터 레코드를 처리하고 계산 된 결과를 반환합니다. 집계 작업은 여러 문서의 값을 함께 그룹화하고 그룹화 된 데이터에 대해 다양한 작업을 수행하여 단일 결과를 반환 할 수 있습니다. SQL count (*) 및 with group by는 mongodb 집계와 동일합니다.

aggregate () 메서드

MongoDB의 집계에는 다음을 사용해야합니다. aggregate() 방법.

통사론

기본 구문 aggregate() 방법은 다음과 같습니다-

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

컬렉션에는 다음 데이터가 있습니다-

{
   _id: ObjectId(7df78ad8902c)
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by_user: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
},
{
   _id: ObjectId(7df78ad8902d)
   title: 'NoSQL Overview', 
   description: 'No sql database is very fast',
   by_user: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 10
},
{
   _id: ObjectId(7df78ad8902e)
   title: 'Neo4j Overview', 
   description: 'Neo4j is no sql database',
   by_user: 'Neo4j',
   url: 'http://www.neo4j.com',
   tags: ['neo4j', 'database', 'NoSQL'],
   likes: 750
},

이제 위 컬렉션에서 각 사용자가 작성한 튜토리얼 수를 나타내는 목록을 표시하려면 다음을 사용합니다. aggregate() 방법-

> db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
{
   "result" : [
      {
         "_id" : "tutorials point",
         "num_tutorial" : 2
      },
      {
         "_id" : "Neo4j",
         "num_tutorial" : 1
      }
   ],
   "ok" : 1
}
>

위의 사용 사례에 대한 SQL 해당 쿼리는 다음과 같습니다. select by_user, count(*) from mycol group by by_user.

위의 예에서는 필드별로 문서를 그룹화했습니다. by_userby_user가 발생할 때마다 합계의 이전 값이 증가합니다. 다음은 사용 가능한 집계 표현식 목록입니다.

표현 기술
$ 합계 컬렉션의 모든 문서에서 정의 된 값을 합산합니다. db.mycol.aggregate ([{$ group : {_id : "$by_user", num_tutorial : {$합계 : "$ likes"}}}])
$ avg 컬렉션의 모든 문서에서 주어진 모든 값의 평균을 계산합니다. db.mycol.aggregate ([{$group : {_id : "$by_user ", num_tutorial : {$avg : "$좋아요 "}}}])
$ 분 컬렉션의 모든 문서에서 해당 값의 최소값을 가져옵니다. db.mycol.aggregate ([{$ group : {_id : "$by_user", num_tutorial : {$최소 : "$ likes"}}}])
$ 최대 컬렉션의 모든 문서에서 해당 값의 최대 값을 가져옵니다. db.mycol.aggregate ([{$group : {_id : "$by_user ", num_tutorial : {$max : "$좋아요 "}}}])
$ 푸시 결과 문서의 배열에 값을 삽입합니다. db.mycol.aggregate ([{$ group : {_id : "$by_user", url : {$푸시 : "$ url"}}}])
$ addToSet 결과 문서의 배열에 값을 삽입하지만 중복을 만들지는 않습니다. db.mycol.aggregate ([{$group : {_id : "$by_user ", URL : {$addToSet : "$url "}}}])
$ first 그룹화에 따라 소스 문서에서 첫 번째 문서를 가져옵니다. 일반적으로 이것은 이전에 적용된 "$ sort"단계와 함께 만 의미가 있습니다. db.mycol.aggregate ([{$group : {_id : "$by_user ", first_url : {$first : "$url "}}}])
$ last 그룹화에 따라 소스 문서에서 마지막 문서를 가져옵니다. 일반적으로 이것은 이전에 적용된 "$ sort"단계와 함께 만 의미가 있습니다. db.mycol.aggregate ([{$group : {_id : "$by_user ", last_url : {$last : "$url "}}}])

파이프 라인 개념

UNIX 명령에서 쉘 파이프 라인은 일부 입력에서 작업을 실행하고 출력을 다음 명령의 입력으로 사용할 수있는 가능성을 의미합니다. MongoDB는 집계 프레임 워크에서도 동일한 개념을 지원합니다. 가능한 단계 세트가 있으며 각 단계는 문서 세트로 입력되어 결과 문서 세트 (또는 파이프 라인 끝에있는 최종 결과 JSON 문서)를 생성합니다. 이것은 차례로 다음 단계 등에 사용될 수 있습니다.

다음은 집계 프레임 워크에서 가능한 단계입니다.

  • $project − 컬렉션에서 특정 필드를 선택하는 데 사용됩니다.

  • $match − 이는 필터링 작업이므로 다음 단계에 입력으로 제공되는 문서의 양을 줄일 수 있습니다.

  • $group − 위에서 설명한대로 실제 집계를 수행합니다.

  • $sort − 문서를 정렬합니다.

  • $skip −이를 통해 주어진 문서 양에 대해 문서 목록에서 앞으로 건너 뛸 수 있습니다.

  • $limit − 이것은 현재 위치에서 시작하여 주어진 번호로 볼 문서의 양을 제한합니다.

  • $unwind− 배열을 사용하는 문서를 풀 때 사용합니다. 배열을 사용할 때 데이터는 일종의 사전 결합이며이 작업은 개별 문서를 다시 갖기 위해 취소됩니다. 따라서이 단계에서는 다음 단계를위한 문서의 양을 늘릴 것입니다.

복제는 여러 서버에서 데이터를 동기화하는 프로세스입니다. 복제는 중복성을 제공하고 서로 다른 데이터베이스 서버에있는 여러 데이터 복사본을 통해 데이터 가용성을 높입니다. 복제는 단일 서버의 손실로부터 데이터베이스를 보호합니다. 또한 복제를 통해 하드웨어 오류 및 서비스 중단으로부터 복구 할 수 있습니다. 데이터의 추가 복사본을 사용하면 재해 복구,보고 또는 백업 전용으로 사용할 수 있습니다.

왜 복제인가?

  • 데이터를 안전하게 유지하려면
  • 높은 (24 * 7) 데이터 가용성
  • 재해 복구
  • 유지 관리를위한 다운 타임 없음 (예 : 백업, 인덱스 재 구축, 압축)
  • 읽기 배율 (읽을 추가 복사본)
  • 복제본 세트는 애플리케이션에 투명합니다.

MongoDB에서 복제가 작동하는 방식

MongoDB는 복제 세트를 사용하여 복제를 수행합니다. 복제 세트는mongod동일한 데이터 세트를 호스팅하는 인스턴스. 복제본에서 하나의 노드는 모든 쓰기 작업을 수신하는 기본 노드입니다. 보조와 같은 다른 모든 인스턴스는 동일한 데이터 세트를 갖도록 기본에서 작업을 적용합니다. 복제본 세트에는 하나의 기본 노드 만있을 수 있습니다.

  • 복제 세트는 두 개 이상의 노드 그룹입니다 (일반적으로 최소 3 개의 노드가 필요함).

  • 복제본 세트에서 한 노드는 기본 노드이고 나머지 노드는 보조 노드입니다.

  • 모든 데이터는 기본 노드에서 보조 노드로 복제됩니다.

  • 자동 장애 조치 또는 유지 관리시 기본에 대한 선택이 설정되고 새 기본 노드가 선택됩니다.

  • 장애가 발생한 노드를 복구 한 후 다시 복제 세트에 가입하고 보조 노드로 작동합니다.

클라이언트 애플리케이션이 항상 기본 노드와 상호 작용하고 기본 노드가 데이터를 보조 노드에 복제하는 MongoDB 복제의 일반적인 다이어그램이 표시됩니다.

복제 세트 기능

  • N 노드의 클러스터
  • 하나의 노드가 기본이 될 수 있습니다.
  • 모든 쓰기 작업이 기본으로 이동
  • 자동 장애 조치
  • 자동 복구
  • 예비 선거의 합의 선거

복제 세트 설정

이 자습서에서는 독립 실행 형 MongoDB 인스턴스를 복제본 세트로 변환합니다. 복제 세트로 변환하는 단계는 다음과 같습니다.

  • 이미 MongoDB 서버를 실행중인 종료.

  • -replSet 옵션을 지정하여 MongoDB 서버를 시작하십시오. 다음은 --replSet의 기본 구문입니다.

mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"

mongod --port 27017 --dbpath "D:\set up\mongodb\data" --replSet rs0
  • 포트 27017에서 이름이 rs0 인 mongod 인스턴스를 시작합니다.

  • 이제 명령 프롬프트를 시작하고이 mongod 인스턴스에 연결하십시오.

  • Mongo 클라이언트에서 다음 명령을 실행하십시오. rs.initiate() 새 복제 세트를 시작합니다.

  • 복제본 세트 구성을 확인하려면 다음 명령을 실행하십시오. rs.conf(). 복제본 세트의 상태를 확인하려면 다음 명령을 실행하십시오.rs.status().

복제 세트에 구성원 추가

복제본 세트에 구성원을 추가하려면 여러 머신에서 mongod 인스턴스를 시작하십시오. 이제 mongo 클라이언트를 시작하고 명령을 실행하십시오.rs.add().

통사론

기본 구문 rs.add() 명령은 다음과 같습니다-

>rs.add(HOST_NAME:PORT)

mongod 인스턴스 이름이 다음과 같다고 가정합니다. mongod1.net 포트에서 실행 중입니다. 27017. 이 인스턴스를 복제본 세트에 추가하려면 다음 명령어를 실행하세요.rs.add() Mongo 클라이언트에서.

>rs.add("mongod1.net:27017")
>

mongod 인스턴스는 기본 노드에 연결된 경우에만 복제본 세트에 추가 할 수 있습니다. 기본에 연결되어 있는지 확인하려면 다음 명령을 실행하십시오.db.isMaster() 몽고 클라이언트에서.

샤딩은 여러 시스템에 걸쳐 데이터 레코드를 저장하는 프로세스이며 데이터 증가 요구를 충족하기위한 MongoDB의 접근 방식입니다. 데이터 크기가 증가함에 따라 단일 시스템으로 데이터를 저장하거나 허용 가능한 읽기 및 쓰기 처리량을 제공하지 못할 수 있습니다. 샤딩은 수평 확장 문제를 해결합니다. 샤딩을 사용하면 데이터 증가와 읽기 및 쓰기 작업 요구를 지원하기 위해 더 많은 시스템을 추가 할 수 있습니다.

왜 샤딩인가?

  • 복제시 모든 쓰기는 마스터 노드로 이동합니다.
  • 지연 시간에 민감한 쿼리는 여전히 마스터로 이동합니다.
  • 단일 복제본 세트는 12 개의 노드로 제한됩니다.
  • 활성 데이터 세트가 크면 메모리가 충분히 클 수 없습니다.
  • 로컬 디스크가 충분히 크지 않습니다.
  • 수직 확장은 너무 비쌉니다.

MongoDB의 샤딩

다음 다이어그램은 샤딩 된 클러스터를 사용하는 MongoDB의 샤딩을 보여줍니다.

다음 다이어그램에는 세 가지 주요 구성 요소가 있습니다.

  • Shards− 샤드는 데이터를 저장하는 데 사용됩니다. 고 가용성 및 데이터 일관성을 제공합니다. 프로덕션 환경에서 각 샤드는 별도의 복제본 세트입니다.

  • Config Servers− 구성 서버는 클러스터의 메타 데이터를 저장합니다. 이 데이터에는 샤드에 대한 클러스터 데이터 세트의 매핑이 포함됩니다. 쿼리 라우터는이 메타 데이터를 사용하여 작업을 특정 샤드로 지정합니다. 프로덕션 환경에서 분할 된 클러스터에는 정확히 3 개의 구성 서버가 있습니다.

  • Query Routers− 쿼리 라우터는 기본적으로 mongo 인스턴스이며 클라이언트 애플리케이션과의 인터페이스 및 적절한 샤드에 대한 직접적인 작업입니다. 쿼리 라우터는 작업을 처리하고 샤드 대상으로 지정한 다음 결과를 클라이언트에 반환합니다. 분할 된 클러스터에는 클라이언트 요청로드를 분할하기 위해 둘 이상의 쿼리 라우터가 포함될 수 있습니다. 클라이언트는 하나의 쿼리 라우터에 요청을 보냅니다. 일반적으로 분할 된 클러스터에는 많은 쿼리 라우터가 있습니다.

이 장에서는 MongoDB에서 백업을 만드는 방법을 알아 봅니다.

MongoDB 데이터 덤프

MongoDB에서 데이터베이스 백업을 생성하려면 다음을 사용해야합니다. mongodump명령. 이 명령은 서버의 전체 데이터를 덤프 디렉토리로 덤프합니다. 데이터 양을 제한하거나 원격 서버의 백업을 생성 할 수있는 많은 옵션이 있습니다.

통사론

기본 구문 mongodump 명령은 다음과 같습니다-

>mongodump

mongod 서버를 시작하십시오. mongod 서버가 localhost 및 포트 27017에서 실행 중이라고 가정하고 명령 프롬프트를 열고 mongodb 인스턴스의 bin 디렉토리로 이동하여 명령을 입력하십시오.mongodump

mycol 컬렉션에 다음 데이터가 있다고 가정합니다.

>mongodump

이 명령은 다음 위치에서 실행되는 서버에 연결됩니다. 127.0.0.1 및 포트 27017 서버의 모든 데이터를 디렉토리에 백업 /bin/dump/. 다음은 명령의 출력입니다-

다음은와 함께 사용할 수있는 사용 가능한 옵션 목록입니다. mongodump 명령.

통사론 기술
mongodump --host HOST_NAME --port PORT_NUMBER 이 명령은 지정된 mongod 인스턴스의 모든 데이터베이스를 백업합니다. mongodump --host tutorialspoint.com --port 27017
mongodump --dbpath DB_PATH --out BACKUP_DIRECTORY 이 명령은 지정된 경로에 지정된 데이터베이스 만 백업합니다. mongodump --dbpath / data / db / --out / data / backup /
mongodump --collection COLLECTION --db DB_NAME 이 명령은 지정된 데이터베이스의 지정된 컬렉션 만 백업합니다. mongodump --collection mycol --db 테스트

데이터 복원

백업 데이터 MongoDB를 복원하려면 mongorestore명령이 사용됩니다. 이 명령은 백업 디렉토리에서 모든 데이터를 복원합니다.

통사론

기본 구문 mongorestore 명령은-

>mongorestore

다음은 명령의 출력입니다-

MongoDB 배포를 준비 할 때 애플리케이션이 프로덕션에서 어떻게 유지되는지 이해해야합니다. 배포 환경을 관리하는 일관되고 반복 가능한 접근 방식을 개발하여 프로덕션에 들어가면 놀라움을 최소화 할 수 있도록하는 것이 좋습니다.

가장 좋은 방법은 설정 프로토 타이핑, 부하 테스트 수행, 주요 측정 항목 모니터링, 해당 정보를 사용하여 설정을 확장하는 것입니다. 접근 방식의 핵심 부분은 전체 시스템을 사전에 모니터링하는 것입니다. 이렇게하면 배포 전에 프로덕션 시스템이 어떻게 유지되는지 이해하고 용량을 추가해야하는 위치를 결정하는 데 도움이됩니다. 예를 들어, 메모리 사용량의 잠재적 인 급증에 대한 통찰력이 있으면 시작하기 전에 쓰기 잠금 문제를 해결하는 데 도움이 될 수 있습니다.

배포를 모니터링하기 위해 MongoDB는 다음 명령 중 일부를 제공합니다.

몽고 스타트

이 명령은 실행중인 모든 mongod 인스턴스의 상태를 확인하고 데이터베이스 작업 카운터를 반환합니다. 이러한 카운터에는 삽입, 쿼리, 업데이트, 삭제 및 커서가 포함됩니다. Command는 페이지 폴트가 발생했을 때도 표시하고 잠금 비율을 보여줍니다. 이는 메모리가 부족하거나 쓰기 용량에 도달하거나 성능 문제가 있음을 의미합니다.

명령을 실행하려면 mongod 인스턴스를 시작하십시오. 다른 명령 프롬프트에서bin mongodb 설치 디렉토리 및 유형 mongostat.

D:\set up\mongodb\bin>mongostat

다음은 명령의 출력입니다-

몽고

이 명령은 컬렉션 단위로 MongoDB 인스턴스의 읽기 및 쓰기 활동을 추적하고보고합니다. 기본적으로,mongotop매초마다 정보를 반환하며 이에 따라 변경할 수 있습니다. 이 읽기 및 쓰기 활동이 애플리케이션 의도와 일치하는지, 그리고 한 번에 데이터베이스에 너무 많은 쓰기를 실행하지 않았는지, 디스크에서 너무 자주 읽는지 또는 작업 세트 크기를 초과하는지 확인해야합니다.

명령을 실행하려면 mongod 인스턴스를 시작하십시오. 다른 명령 프롬프트에서bin mongodb 설치 디렉토리 및 유형 mongotop.

D:\set up\mongodb\bin>mongotop

다음은 명령의 출력입니다-

바꾸다 mongotop 정보를 덜 자주 반환하려면 mongotop 명령 뒤에 특정 번호를 지정하십시오.

D:\set up\mongodb\bin>mongotop 30

위의 예는 30 초마다 값을 반환합니다.

MongoDB 도구 외에도 10gen은 대시 보드를 제공하고 전체 클러스터의 메트릭보기를 제공하는 무료 호스팅 모니터링 서비스 인 MongoDB 관리 서비스 (MMS)를 제공합니다.

이 장에서는 MongoDB JDBC 드라이버를 설정하는 방법을 배웁니다.

설치

Java 프로그램에서 MongoDB 사용을 시작하기 전에 MongoDB JDBC 드라이버 및 Java가 시스템에 설정되어 있는지 확인해야합니다. 컴퓨터에서 Java 설치에 대한 Java 자습서를 확인할 수 있습니다. 이제 MongoDB JDBC 드라이버를 설정하는 방법을 살펴 보겠습니다.

  • 다운로드 mongo.jar 경로에서 jar를 다운로드해야합니다 . 최신 릴리스를 다운로드하십시오.

  • mongo.jar를 클래스 경로에 포함해야합니다.

데이터베이스에 연결

데이터베이스를 연결하려면 데이터베이스 이름을 지정해야합니다. 데이터베이스가 없으면 MongoDB가 자동으로 생성합니다.

다음은 데이터베이스에 연결하는 코드 스 니펫입니다.

import com.mongodb.client.MongoDatabase; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class ConnectToDB { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
   
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 
      System.out.println("Credentials ::"+ credential);     
   } 
}

이제 위의 프로그램을 컴파일하고 실행하여 아래와 같이 myDb 데이터베이스를 만들어 보겠습니다.

$javac ConnectToDB.java 
$java ConnectToDB

실행시 위의 프로그램은 다음과 같은 출력을 제공합니다.

Connected to the database successfully 
Credentials ::MongoCredential{
   mechanism = null, 
   userName = 'sampleUser', 
   source = 'myDb', 
   password = <hidden>, 
   mechanismProperties = {}
}

컬렉션 만들기

컬렉션을 만들려면 createCollection() 의 방법 com.mongodb.client.MongoDatabase 클래스가 사용됩니다.

다음은 컬렉션을 만드는 코드 스 니펫입니다-

import com.mongodb.client.MongoDatabase; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class CreatingCollection { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
     
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      //Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      //Creating a collection 
      database.createCollection("sampleCollection"); 
      System.out.println("Collection created successfully"); 
   } 
}

컴파일시 위의 프로그램은 다음과 같은 결과를 제공합니다.

Connected to the database successfully 
Collection created successfully

컬렉션 가져 오기 / 선택

데이터베이스에서 컬렉션을 가져 오거나 선택하려면 getCollection() 의 방법 com.mongodb.client.MongoDatabase 클래스가 사용됩니다.

다음은 컬렉션을 가져 오거나 선택하는 프로그램입니다.

import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 

import org.bson.Document; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class selectingCollection { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
     
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      // Creating a collection 
      System.out.println("Collection created successfully"); 

      // Retieving a collection
      MongoCollection<Document> collection = database.getCollection("myCollection"); 
      System.out.println("Collection myCollection selected successfully"); 
   }
}

컴파일시 위의 프로그램은 다음과 같은 결과를 제공합니다.

Connected to the database successfully 
Collection created successfully 
Collection myCollection selected successfully

문서 삽입

MongoDB에 문서를 삽입하려면 insert() 의 방법 com.mongodb.client.MongoCollection 클래스가 사용됩니다.

다음은 문서를 삽입하는 코드 스 니펫입니다.

import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 

import org.bson.Document;  
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class InsertingDocument { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 

      // Retrieving a collection
      MongoCollection<Document> collection = database.getCollection("sampleCollection"); 
      System.out.println("Collection sampleCollection selected successfully");

      Document document = new Document("title", "MongoDB") 
      .append("id", 1)
      .append("description", "database") 
      .append("likes", 100) 
      .append("url", "http://www.tutorialspoint.com/mongodb/") 
      .append("by", "tutorials point");  
      collection.insertOne(document); 
      System.out.println("Document inserted successfully");     
   } 
}

컴파일시 위의 프로그램은 다음과 같은 결과를 제공합니다.

Connected to the database successfully 
Collection sampleCollection selected successfully 
Document inserted successfully

모든 문서 검색

컬렉션에서 모든 문서를 선택하려면 find() 의 방법 com.mongodb.client.MongoCollection클래스가 사용됩니다. 이 메서드는 커서를 반환하므로이 커서를 반복해야합니다.

다음은 모든 문서를 선택하는 프로그램입니다-

import com.mongodb.client.FindIterable; 
import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase;  

import java.util.Iterator; 
import org.bson.Document; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class RetrievingAllDocuments { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential;
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      // Retrieving a collection 
      MongoCollection<Document> collection = database.getCollection("sampleCollection");
      System.out.println("Collection sampleCollection selected successfully"); 

      // Getting the iterable object 
      FindIterable<Document> iterDoc = collection.find(); 
      int i = 1; 

      // Getting the iterator 
      Iterator it = iterDoc.iterator(); 
    
      while (it.hasNext()) {  
         System.out.println(it.next());  
      i++; 
      }
   } 
}

컴파일시 위의 프로그램은 다음과 같은 결과를 제공합니다.

Document{{
   _id = 5967745223993a32646baab8, 
   title = MongoDB, 
   id = 1, 
   description = database, 
   likes = 100, 
   url = http://www.tutorialspoint.com/mongodb/, by = tutorials point
}}  
Document{{
   _id = 7452239959673a32646baab8, 
   title = RethinkDB, 
   id = 2, 
   description = database, 
   likes = 200, 
   url = http://www.tutorialspoint.com/rethinkdb/, by = tutorials point
}}

문서 업데이트

컬렉션에서 문서를 업데이트하려면 updateOne() 의 방법 com.mongodb.client.MongoCollection 클래스가 사용됩니다.

다음은 첫 번째 문서를 선택하는 프로그램입니다.

import com.mongodb.client.FindIterable; 
import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 
import com.mongodb.client.model.Filters; 
import com.mongodb.client.model.Updates; 

import java.util.Iterator; 
import org.bson.Document;  
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class UpdatingDocuments { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
     
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 

      // Retrieving a collection 
      MongoCollection<Document> collection = database.getCollection("sampleCollection");
      System.out.println("Collection myCollection selected successfully"); 

      collection.updateOne(Filters.eq("id", 1), Updates.set("likes", 150));       
      System.out.println("Document update successfully...");  
      
      // Retrieving the documents after updation 
      // Getting the iterable object
      FindIterable<Document> iterDoc = collection.find(); 
      int i = 1; 

      // Getting the iterator 
      Iterator it = iterDoc.iterator(); 

      while (it.hasNext()) {  
         System.out.println(it.next());  
         i++; 
      }     
   }  
}

컴파일시 위의 프로그램은 다음과 같은 결과를 제공합니다.

Document update successfully... 
Document {{
   _id = 5967745223993a32646baab8, 
   title = MongoDB, 
   id = 1, 
   description = database, 
   likes = 150, 
   url = http://www.tutorialspoint.com/mongodb/, by = tutorials point
}}

문서 삭제

컬렉션에서 문서를 삭제하려면 다음을 사용해야합니다. deleteOne() 의 방법 com.mongodb.client.MongoCollection 수업.

다음은 문서를 삭제하는 프로그램입니다-

import com.mongodb.client.FindIterable; 
import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 
import com.mongodb.client.model.Filters;  

import java.util.Iterator; 
import org.bson.Document; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class DeletingDocuments { 
   
   public static void main( String args[] ) {  
   
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 );
      
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 

      // Retrieving a collection
      MongoCollection<Document> collection = database.getCollection("sampleCollection");
      System.out.println("Collection sampleCollection selected successfully"); 

      // Deleting the documents 
      collection.deleteOne(Filters.eq("id", 1)); 
      System.out.println("Document deleted successfully...");  
      
      // Retrieving the documents after updation 
      // Getting the iterable object 
      FindIterable<Document> iterDoc = collection.find(); 
      int i = 1; 

      // Getting the iterator 
      Iterator it = iterDoc.iterator(); 

      while (it.hasNext()) {  
         System.out.println("Inserted Document: "+i);  
         System.out.println(it.next());  
         i++; 
      }       
   } 
}

컴파일시 위의 프로그램은 다음과 같은 결과를 제공합니다.

Connected to the database successfully 
Collection sampleCollection selected successfully 
Document deleted successfully...

컬렉션 삭제

데이터베이스에서 컬렉션을 삭제하려면 다음을 사용해야합니다. drop() 의 방법 com.mongodb.client.MongoCollection 수업.

다음은 컬렉션을 삭제하는 프로그램입니다-

import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase;  

import org.bson.Document;  
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class DropingCollection { 
   
   public static void main( String args[] ) {  

      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      // Creating a collection 
      System.out.println("Collections created successfully"); 

      // Retieving a collection
      MongoCollection<Document> collection = database.getCollection("sampleCollection");

      // Dropping a Collection 
      collection.drop(); 
      System.out.println("Collection dropped successfully");
   } 
}

컴파일시 위의 프로그램은 다음과 같은 결과를 제공합니다.

Connected to the database successfully 
Collection sampleCollection selected successfully 
Collection dropped successfully

모든 컬렉션 나열

데이터베이스의 모든 컬렉션을 나열하려면 다음을 사용해야합니다. listCollectionNames() 의 방법 com.mongodb.client.MongoDatabase 수업.

다음은 데이터베이스의 모든 컬렉션을 나열하는 프로그램입니다-

import com.mongodb.client.MongoDatabase; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class ListOfCollection { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 

      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 
      System.out.println("Collection created successfully"); 
      for (String name : database.listCollectionNames()) { 
         System.out.println(name); 
      } 
   }
}

컴파일시 위의 프로그램은 다음과 같은 결과를 제공합니다.

Connected to the database successfully 
Collection created successfully 
myCollection 
myCollection1 
myCollection5

남은 MongoDB 메서드 save(), limit(), skip(), sort() 등은 후속 자습서에서 설명한 것과 동일하게 작동합니다.

MongoDB를 PHP와 함께 사용하려면 MongoDB PHP 드라이버를 사용해야합니다. URL 다운로드 PHP 드라이버 에서 드라이버를 다운로드합니다 . 최신 릴리스를 다운로드하십시오. 이제 아카이브의 압축을 풀고 php_mongo.dll을 PHP 확장 디렉토리 (기본적으로 "ext")에 넣고 php.ini 파일에 다음 줄을 추가합니다.

extension = php_mongo.dll

연결 및 데이터베이스 선택

연결하려면 데이터베이스 이름을 지정해야합니다. 데이터베이스가 없으면 MongoDB가 자동으로 생성합니다.

다음은 데이터베이스에 연결하는 코드 스 니펫입니다.

<?php
   // connect to mongodb
   $m = new MongoClient();
	
   echo "Connection to database successfully";
   // select a database
   $db = $m->mydb;
	
   echo "Database mydb selected";
?>

프로그램이 실행되면 다음 결과가 생성됩니다.

Connection to database successfully
Database mydb selected

컬렉션 만들기

다음은 컬렉션을 만드는 코드 스 니펫입니다-

<?php
   // connect to mongodb
   $m = new MongoClient(); echo "Connection to database successfully"; // select a database $db = $m->mydb; echo "Database mydb selected"; $collection = $db->createCollection("mycol");
   echo "Collection created succsessfully";
?>

프로그램이 실행되면 다음 결과가 생성됩니다.

Connection to database successfully
Database mydb selected
Collection created succsessfully

문서 삽입

MongoDB에 문서를 삽입하려면 insert() 방법이 사용됩니다.

다음은 문서를 삽입하는 코드 스 니펫입니다.

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";
	
   $document = array( "title" => "MongoDB", "description" => "database", "likes" => 100, "url" => "http://www.tutorialspoint.com/mongodb/", "by" => "tutorials point" ); $collection->insert($document);
   echo "Document inserted successfully";
?>

프로그램이 실행되면 다음 결과가 생성됩니다.

Connection to database successfully
Database mydb selected
Collection selected succsessfully
Document inserted successfully

모든 문서 찾기

컬렉션에서 모든 문서를 선택하려면 find () 메서드가 사용됩니다.

다음은 모든 문서를 선택하는 코드 스 니펫입니다.

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";

   $cursor = $collection->find();
   // iterate cursor to display title of documents
	
   foreach ($cursor as $document) {
      echo $document["title"] . "\n";
   }
?>

프로그램이 실행되면 다음 결과가 생성됩니다.

Connection to database successfully
Database mydb selected
Collection selected succsessfully {
   "title": "MongoDB"
}

문서 업데이트

문서를 업데이트하려면 update () 메서드를 사용해야합니다.

다음 예에서는 삽입 된 문서의 제목을 다음으로 업데이트합니다. MongoDB Tutorial. 다음은 문서를 업데이트하는 코드 스 니펫입니다.

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";

   // now update the document
   $collection->update(array("title"=>"MongoDB"), array('$set'=>array("title"=>"MongoDB Tutorial")));
   echo "Document updated successfully";
	
   // now display the updated document
   $cursor = $collection->find();
	
   // iterate cursor to display title of documents
   echo "Updated document";
	
   foreach ($cursor as $document) {
      echo $document["title"] . "\n";
   }
?>

프로그램이 실행되면 다음 결과가 생성됩니다.

Connection to database successfully
Database mydb selected
Collection selected succsessfully
Document updated successfully
Updated document {
   "title": "MongoDB Tutorial"
}

문서 삭제

문서를 삭제하려면 remove () 메서드를 사용해야합니다.

다음 예에서는 제목이있는 문서를 제거합니다. MongoDB Tutorial. 다음은 문서를 삭제하는 코드 스 니펫입니다.

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";
   
   // now remove the document
   $collection->remove(array("title"=>"MongoDB Tutorial"),false); echo "Documents deleted successfully"; // now display the available documents $cursor = $collection->find(); // iterate cursor to display title of documents echo "Updated document"; foreach ($cursor as $document) { echo $document["title"] . "\n";
   }
?>

프로그램이 실행되면 다음 결과가 생성됩니다.

Connection to database successfully
Database mydb selected
Collection selected succsessfully
Documents deleted successfully

위의 예에서 두 번째 매개 변수는 부울 유형이며 justOne 분야의 remove() 방법.

남은 MongoDB 메서드 findOne(), save(), limit(), skip(), sort() 등은 위에서 설명한 것과 동일하게 작동합니다.

MongoDB의 관계는 다양한 문서가 논리적으로 서로 어떻게 관련되어 있는지를 나타냅니다. 관계는 다음을 통해 모델링 할 수 있습니다.EmbeddedReferenced구혼. 이러한 관계는 1 : 1, 1 : N, N : 1 또는 N : N 일 수 있습니다.

사용자를 위해 주소를 저장하는 경우를 고려해 보겠습니다. 따라서 한 사용자가 여러 주소를 가질 수 있으므로 1 : N 관계가됩니다.

다음은 샘플 문서 구조입니다. user 문서-

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "name": "Tom Hanks",
   "contact": "987654321",
   "dob": "01-01-1991"
}

다음은 샘플 문서 구조입니다. address 문서-

{
   "_id":ObjectId("52ffc4a5d85242602e000000"),
   "building": "22 A, Indiana Apt",
   "pincode": 123456,
   "city": "Los Angeles",
   "state": "California"
}

내재 된 관계 모델링

임베디드 접근 방식에서는 사용자 문서 내에 주소 문서를 임베드합니다.

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin",
   "address": [
      {
         "building": "22 A, Indiana Apt",
         "pincode": 123456,
         "city": "Los Angeles",
         "state": "California"
      },
      {
         "building": "170 A, Acropolis Apt",
         "pincode": 456789,
         "city": "Chicago",
         "state": "Illinois"
      }
   ]
}

이 접근 방식은 모든 관련 데이터를 단일 문서에 유지하므로 검색 및 유지 관리가 쉽습니다. 전체 문서는 다음과 같은 단일 쿼리로 검색 할 수 있습니다.

>db.users.findOne({"name":"Tom Benzamin"},{"address":1})

위 쿼리에서 dbusers 각각 데이터베이스와 컬렉션입니다.

단점은 포함 된 문서의 크기가 계속 커지면 읽기 / 쓰기 성능에 영향을 미칠 수 있다는 것입니다.

참조 된 관계 모델링

이것이 정규화 된 관계를 설계하는 접근 방식입니다. 이 접근 방식에서는 사용자 문서와 주소 문서가 모두 별도로 유지되지만 사용자 문서에는 주소 문서의 주소를 참조하는 필드가 포함됩니다.id 들.

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin",
   "address_ids": [
      ObjectId("52ffc4a5d85242602e000000"),
      ObjectId("52ffc4a5d85242602e000001")
   ]
}

위와 같이 사용자 문서에는 배열 필드가 포함됩니다. address_ids해당 주소의 ObjectId를 포함합니다. 이러한 ObjectId를 사용하여 주소 문서를 쿼리하고 거기에서 주소 세부 정보를 가져올 수 있습니다. 이 접근 방식에서는 두 개의 쿼리가 필요합니다.address_ids 필드에서 user 이 주소를 가져 오는 두 번째 address 수집.

>var result = db.users.findOne({"name":"Tom Benzamin"},{"address_ids":1})
>var addresses = db.address.find({"_id":{"$in":result["address_ids"]}})

MongoDB 관계의 마지막 장에서 볼 수 있듯이 MongoDB에서 정규화 된 데이터베이스 구조를 구현하기 위해 다음 개념을 사용합니다. Referenced Relationships 일컬어 Manual References여기서 참조 된 문서의 ID를 다른 문서에 수동으로 저장합니다. 그러나 문서에 다른 컬렉션의 참조가 포함 된 경우MongoDB DBRefs.

DBRefs 대 수동 참조

수동 참조 대신 DBRef를 사용하는 시나리오의 예로서, 다른 컬렉션 (address_home, address_office, address_mailing 등)에 다른 유형의 주소 (집, 사무실, 우편물 등)를 저장하는 데이터베이스를 고려하십시오. 이제user컬렉션의 문서는 주소를 참조하며 주소 유형에 따라 살펴볼 컬렉션도 지정해야합니다. 문서가 여러 컬렉션의 문서를 참조하는 시나리오에서는 DBRef를 사용해야합니다.

DBRef 사용

DBRefs에는 세 개의 필드가 있습니다-

  • $ref −이 필드는 참조 문서의 컬렉션을 지정합니다.

  • $id −이 필드는 참조 문서의 _id 필드를 지정합니다.

  • $db − 선택 필드이며 참조 문서가있는 데이터베이스의 이름을 포함합니다.

DBRef 필드가있는 샘플 사용자 문서를 고려하십시오. address 코드 스 니펫에서 볼 수 있듯이-

{
   "_id":ObjectId("53402597d852426020000002"),
   "address": {
   "$ref": "address_home", "$id": ObjectId("534009e4d852427820000002"),
   "$db": "tutorialspoint"},
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin"
}

그만큼 address 여기서 DBRef 필드는 참조 된 주소 문서가 address_home 아래 컬렉션 tutorialspoint 데이터베이스의 ID는 534009e4d852427820000002입니다.

다음 코드는 지정된 컬렉션을 동적으로 찾습니다. $ref 매개 변수 (address_home 우리의 경우) ID가 지정된 문서의 경우 $id DBRef의 매개 변수.

>var user = db.users.findOne({"name":"Tom Benzamin"})
>var dbRef = user.address
>db[dbRef.$ref].findOne({"_id":(dbRef.$id)})

위의 코드는 다음 주소 문서를 반환합니다. address_home collection −

{
   "_id" : ObjectId("534009e4d852427820000002"),
   "building" : "22 A, Indiana Apt",
   "pincode" : 123456,
   "city" : "Los Angeles",
   "state" : "California"
}

In this chapter, we will learn about covered queries.

What is a Covered Query?

As per the official MongoDB documentation, a covered query is a query in which −

  • All the fields in the query are part of an index.
  • All the fields returned in the query are in the same index.

Since all the fields present in the query are part of an index, MongoDB matches the query conditions and returns the result using the same index without actually looking inside the documents. Since indexes are present in RAM, fetching data from indexes is much faster as compared to fetching data by scanning documents.

Using Covered Queries

To test covered queries, consider the following document in the users collection −

{
   "_id": ObjectId("53402597d852426020000002"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "gender": "M",
   "name": "Tom Benzamin",
   "user_name": "tombenzamin"
}

We will first create a compound index for the users collection on the fields gender and user_name using the following query −

>db.users.ensureIndex({gender:1,user_name:1})

Now, this index will cover the following query −

>db.users.find({gender:"M"},{user_name:1,_id:0})

That is to say that for the above query, MongoDB would not go looking into database documents. Instead it would fetch the required data from indexed data which is very fast.

Since our index does not include _id field, we have explicitly excluded it from result set of our query, as MongoDB by default returns _id field in every query. So the following query would not have been covered inside the index created above −

>db.users.find({gender:"M"},{user_name:1})

Lastly, remember that an index cannot cover a query if −

  • Any of the indexed fields is an array
  • Any of the indexed fields is a subdocument

Analyzing queries is a very important aspect of measuring how effective the database and indexing design is. We will learn about the frequently used $explain and $hint queries.

Using $explain

The $explain operator provides information on the query, indexes used in a query and other statistics. It is very useful when analyzing how well your indexes are optimized.

In the last chapter, we had already created an index for the users collection on fields gender and user_name using the following query −

>db.users.ensureIndex({gender:1,user_name:1})

We will now use $explain on the following query −

>db.users.find({gender:"M"},{user_name:1,_id:0}).explain()

The above explain() query returns the following analyzed result −

{
   "cursor" : "BtreeCursor gender_1_user_name_1",
   "isMultiKey" : false,
   "n" : 1,
   "nscannedObjects" : 0,
   "nscanned" : 1,
   "nscannedObjectsAllPlans" : 0,
   "nscannedAllPlans" : 1,
   "scanAndOrder" : false,
   "indexOnly" : true,
   "nYields" : 0,
   "nChunkSkips" : 0,
   "millis" : 0,
   "indexBounds" : {
      "gender" : [
         [
            "M",
            "M"
         ]
      ],
      "user_name" : [
         [
            {
               "$minElement" : 1 }, { "$maxElement" : 1
            }
         ]
      ]
   }
}

We will now look at the fields in this result set −

  • The true value of indexOnly indicates that this query has used indexing.

  • The cursor field specifies the type of cursor used. BTreeCursor type indicates that an index was used and also gives the name of the index used. BasicCursor indicates that a full scan was made without using any indexes.

  • n indicates the number of documents matching returned.

  • nscannedObjects indicates the total number of documents scanned.

  • nscanned indicates the total number of documents or index entries scanned.

Using $hint

The $hint operator forces the query optimizer to use the specified index to run a query. This is particularly useful when you want to test performance of a query with different indexes. For example, the following query specifies the index on fields gender and user_name to be used for this query −

>db.users.find({gender:"M"},{user_name:1,_id:0}).hint({gender:1,user_name:1})

To analyze the above query using $explain −

>db.users.find({gender:"M"},{user_name:1,_id:0}).hint({gender:1,user_name:1}).explain()

Model Data for Atomic Operations

The recommended approach to maintain atomicity would be to keep all the related information, which is frequently updated together in a single document using embedded documents. This would make sure that all the updates for a single document are atomic.

Consider the following products document −

{
   "_id":1,
   "product_name": "Samsung S3",
   "category": "mobiles",
   "product_total": 5,
   "product_available": 3,
   "product_bought_by": [
      {
         "customer": "john",
         "date": "7-Jan-2014"
      },
      {
         "customer": "mark",
         "date": "8-Jan-2014"
      }
   ]
}

In this document, we have embedded the information of the customer who buys the product in the product_bought_by field. Now, whenever a new customer buys the product, we will first check if the product is still available using product_available field. If available, we will reduce the value of product_available field as well as insert the new customer's embedded document in the product_bought_by field. We will use findAndModify command for this functionality because it searches and updates the document in the same go.

>db.products.findAndModify({ 
   query:{_id:2,product_available:{$gt:0}}, 
   update:{ 
      $inc:{product_available:-1}, $push:{product_bought_by:{customer:"rob",date:"9-Jan-2014"}} 
   }    
})

Our approach of embedded document and using findAndModify query makes sure that the product purchase information is updated only if it the product is available. And the whole of this transaction being in the same query, is atomic.

In contrast to this, consider the scenario where we may have kept the product availability and the information on who has bought the product, separately. In this case, we will first check if the product is available using the first query. Then in the second query we will update the purchase information. However, it is possible that between the executions of these two queries, some other user has purchased the product and it is no more available. Without knowing this, our second query will update the purchase information based on the result of our first query. This will make the database inconsistent because we have sold a product which is not available.

Consider the following document of the users collection −

{
   "address": {
      "city": "Los Angeles",
      "state": "California",
      "pincode": "123"
   },
   "tags": [
      "music",
      "cricket",
      "blogs"
   ],
   "name": "Tom Benzamin"
}

The above document contains an address sub-document and a tags array.

Indexing Array Fields

Suppose we want to search user documents based on the user’s tags. For this, we will create an index on tags array in the collection.

Creating an index on array in turn creates separate index entries for each of its fields. So in our case when we create an index on tags array, separate indexes will be created for its values music, cricket and blogs.

To create an index on tags array, use the following code −

>db.users.ensureIndex({"tags":1})

After creating the index, we can search on the tags field of the collection like this −

>db.users.find({tags:"cricket"})

적절한 인덱싱이 사용되었는지 확인하려면 다음을 사용하십시오. explain 명령-

>db.users.find({tags:"cricket"}).explain()

위의 명령으로 "cursor": "BtreeCursor tags_1"이 생성되어 적절한 인덱싱이 사용되었는지 확인합니다.

하위 문서 필드 인덱싱

도시, 주 및 암호 필드를 기반으로 문서를 검색한다고 가정합니다. 이 모든 필드는 주소 하위 문서 필드의 일부이므로 하위 문서의 모든 필드에 대한 색인을 만듭니다.

하위 문서의 세 필드 모두에 대한 색인을 생성하려면 다음 코드를 사용하십시오.

>db.users.ensureIndex({"address.city":1,"address.state":1,"address.pincode":1})

색인이 생성되면 다음과 같이이 색인을 사용하여 하위 문서 필드를 검색 할 수 있습니다.

>db.users.find({"address.city":"Los Angeles"})

쿼리 식은 지정된 인덱스의 순서를 따라야합니다. 따라서 위에서 생성 된 인덱스는 다음 쿼리를 지원합니다.

>db.users.find({"address.city":"Los Angeles","address.state":"California"})

또한 다음 쿼리를 지원합니다-

>db.users.find({"address.city":"LosAngeles","address.state":"California",
   "address.pincode":"123"})

이 장에서는 인덱싱 제한 및 기타 구성 요소에 대해 알아 봅니다.

추가 간접비

모든 인덱스는 약간의 공간을 차지할뿐만 아니라 각 삽입, 업데이트 및 삭제시 오버 헤드를 유발합니다. 따라서 읽기 작업에 컬렉션을 거의 사용하지 않는 경우 인덱스를 사용하지 않는 것이 좋습니다.

RAM 사용량

인덱스는 RAM에 저장되므로 인덱스의 총 크기가 RAM 제한을 초과하지 않는지 확인해야합니다. 총 크기로 인해 RAM 크기가 증가하면 일부 인덱스가 삭제되기 시작하여 성능이 저하됩니다.

쿼리 제한

인덱싱은 다음을 사용하는 쿼리에서 사용할 수 없습니다.

  • 정규 표현식 또는 부정 연산자 $nin, $아닙니다.
  • $ mod 등과 같은 산술 연산자
  • $ where 절

따라서 항상 쿼리에 대한 인덱스 사용을 확인하는 것이 좋습니다.

인덱스 키 제한

버전 2.6부터 MongoDB는 기존 인덱스 필드의 값이 인덱스 키 제한을 초과하는 경우 인덱스를 생성하지 않습니다.

색인 키 제한을 초과하는 문서 삽입

MongoDB는이 문서의 인덱싱 된 필드 값이 인덱스 키 제한을 초과하는 경우 인덱싱 된 컬렉션에 문서를 삽입하지 않습니다. mongorestore 및 mongoimport 유틸리티도 마찬가지입니다.

최대 범위

  • 컬렉션은 64 개 이상의 인덱스를 가질 수 없습니다.
  • 인덱스 이름의 길이는 125자를 초과 할 수 없습니다.
  • 복합 색인에는 최대 31 개의 필드가 색인화 될 수 있습니다.

우리는 이전의 모든 장에서 MongoDB Object Id를 사용했습니다. 이 장에서는 ObjectId의 구조를 이해합니다.

ObjectId 다음 구조를 갖는 12 바이트 BSON 유형입니다.

  • 유닉스 시대 이후 초를 나타내는 처음 4 바이트
  • 다음 3 바이트는 컴퓨터 식별자입니다.
  • 다음 2 바이트는 다음으로 구성됩니다. process id
  • 마지막 3 바이트는 임의의 카운터 값입니다.

MongoDB는 ObjectId를 기본값으로 사용합니다. _id문서를 생성하는 동안 생성되는 각 문서의 필드입니다. ObjectId의 복잡한 조합은 모든 _id 필드를 고유하게 만듭니다.

새 ObjectId 생성

새 ObjectId를 생성하려면 다음 코드를 사용하십시오.

>newObjectId = ObjectId()

위의 문은 다음과 같이 고유하게 생성 된 ID를 반환했습니다.

ObjectId("5349b4ddd2781d08c09890f3")

MongoDB가 ObjectId를 생성하는 대신 12 바이트 ID를 제공 할 수도 있습니다.

>myObjectId = ObjectId("5349b4ddd2781d08c09890f4")

문서의 타임 스탬프 생성

_id ObjectId는 기본적으로 4 바이트 타임 스탬프를 저장하므로 대부분의 경우 문서 생성 시간을 저장할 필요가 없습니다. getTimestamp 메소드를 사용하여 문서 생성 시간을 가져올 수 있습니다.

>ObjectId("5349b4ddd2781d08c09890f4").getTimestamp()

이 문서의 생성 시간을 ISO 날짜 형식으로 반환합니다.

ISODate("2014-04-12T21:49:17Z")

ObjectId를 문자열로 변환

경우에 따라 문자열 형식의 ObjectId 값이 필요할 수 있습니다. ObjectId를 문자열로 변환하려면 다음 코드를 사용하십시오.

>newObjectId.str

위의 코드는 Guid의 문자열 형식을 반환합니다.

5349b4ddd2781d08c09890f3

MongoDB 문서에 따라 Map-reduce대량의 데이터를 유용한 집계 결과로 압축하기위한 데이터 처리 패러다임입니다. MongoDB 사용mapReduce지도 축소 작업을위한 명령. MapReduce는 일반적으로 대용량 데이터 세트를 처리하는 데 사용됩니다.

MapReduce 명령

다음은 기본 mapReduce 명령의 구문입니다.

>db.collection.mapReduce(
   function() {emit(key,value);},  //map function
   function(key,values) {return reduceFunction}, {   //reduce function
      out: collection,
      query: document,
      sort: document,
      limit: number
   }
)

map-reduce 함수는 먼저 컬렉션을 쿼리 한 다음 결과 문서를 매핑하여 키-값 쌍을 생성 한 다음 여러 값이있는 키를 기준으로 축소됩니다.

위의 구문에서-

  • map 값을 키와 매핑하고 키-값 쌍을 내보내는 자바 스크립트 함수입니다.

  • reduce 동일한 키를 가진 모든 문서를 줄이거 나 그룹화하는 자바 스크립트 함수입니다.

  • out 지도 축소 쿼리 결과의 위치를 ​​지정합니다.

  • query 문서 선택을위한 선택적 선택 기준을 지정합니다.

  • sort 선택적 정렬 기준을 지정합니다.

  • limit 반환 할 선택적 최대 문서 수를 지정합니다.

MapReduce 사용

사용자 게시물을 저장하는 다음 문서 구조를 고려하십시오. 문서는 사용자의 user_name과 게시 상태를 저장합니다.

{
   "post_text": "tutorialspoint is an awesome website for tutorials",
   "user_name": "mark",
   "status":"active"
}

이제 mapReduce 함수를 posts 컬렉션은 모든 활성 게시물을 선택하고 user_name을 기준으로 그룹화 한 다음 다음 코드를 사용하여 각 사용자의 게시물 수를 계산합니다.

>db.posts.mapReduce( 
   function() { emit(this.user_id,1); }, 
	
   function(key, values) {return Array.sum(values)}, {  
      query:{status:"active"},  
      out:"post_total" 
   }
)

위의 mapReduce 쿼리는 다음 결과를 출력합니다.

{
   "result" : "post_total",
   "timeMillis" : 9,
   "counts" : {
      "input" : 4,
      "emit" : 4,
      "reduce" : 2,
      "output" : 2
   },
   "ok" : 1,
}

결과는 총 4 개의 문서가 쿼리와 일치하고 (status : "active"), map 함수는 키-값 쌍이있는 4 개의 문서를 내보냈으며, 마지막으로 reduce 함수는 동일한 키를 가진 매핑 된 문서를 2 개로 그룹화했습니다.

이 mapReduce 쿼리의 결과를 보려면 찾기 연산자를 사용하십시오.

>db.posts.mapReduce( 
   function() { emit(this.user_id,1); }, 
   function(key, values) {return Array.sum(values)}, {  
      query:{status:"active"},  
      out:"post_total" 
   }
	
).find()

위의 쿼리는 두 사용자 모두가 tommark 활성 상태에 두 개의 게시물이 있습니다-

{ "_id" : "tom", "value" : 2 }
{ "_id" : "mark", "value" : 2 }

비슷한 방식으로 MapReduce 쿼리를 사용하여 크고 복잡한 집계 쿼리를 구성 할 수 있습니다. 사용자 정의 Javascript 함수를 사용하면 매우 유연하고 강력한 MapReduce를 사용할 수 있습니다.

버전 2.4부터 MongoDB는 문자열 콘텐츠 내부 검색을위한 텍스트 인덱스 지원을 시작했습니다. 그만큼Text Search 형태소 분석 기술을 사용하여 다음과 같은 형태소 중지 단어를 삭제하여 문자열 필드에서 지정된 단어를 찾습니다. a, an, the, 현재 MongoDB는 약 15 개의 언어를 지원합니다.

텍스트 검색 활성화

처음에는 텍스트 검색이 실험적인 기능 이었지만 버전 2.6부터는 구성이 기본적으로 활성화되어 있습니다. 그러나 이전 버전의 MongoDB를 사용하는 경우 다음 코드로 텍스트 검색을 활성화해야합니다.

>db.adminCommand({setParameter:true,textSearchEnabled:true})

텍스트 인덱스 생성

아래의 다음 문서를 고려하십시오. posts 게시물 텍스트와 태그를 포함하는 컬렉션-

{
   "post_text": "enjoy the mongodb articles on tutorialspoint",
   "tags": [
      "mongodb",
      "tutorialspoint"
   ]
}

post_text 필드에 텍스트 인덱스를 생성하여 게시물의 텍스트 내부를 검색 할 수 있습니다.

>db.posts.ensureIndex({post_text:"text"})

텍스트 인덱스 사용

이제 post_text 필드에 텍스트 인덱스를 만들었으므로 단어가 포함 된 모든 게시물을 검색합니다. tutorialspoint 그들의 텍스트에서.

>db.posts.find({$text:{$search:"tutorialspoint"}})

위의 명령은 다음과 같은 결과 문서를 반환했습니다. tutorialspoint 포스트 텍스트에서-

{ 
   "_id" : ObjectId("53493d14d852429c10000002"), 
   "post_text" : "enjoy the mongodb articles on tutorialspoint", 
   "tags" : [ "mongodb", "tutorialspoint" ]
}
{
   "_id" : ObjectId("53493d1fd852429c10000003"), 
   "post_text" : "writing tutorials on mongodb",
   "tags" : [ "mongodb", "tutorial" ] 
}

이전 버전의 MongoDB를 사용하는 경우 다음 명령을 사용해야합니다.

>db.posts.runCommand("text",{search:" tutorialspoint "})

텍스트 검색을 사용하면 일반 검색에 비해 검색 효율성이 크게 향상됩니다.

텍스트 인덱스 삭제

기존 텍스트 인덱스를 삭제하려면 먼저 다음 쿼리를 사용하여 인덱스 이름을 찾으십시오.

>db.posts.getIndexes()

위 쿼리에서 인덱스 이름을 가져온 후 다음 명령을 실행합니다. 여기,post_text_text 색인의 이름입니다.

>db.posts.dropIndex("post_text_text")

정규식은 모든 언어에서 자주 사용되어 모든 문자열에서 패턴이나 단어를 검색합니다. MongoDB는 또한 다음을 사용하여 문자열 패턴 일치를위한 정규식 기능을 제공합니다.$regex운영자. MongoDB는 PCRE (Perl 호환 정규식)를 정규식 언어로 사용합니다.

텍스트 검색과 달리 정규 표현식을 사용하기 위해 구성이나 명령을 수행 할 필요가 없습니다.

다음 문서 구조를 고려하십시오. posts 게시물 텍스트와 태그를 포함하는 컬렉션-

{
   "post_text": "enjoy the mongodb articles on tutorialspoint",
   "tags": [
      "mongodb",
      "tutorialspoint"
   ]
}

정규식 사용

다음 정규식 쿼리는 문자열이 포함 된 모든 게시물을 검색합니다. tutorialspoint 그것에서-

>db.posts.find({post_text:{$regex:"tutorialspoint"}})

동일한 쿼리를 다음과 같이 작성할 수도 있습니다.

>db.posts.find({post_text:/tutorialspoint/})

대소 문자를 구분하지 않는 정규식 사용

검색 대소 문자를 구분하지 않으려면 $options 값이있는 매개 변수 $i. 다음 명령은 단어가 포함 된 문자열을 찾습니다.tutorialspoint, 대소 문자에 관계없이 −

>db.posts.find({post_text:{$regex:"tutorialspoint",$options:"$i"}})

이 쿼리에서 반환 된 결과 중 하나는 단어가 포함 된 다음 문서입니다. tutorialspoint 다른 경우에-

{
   "_id" : ObjectId("53493d37d852429c10000004"),
   "post_text" : "hey! this is my post on TutorialsPoint", 
   "tags" : [ "tutorialspoint" ]
}

배열 요소에 정규식 사용

배열 필드에 정규식의 개념을 사용할 수도 있습니다. 이것은 태그의 기능을 구현할 때 특히 매우 중요합니다. 따라서 tutorial이라는 단어로 시작하는 태그가있는 모든 게시물 (tutorial 또는 tutorials 또는 tutorialpoint 또는 tutorialphp)을 검색하려면 다음 코드를 사용할 수 있습니다.

>db.posts.find({tags:{$regex:"tutorial"}})

정규식 쿼리 최적화

  • 문서 필드가 indexed, 쿼리는 정규식과 일치하는 색인 ​​값을 사용합니다. 따라서 전체 컬렉션을 검색하는 정규식에 비해 검색이 매우 빠릅니다.

  • 정규식이 prefix expression, 모든 일치는 특정 문자열 문자로 시작하는 것을 의미합니다. 예를 들어 정규식이 다음과 같은 경우^tut이면 쿼리는 다음으로 시작하는 문자열 만 검색해야합니다. tut.

RockMongo는 서버, 데이터베이스, 컬렉션, 문서, 인덱스 등을 관리 할 수있는 MongoDB 관리 도구입니다. 문서를 읽고, 쓰고, 작성할 수있는 매우 사용자 친화적 인 방법을 제공합니다. PHP 및 MySQL 용 PHPMyAdmin 도구와 유사합니다.

RockMongo 다운로드

여기에서 최신 버전의 RockMongo를 다운로드 할 수 있습니다. https://github.com/iwind/rockmongo

RockMongo 설치

다운로드가 완료되면 서버 루트 폴더에 패키지의 압축을 풀고 압축을 푼 폴더의 이름을 rockmongo. 웹 브라우저를 열고index.phprockmongo 폴더의 페이지. 사용자 이름 / 비밀번호로 각각 admin / admin을 입력합니다.

RockMongo 작업

이제 RockMongo로 수행 할 수있는 몇 가지 기본 작업을 살펴 ​​보겠습니다.

새 데이터베이스 생성

새 데이터베이스를 생성하려면 Databases탭. 딸깍 하는 소리Create New Database. 다음 화면에서 새 데이터베이스의 이름을 입력하고Create. 왼쪽 패널에 새 데이터베이스가 추가되는 것을 볼 수 있습니다.

새 컬렉션 만들기

데이터베이스 내에 새 컬렉션을 만들려면 왼쪽 패널에서 해당 데이터베이스를 클릭합니다. 클릭New Collection상단에 링크. 컬렉션의 필수 이름을 제공합니다. Is Capped, Size 및 Max의 다른 필드에 대해서는 걱정하지 마십시오. 클릭Create. 새 컬렉션이 생성되고 왼쪽 패널에서 볼 수 있습니다.

새 문서 생성

새 문서를 생성하려면 문서를 추가 할 컬렉션을 클릭합니다. 컬렉션을 클릭하면 거기에 나열된 해당 컬렉션 내의 모든 문서를 볼 수 있습니다. 새 문서를 만들려면Insert상단에 링크. 문서의 데이터를 JSON 또는 배열 형식으로 입력하고Save.

데이터 내보내기 / 가져 오기

컬렉션의 데이터를 가져 오거나 내보내려면 해당 컬렉션을 클릭 한 다음 Export/Import상단 패널에 링크. 다음 지침에 따라 데이터를 zip 형식으로 내 보낸 다음 동일한 zip 파일을 가져와 데이터를 다시 가져옵니다.

GridFS이미지, 오디오 파일, 비디오 파일 등과 같은 대용량 파일을 저장하고 검색하기위한 MongoDB 사양입니다. 파일을 저장하는 일종의 파일 시스템이지만 해당 데이터는 MongoDB 컬렉션 내에 저장됩니다. GridFS는 문서 크기 제한 인 16MB보다 훨씬 더 큰 파일을 저장할 수 있습니다.

GridFS는 파일을 청크로 분할하고 각 데이터 청크를 각각 최대 크기가 255k 인 별도의 문서에 저장합니다.

GridFS는 기본적으로 두 개의 컬렉션을 사용합니다. fs.filesfs.chunks파일의 메타 데이터와 청크를 저장합니다. 각 청크는 고유 한 _id ObjectId 필드로 식별됩니다. fs. 파일은 상위 문서 역할을합니다. 그만큼files_id fs.chunks 문서의 필드는 청크를 부모에 연결합니다.

다음은 fs.files 컬렉션의 샘플 문서입니다-

{
   "filename": "test.txt",
   "chunkSize": NumberInt(261120),
   "uploadDate": ISODate("2014-04-13T11:32:33.557Z"),
   "md5": "7b762939321e146569b07f72c62cca4f",
   "length": NumberInt(646)
}

문서는 파일 이름, 청크 크기, 업로드 날짜 및 길이를 지정합니다.

다음은 fs.chunks 문서의 샘플 문서입니다.

{
   "files_id": ObjectId("534a75d19f54bfec8a2fe44b"),
   "n": NumberInt(0),
   "data": "Mongo Binary Data"
}

GridFS에 파일 추가

이제 GridFS를 사용하여 mp3 파일을 저장합니다. put명령. 이를 위해 우리는mongofiles.exe MongoDB 설치 폴더의 bin 폴더에있는 유틸리티.

명령 프롬프트를 열고 MongoDB 설치 폴더의 bin 폴더에있는 mongofiles.exe로 이동하여 다음 코드를 입력하십시오.

>mongofiles.exe -d gridfs put song.mp3

여기, gridfs파일이 저장 될 데이터베이스의 이름입니다. 데이터베이스가 없으면 MongoDB는 즉시 새 문서를 자동으로 생성합니다. Song.mp3는 업로드 된 파일의 이름입니다. 데이터베이스에서 파일의 문서를 보려면 find query를 사용할 수 있습니다.

>db.fs.files.find()

위의 명령은 다음 문서를 반환했습니다.

{
   _id: ObjectId('534a811bf8b4aa4d33fdf94d'), 
   filename: "song.mp3", 
   chunkSize: 261120, 
   uploadDate: new Date(1397391643474), md5: "e4f53379c909f7bed2e9d631e15c1c41",
   length: 10401959 
}

또한 이전 쿼리에서 반환 된 문서 ID를 사용하여 다음 코드로 저장된 파일과 관련된 fs.chunks 컬렉션에있는 모든 청크를 볼 수 있습니다.

>db.fs.chunks.find({files_id:ObjectId('534a811bf8b4aa4d33fdf94d')})

필자의 경우 쿼리는 전체 mp3 문서가 40 개의 데이터 청크로 분할되었음을 의미하는 40 개의 문서를 반환했습니다.

Capped collections생성, 읽기 및 삭제 작업을위한 고성능을 지원하기 위해 삽입 순서를 따르는 고정 크기 순환 컬렉션입니다. 순환이란 모음에 할당 된 고정 크기가 소진되면 명시적인 명령을 제공하지 않고 모음에서 가장 오래된 문서를 삭제하기 시작 함을 의미합니다.

제한된 컬렉션은 업데이트로 인해 문서 크기가 증가하는 경우 문서 업데이트를 제한합니다. 제한 컬렉션은 디스크 스토리지 순서대로 문서를 저장하므로 문서 크기로 인해 디스크에 할당 된 크기가 증가하지 않습니다. 제한 컬렉션은 로그 정보, 캐시 데이터 또는 기타 대용량 데이터를 저장하는 데 가장 적합합니다.

제한된 컬렉션 만들기

제한된 컬렉션을 생성하려면 일반 createCollection 명령을 사용하지만 capped 옵션으로 true 컬렉션의 최대 크기를 바이트 단위로 지정합니다.

>db.createCollection("cappedLogCollection",{capped:true,size:10000})

컬렉션 크기 외에도 다음을 사용하여 컬렉션의 문서 수를 제한 할 수 있습니다. max 매개 변수-

>db.createCollection("cappedLogCollection",{capped:true,size:10000,max:1000})

컬렉션의 제한 여부를 확인하려면 다음을 사용하십시오. isCapped 명령-

>db.cappedLogCollection.isCapped()

capped로 변환하려는 기존 컬렉션이있는 경우 다음 코드를 사용하여 수행 할 수 있습니다.

>db.runCommand({"convertToCapped":"posts",size:10000})

이 코드는 기존 컬렉션을 변환합니다. posts 모자 컬렉션에.

제한 컬렉션 쿼리

기본적으로 제한된 컬렉션에 대한 찾기 쿼리는 삽입 순서로 결과를 표시합니다. 그러나 문서를 역순으로 검색하려면sort 다음 코드와 같이 명령-

>db.cappedLogCollection.find().sort({$natural:-1})

알 가치가있는 제한된 컬렉션과 관련하여 몇 가지 다른 중요한 사항이 있습니다.

  • 제한된 컬렉션에서 문서를 삭제할 수 없습니다.

  • 제한된 컬렉션에는 _id 필드에도 기본 인덱스가 없습니다.

  • 새 문서를 삽입하는 동안 MongoDB는 실제로 디스크에서 새 문서를 수용 할 장소를 찾을 필요가 없습니다. 컬렉션 끝에 새 문서를 맹목적으로 삽입 할 수 있습니다. 이렇게하면 제한된 컬렉션의 삽입 작업이 매우 빠릅니다.

  • 마찬가지로 문서를 읽는 동안 MongoDB는 디스크에있는 것과 동일한 순서로 문서를 반환합니다. 이것은 읽기 작업을 매우 빠르게 만듭니다.

MongoDB에는 SQL 데이터베이스와 같은 기본 자동 증가 기능이 없습니다. 기본적으로 12 바이트 ObjectId를 사용합니다._id문서를 고유하게 식별하기위한 기본 키로 필드. 그러나 _id 필드에 ObjectId가 아닌 일부 자동 증가 값을 갖기를 원하는 시나리오가있을 수 있습니다.

이것은 MongoDB의 기본 기능이 아니기 때문에 프로그래밍 방식으로 counters MongoDB 문서에서 제안한 컬렉션.

카운터 수집 사용

다음을 고려하세요 products문서. 우리는 _id 필드가auto-incremented integer sequence 1,2,3,4부터 n까지.

{
  "_id":1,
  "product_name": "Apple iPhone",
  "category": "mobiles"
}

이를 위해 counters 모든 시퀀스 필드에 대한 마지막 시퀀스 값을 추적합니다.

>db.createCollection("counters")

이제 카운터 컬렉션에 다음 문서를 삽입합니다. productid 그것의 열쇠로-

{
  "_id":"productid",
  "sequence_value": 0
}

필드 sequence_value 시퀀스의 마지막 값을 추적합니다.

카운터 컬렉션에이 시퀀스 문서를 삽입하려면 다음 코드를 사용하십시오.

>db.counters.insert({_id:"productid",sequence_value:0})

자바 스크립트 함수 생성

이제 우리는 함수를 만들 것입니다 getNextSequenceValue시퀀스 이름을 입력으로 사용하고 시퀀스 번호를 1 씩 증가시키고 업데이트 된 시퀀스 번호를 반환합니다. 우리의 경우 시퀀스 이름은productid.

>function getNextSequenceValue(sequenceName){

   var sequenceDocument = db.counters.findAndModify({
      query:{_id: sequenceName },
      update: {$inc:{sequence_value:1}},
      new:true
   });
	
   return sequenceDocument.sequence_value;
}

자바 스크립트 기능 사용

이제 새 문서를 만들고 반환 된 시퀀스 값을 문서의 _id 필드로 할당하는 동안 getNextSequenceValue 함수를 사용합니다.

다음 코드를 사용하여 두 개의 샘플 문서를 삽입하십시오-

>db.products.insert({
   "_id":getNextSequenceValue("productid"),
   "product_name":"Apple iPhone",
   "category":"mobiles"
})

>db.products.insert({
   "_id":getNextSequenceValue("productid"),
   "product_name":"Samsung S3",
   "category":"mobiles"
})

보시다시피 getNextSequenceValue 함수를 사용하여 _id 필드의 값을 설정했습니다.

기능을 확인하기 위해 find 명령을 사용하여 문서를 가져 오겠습니다.

>db.products.find()

위의 쿼리는 자동 증가 된 _id 필드가있는 다음 문서를 반환했습니다.

{ "_id" : 1, "product_name" : "Apple iPhone", "category" : "mobiles"}

{ "_id" : 2, "product_name" : "Samsung S3", "category" : "mobiles" }