Учебники

MongoDB — Краткое руководство

MongoDB — Обзор

MongoDB — это кроссплатформенная, ориентированная на документы база данных, которая обеспечивает высокую производительность, высокую доступность и простоту масштабирования. MongoDB работает над концепцией сбора и документа.

База данных

База данных — это физический контейнер для коллекций. Каждая база данных получает свой набор файлов в файловой системе. Один сервер MongoDB обычно имеет несколько баз данных.

Коллекция

Коллекция представляет собой группу документов MongoDB. Это эквивалент таблицы RDBMS. Коллекция существует в одной базе данных. Коллекции не применяют схему. Документы в коллекции могут иметь разные поля. Как правило, все документы в коллекции имеют аналогичное или связанное назначение.

Документ

Документ — это набор пар ключ-значение. Документы имеют динамическую схему. Динамическая схема означает, что документы в одной коллекции не обязательно должны иметь одинаковый набор полей или структуру, а общие поля в документах коллекции могут содержать данные разных типов.

В следующей таблице показана взаимосвязь терминологии СУБД с MongoDB.

RDBMS MongoDB
База данных База данных
Таблица Коллекция
Кортеж / Ряд Документ
колонка поле
Присоединение к таблице Вложенные документы
Основной ключ Первичный ключ (ключ по умолчанию _id, предоставленный самой mongodb)
Сервер базы данных и клиент
ТуздЫ / Oracle mongod
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-байтовое шестнадцатеричное число, которое обеспечивает уникальность каждого документа. Вы можете указать _id при вставке документа. Если вы не предоставите, MongoDB предоставит уникальный идентификатор для каждого документа. Эти 12 байтов, первые 4 байта для текущей метки времени, следующие 3 байта для идентификатора машины, следующие 2 байта для идентификатора процесса сервера MongoDB и оставшиеся 3 байта являются простым инкрементным ЗНАЧЕНИЕМ.

MongoDB — Преимущества

Любая реляционная база данных имеет типичный дизайн схемы, который показывает количество таблиц и взаимосвязь между этими таблицами. В то время как в MongoDB, нет понятия отношения.

Преимущества MongoDB перед RDBMS

  • Схема меньше — MongoDB — это база данных документов, в которой одна коллекция содержит разные документы. Количество полей, содержание и размер документа могут отличаться от одного документа к другому.

  • Структура одного объекта понятна.

  • Нет сложных соединений.

  • Глубокая возможность запроса. MongoDB поддерживает динамические запросы к документам, используя основанный на документе язык запросов, почти такой же мощный, как SQL.

  • Tuning.

  • Простота масштабирования — MongoDB легко масштабируется.

  • Преобразование / отображение объектов приложения в объекты базы данных не требуется.

  • Использует внутреннюю память для хранения (оконного) рабочего набора, обеспечивая более быстрый доступ к данным.

Схема меньше — MongoDB — это база данных документов, в которой одна коллекция содержит разные документы. Количество полей, содержание и размер документа могут отличаться от одного документа к другому.

Структура одного объекта понятна.

Нет сложных соединений.

Глубокая возможность запроса. MongoDB поддерживает динамические запросы к документам, используя основанный на документе язык запросов, почти такой же мощный, как SQL.

Tuning.

Простота масштабирования — MongoDB легко масштабируется.

Преобразование / отображение объектов приложения в объекты базы данных не требуется.

Использует внутреннюю память для хранения (оконного) рабочего набора, обеспечивая более быстрый доступ к данным.

Зачем использовать MongoDB?

  • Ориентированное на документы хранилище — данные хранятся в форме документов в стиле JSON.

  • Индекс по любому атрибуту

  • Репликация и высокая доступность

  • Авто-Sharding

  • Богатые запросы

  • Быстрые обновления на месте

  • Профессиональная поддержка MongoDB

Ориентированное на документы хранилище — данные хранятся в форме документов в стиле JSON.

Индекс по любому атрибуту

Репликация и высокая доступность

Авто-Sharding

Богатые запросы

Быстрые обновления на месте

Профессиональная поддержка MongoDB

Где использовать MongoDB?

  • Большие данные
  • Управление контентом и доставка
  • Мобильная и социальная инфраструктура
  • Управление данными пользователя
  • Data Hub

MongoDB — Окружающая среда

Давайте теперь посмотрим, как установить MongoDB на Windows.

Установите MongoDB на Windows

Чтобы установить MongoDB в Windows, сначала загрузите последнюю версию MongoDB с https://www.mongodb.org/downloads . Убедитесь, что вы получаете правильную версию MongoDB в зависимости от вашей версии Windows. Чтобы получить версию Windows, откройте командную строку и выполните следующую команду.

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

32-разрядные версии MongoDB поддерживают только базы данных размером менее 2 ГБ и подходят только для тестирования и оценки.

Теперь распакуйте загруженный файл на диск c: \ или в любое другое место. Убедитесь, что имя извлеченной папки — mongodb-win32-i386- [версия] или mongodb-win32-x86_64- [версия]. Здесь [версия] — версия загрузки 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 , указав путь dbpath в mongod.exe . Для того же, выполните следующие команды.

В командной строке перейдите в каталог bin, находящийся в папке установки MongoDB. Предположим, моя папка установки — 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" 

Это отобразит сообщение об ожидающих соединениях на выходе консоли, которое указывает на то, что процесс 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

Установите MongoDB в Ubuntu

Выполните следующую команду для импорта открытого ключа GPG MongoDB —

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. Это покажет имя базы данных, номер коллекции и документы в базе данных. Вывод команды показан на следующем скриншоте.

DB Stats

MongoDB — Моделирование данных

Данные в MongoDB имеют гибкие schema.documents в той же коллекции. Им не обязательно иметь один и тот же набор полей или структуру, а общие поля в документах коллекции могут содержать данные разных типов.

Некоторые соображения при разработке схемы в MongoDB

  • Создайте свою схему в соответствии с требованиями пользователя.

  • Объедините объекты в один документ, если вы будете использовать их вместе. В противном случае разделите их (но убедитесь, что нет необходимости в соединениях).

  • Дублируйте данные (но ограниченно), потому что дисковое пространство дешевое по сравнению с временем вычислений.

  • Не присоединяйся, а пиши, а не читай.

  • Оптимизируйте свою схему для наиболее частых случаев использования.

  • У сложной агрегации в схеме.

Создайте свою схему в соответствии с требованиями пользователя.

Объедините объекты в один документ, если вы будете использовать их вместе. В противном случае разделите их (но убедитесь, что нет необходимости в соединениях).

Дублируйте данные (но ограниченно), потому что дисковое пространство дешевое по сравнению с временем вычислений.

Не присоединяйся, а пиши, а не читай.

Оптимизируйте свою схему для наиболее частых случаев использования.

У сложной агрегации в схеме.

пример

Предположим, клиенту нужен дизайн базы данных для его блога / веб-сайта, и вы увидите различия между дизайном схемы RDBMS и MongoDB. Сайт имеет следующие требования.

  • Каждый пост имеет уникальный заголовок, описание и URL.
  • Каждый пост может иметь один или несколько тегов.
  • Каждый пост имеет название своего издателя и общее количество лайков.
  • В каждом сообщении есть комментарии пользователей, а также их имя, сообщение, время и лайки.
  • На каждый пост может быть ноль или более комментариев.

В схеме RDBMS проект для вышеуказанных требований будет иметь минимум три таблицы.

Разработка схемы РСУБД

Находясь в схеме 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
      }
   ]
}

Таким образом, при отображении данных в РСУБД необходимо объединить три таблицы, а в MongoDB данные будут отображаться только из одной коллекции.

MongoDB — Создать базу данных

В этой главе мы увидим, как создать базу данных в MongoDB.

Использование команды

MongoDB использовать DATABASE_NAME используется для создания базы данных. Команда создаст новую базу данных, если она не существует, в противном случае она вернет существующую базу данных.

Синтаксис

Основной синтаксис использования оператора DATABASE следующий:

use DATABASE_NAME

пример

Если вы хотите использовать базу данных с именем <mydb> , используйте оператор 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 по умолчанию база данных является тестовой. Если вы не создали базу данных, коллекции будут храниться в тестовой базе данных.

MongoDB — Удалить базу данных

В этой главе мы увидим, как удалить базу данных с помощью команды 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 — Создать коллекцию

В этой главе мы увидим, как создать коллекцию с использованием MongoDB.

Метод createCollection ()

MongoDB db.createCollection (имя, параметры) используется для создания коллекции.

Синтаксис

Основной синтаксис команды createCollection () следующий:

db.createCollection(name, options)

В команде name это имя коллекции, которая будет создана. Параметры — это документ, который используется для указания конфигурации коллекции.

параметр Тип Описание
название строка Название коллекции, которая будет создана
Опции Документ (Необязательно) Укажите параметры, касающиеся объема памяти и индексации

Параметр options является необязательным, поэтому необходимо указывать только название коллекции. Ниже приведен список опций, которые вы можете использовать —

поле Тип Описание
ограничен логический (Необязательно) Если установлено значение true, включает ограниченную коллекцию. Ограниченная коллекция — это коллекция фиксированного размера, которая автоматически перезаписывает свои самые старые записи, когда достигает максимального размера. Если вы указываете true, вам также нужно указать параметр размера.
autoIndexId логический (Необязательно) Если установлено значение true, автоматически создавать индекс для поля _id.s Значение по умолчанию — false.
размер число (Необязательно) Указывает максимальный размер в байтах для ограниченной коллекции. Если значение capped равно true, то вам также необходимо указать это поле.
Максимум число (Необязательно) Указывает максимально допустимое количество документов в ограниченном собрании.

При вставке документа MongoDB сначала проверяет поле размера коллекции с ограничениями, а затем проверяет поле max.

Примеры

Основной синтаксис метода createCollection () без опций следующий:

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

Вы можете проверить созданную коллекцию с помощью команды show collection .

>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 Collection

В этой главе мы увидим, как удалить коллекцию, используя 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 — Типы данных

MongoDB поддерживает много типов данных. Некоторые из них —

  • String — это наиболее часто используемый тип данных для хранения данных. Строка в MongoDB должна быть действительной в формате UTF-8.

  • Integer — этот тип используется для хранения числового значения. Целое число может быть 32-разрядным или 64-разрядным в зависимости от вашего сервера.

  • Boolean — этот тип используется для хранения логического (true / false) значения.

  • Double — этот тип используется для хранения значений с плавающей запятой.

  • Клавиши Min / Max — этот тип используется для сравнения значения с самым низким и самым высоким элементами BSON.

  • Массивы — этот тип используется для хранения массивов или списка или нескольких значений в одном ключе.

  • Отметка времени — отметка времени. Это может быть удобно для записи, когда документ был изменен или добавлен.

  • Объект — этот тип данных используется для встроенных документов.

  • Null — этот тип используется для хранения значения Null.

  • Символ — этот тип данных используется идентично строке; однако, это обычно зарезервировано для языков, которые используют определенный тип символов.

  • Дата — этот тип данных используется для хранения текущей даты или времени в формате времени UNIX. Вы можете указать собственную дату и время, создав объект Date и передав в него день, месяц, год.

  • Идентификатор объекта — этот тип данных используется для хранения идентификатора документа.

  • Двоичные данные — этот тип данных используется для хранения двоичных данных.

  • Код — этот тип данных используется для хранения кода JavaScript в документе.

  • Регулярное выражение — этот тип данных используется для хранения регулярного выражения.

String — это наиболее часто используемый тип данных для хранения данных. Строка в MongoDB должна быть действительной в формате UTF-8.

Integer — этот тип используется для хранения числового значения. Целое число может быть 32-разрядным или 64-разрядным в зависимости от вашего сервера.

Boolean — этот тип используется для хранения логического (true / false) значения.

Double — этот тип используется для хранения значений с плавающей запятой.

Клавиши Min / Max — этот тип используется для сравнения значения с самым низким и самым высоким элементами BSON.

Массивы — этот тип используется для хранения массивов или списка или нескольких значений в одном ключе.

Отметка времени — отметка времени. Это может быть удобно для записи, когда документ был изменен или добавлен.

Объект — этот тип данных используется для встроенных документов.

Null — этот тип используется для хранения значения Null.

Символ — этот тип данных используется идентично строке; однако, это обычно зарезервировано для языков, которые используют определенный тип символов.

Дата — этот тип данных используется для хранения текущей даты или времени в формате времени UNIX. Вы можете указать собственную дату и время, создав объект Date и передав в него день, месяц, год.

Идентификатор объекта — этот тип данных используется для хранения идентификатора документа.

Двоичные данные — этот тип данных используется для хранения двоичных данных.

Код — этот тип данных используется для хранения кода JavaScript в документе.

Регулярное выражение — этот тип данных используется для хранения регулярного выражения.

MongoDB — Вставить документ

В этой главе мы узнаем, как вставить документ в коллекцию MongoDB.

Метод вставки ()

Чтобы вставить данные в коллекцию MongoDB, вам необходимо использовать метод insert () или save () MongoDB.

Синтаксис

Основной синтаксис команды 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 байтов, уникальное для каждого документа в коллекции. 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, он заменит все данные документа, содержащие _id, как указано в методе save ().

MongoDB — Запрос документа

В этой главе мы узнаем, как запрашивать документ из коллекции MongoDB.

Метод find ()

Чтобы запросить данные из коллекции MongoDB, вам нужно использовать метод find () MongoDB.

Синтаксис

Основной синтаксис метода 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
равенство {<Ключ>: <значение>} db.mycol.find ({«by»: «tutorials point»}). pretty () где by = ‘tutorials point’
Меньше, чем {<Ключ>: {$ л: <значение>}} db.mycol.find ({ «любит»: {$ л: 50}}). довольно () где любит <50
Меньше чем равно {<Ключ>: {$ Г: <значение>}} db.mycol.find ({ «любит»: {$ Г: 50}}). довольно () где любит <= 50
Лучше чем {<Ключ>: {$ Gt: <значение>}} db.mycol.find ({ «любит»: {$ Gt: 50}}). довольно () где нравится> 50
Больше чем равно {<Ключ>: {$ GTE: <значение>}} db.mycol.find ({ «любит»: {$ GTE: 50}}). довольно () где любит> = 50
Не равно {<Ключ>: {$ п: <значение>}} db.mycol.find ({ «любит»: {$ п: 50}}). довольно () где любит! = 50

И в MongoDB

Синтаксис

В методе find () , если вы передаете несколько ключей, разделяя их символом ‘,’, MongoDB обрабатывает его как условие AND . Ниже приведен основной синтаксис AND

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

пример

В следующем примере будут показаны все учебные пособия, написанные «tutorials point» и имеющие название «Обзор MongoDB».

>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 ‘И title =’ MongoDB Overview » . Вы можете передать любое количество пар ключ-значение в предложении find.

ИЛИ в MongoDB

Синтаксис

Для запроса документов на основе условия ИЛИ вам нужно использовать $ или ключевое слово. Ниже приведен основной синтаксис ИЛИ

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

пример

В следующем примере будут показаны все учебные пособия, написанные «точкой обучения» или имеющие название «Обзор MongoDB».

>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» или «Учебное пособие». Эквивалентный SQL, где предложение ‘где любит> 10 AND (by =’ tutorials point ‘ИЛИ 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 — обновить документ

Методы 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» для документов с заголовком «Обзор MongoDB».

>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 — Удалить документ

В этой главе мы узнаем, как удалить документ с помощью MongoDB.

Метод удаления ()

Метод удаления () MongoDB используется для удаления документа из коллекции. Метод remove () принимает два параметра. Одним из них является критерий удаления, а вторым — флаг justOne.

  • Критерии удаления — (Необязательно) критерии удаления в соответствии с документами будут удалены.

  • justOne — (Необязательно), если установлено значение true или 1, затем удалить только один документ.

Критерии удаления — (Необязательно) критерии удаления в соответствии с документами будут удалены.

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».

>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 удалит все документы из коллекции. Это эквивалентно команде усечения SQL.

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

MongoDB — Проекция

В MongoDB проекция означает выбор только необходимых данных, а не выборку всех данных документа. Если в документе 5 полей и вам нужно показать только 3, выберите из них только 3 поля.

Метод find ()

Метод find () , описанный в MongoDB Query Document, принимает второй необязательный параметр, представляющий собой список полей, которые вы хотите получить. В 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 — лимит записей

В этой главе мы узнаем, как ограничить записи с помощью 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"}
>

Если вы не укажете аргумент number в методе limit (), он отобразит все документы из коллекции.

MongoDB Пропустить () метод

Помимо метода 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 — сортировка записей

В этой главе мы научимся сортировать записи в 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 должен сканировать каждый документ коллекции, чтобы выбрать те документы, которые соответствуют запросу. Это сканирование крайне неэффективно и требует MongoDB для обработки большого объема данных.

Индексы — это специальные структуры данных, которые хранят небольшую часть набора данных в удобной для просмотра форме. В индексе хранится значение определенного поля или набора полей, упорядоченных по значению поля, указанному в индексе.

Метод sureIndex ()

Для создания индекса вам необходимо использовать метод sureIndex () MongoDB.

Синтаксис

Основной синтаксис метода sureIndex () заключается в следующем ().

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

Здесь ключ — это имя поля, в котором вы хотите создать индекс, а 1 — для возрастания. Чтобы создать индекс в порядке убывания, вам нужно использовать -1.

пример

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

В методе sureIndex () вы можете передать несколько полей, чтобы создать индекс для нескольких полей.

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

Метод sureIndex () также принимает список опций (которые являются необязательными). Ниже приведен список —

параметр Тип Описание
фон логический Создает индекс в фоновом режиме, чтобы создание индекса не блокировало другие действия базы данных. Укажите true для построения в фоновом режиме. Значением по умолчанию является false .
уникальный логический Создает уникальный индекс, чтобы коллекция не принимала вставку документов, в которых ключ или ключи индекса соответствуют существующему значению в индексе. Укажите true, чтобы создать уникальный индекс. Значением по умолчанию является false .
название строка Название индекса. Если не указано, MongoDB генерирует имя индекса путем объединения имен индексированных полей и порядка сортировки.
dropDups логический Создает уникальный индекс для поля, которое может иметь дубликаты. MongoDB индексирует только первое вхождение ключа и удаляет все документы из коллекции, которые содержат последующие вхождения этого ключа. Укажите true, чтобы создать уникальный индекс. Значением по умолчанию является false .
редкий логический Если true, индекс ссылается только на документы с указанным полем. Эти индексы занимают меньше места, но ведут себя по-разному в некоторых ситуациях (особенно при сортировке). Значением по умолчанию является false .
expireAfterSeconds целое число Задает значение в секундах в виде TTL для управления продолжительностью хранения документов в этой коллекции MongoDB.
v индекс версии Номер версии индекса. Версия индекса по умолчанию зависит от версии MongoDB, работающей при создании индекса.
веса документ Вес представляет собой число в диапазоне от 1 до 99 999 и обозначает значимость поля относительно других проиндексированных полей с точки зрения оценки.
язык по умолчанию строка Для текстового индекса — это язык, который определяет список стоп-слов и правила для стеммера и токенизатора. Значением по умолчанию является английский .
language_override строка Для текстового индекса укажите имя поля в документе, который содержит язык для переопределения языка по умолчанию. Значением по умолчанию является язык.

MongoDB — Агрегация

Операции агрегации обрабатывают записи данных и возвращают вычисленные результаты. Операции агрегации группируют значения из нескольких документов вместе и могут выполнять различные операции над сгруппированными данными для возврата одного результата. В SQL count (*) и с group by является эквивалентом агрегации mongodb.

Метод агрегата ()

Для агрегирования в 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 эквивалентный запрос для вышеупомянутого варианта использования будет выбран by_user, count (*) из группы mycol by by_user .

В приведенном выше примере мы сгруппировали документы по полю by_user, и при каждом появлении by_user предыдущее значение суммы увеличивается. Ниже приведен список доступных выражений агрегации.

выражение Описание пример
$ сумма Суммирует определенное значение из всех документов в коллекции. db.mycol.aggregate ([{$ group: {_id: «$ by_user», num_tutorial: {$ sum: «$ likes»}}}])
$ ср Вычисляет среднее значение всех заданных значений из всех документов в коллекции. db.mycol.aggregate ([{$ group: {_id: «$ by_user», num_tutorial: {$ avg: «$ likes»}}}])
$ мин Получает минимум соответствующих значений из всех документов в коллекции. db.mycol.aggregate ([{$ group: {_id: «$ by_user», num_tutorial: {$ min: «$ likes»}}}])
$ макс Получает максимум соответствующих значений из всех документов в коллекции. db.mycol.aggregate ([{$ group: {_id: «$ by_user», num_tutorial: {$ max: «$ likes»}}}])
$ толчок Вставляет значение в массив в результирующий документ. db.mycol.aggregate ([{$ group: {_id: «$ by_user», url: {$ push: «$ url»}}}])
$ addToSet Вставляет значение в массив в результирующий документ, но не создает дубликаты. db.mycol.aggregate ([{$ group: {_id: «$ by_user», url: {$ addToSet: «$ url»}}}])
$ первый Получает первый документ из исходных документов в соответствии с группировкой. Как правило, это имеет смысл только вместе с некоторым ранее примененным этапом «$ sort». db.mycol.aggregate ([{$ group: {_id: «$ by_user», first_url: {$ first: «$ url»}}}])
$ последний Получает последний документ из исходных документов в соответствии с группировкой. Как правило, это имеет смысл только вместе с некоторым ранее примененным этапом «$ sort». db.mycol.aggregate ([{$ group: {_id: «$ by_user», last_url: {$ last: «$ url»}}}])

Концепция трубопровода

В команде UNIX конвейер оболочки означает возможность выполнить операцию для некоторого ввода и использовать вывод в качестве ввода для следующей команды и так далее. MongoDB также поддерживает ту же концепцию в структуре агрегации. Существует множество возможных этапов, и каждый из них берется как набор документов в качестве входных данных и создает результирующий набор документов (или конечный результирующий документ JSON в конце конвейера). Это может затем использоваться для следующего этапа и так далее.

Ниже приведены возможные этапы в структуре агрегации —

  • $ project — используется для выбора некоторых определенных полей из коллекции.

  • $ match — это операция фильтрации, которая может уменьшить количество документов, которые передаются в качестве входных данных для следующего этапа.

  • $ group — выполняет фактическую агрегацию, как описано выше.

  • $ sortсортирует документы.

  • $ skip — при этом можно пропустить вперед в списке документов для заданного количества документов.

  • $ limit — ограничивает количество документов для просмотра заданным числом, начиная с текущих позиций.

  • $ unwind — используется для размотки документа, использующего массивы. При использовании массива данные являются своего рода предварительно объединенными, и эта операция будет отменена для повторного получения отдельных документов. Таким образом, на этом этапе мы увеличим количество документов для следующего этапа.

$ project — используется для выбора некоторых определенных полей из коллекции.

$ match — это операция фильтрации, которая может уменьшить количество документов, которые передаются в качестве входных данных для следующего этапа.

$ group — выполняет фактическую агрегацию, как описано выше.

$ sortсортирует документы.

$ skip — при этом можно пропустить вперед в списке документов для заданного количества документов.

$ limit — ограничивает количество документов для просмотра заданным числом, начиная с текущих позиций.

$ unwind — используется для размотки документа, использующего массивы. При использовании массива данные являются своего рода предварительно объединенными, и эта операция будет отменена для повторного получения отдельных документов. Таким образом, на этом этапе мы увеличим количество документов для следующего этапа.

MongoDB — Репликация

Репликация — это процесс синхронизации данных между несколькими серверами. Репликация обеспечивает избыточность и повышает доступность данных благодаря наличию нескольких копий данных на разных серверах баз данных. Репликация защищает базу данных от потери одного сервера. Репликация также позволяет восстанавливаться после сбоя оборудования и перерывов в обслуживании. С дополнительными копиями данных вы можете выделить одну для аварийного восстановления, создания отчетов или резервного копирования.

Почему Репликация?

  • Чтобы сохранить ваши данные в безопасности
  • Высокая (24 * 7) доступность данных
  • Аварийное восстановление
  • Нет времени на обслуживание (например, резервное копирование, перестроение индекса, сжатие)
  • Масштабирование чтения (дополнительные копии для чтения)
  • Набор реплик прозрачен для приложения

Как работает репликация в MongoDB

MongoDB достигает репликации с помощью набора реплик. Набор реплик — это группа экземпляров mongod, которые содержат один и тот же набор данных. В реплике один узел является основным узлом, который получает все операции записи. Все другие экземпляры, такие как вторичные, применяют операции с первичного, чтобы у них был тот же набор данных. Набор реплик может иметь только один основной узел.

  • Набор реплик — это группа из двух или более узлов (обычно требуется минимум 3 узла).

  • В наборе реплик один узел является первичным узлом, а остальные узлы являются вторичными.

  • Все данные реплицируются с первичного на вторичный узел.

  • Во время автоматического восстановления после сбоя или обслуживания выбор устанавливается для основного и новый основной узел выбирается.

  • После восстановления отказавшего узла он снова присоединяется к набору реплик и работает как вторичный узел.

Набор реплик — это группа из двух или более узлов (обычно требуется минимум 3 узла).

В наборе реплик один узел является первичным узлом, а остальные узлы являются вторичными.

Все данные реплицируются с первичного на вторичный узел.

Во время автоматического восстановления после сбоя или обслуживания выбор устанавливается для основного и новый основной узел выбирается.

После восстановления отказавшего узла он снова присоединяется к набору реплик и работает как вторичный узел.

Показана типичная схема репликации MongoDB, в которой клиентское приложение всегда взаимодействует с первичным узлом, а первичный узел затем реплицирует данные на вторичные узлы.

Репликация MongoDB

Особенности набора реплик

  • Кластер из N узлов
  • Любой узел может быть основным
  • Все операции записи идут на основной
  • Автоматическое переключение при сбое
  • Автоматическое восстановление
  • Консенсусные выборы первичного

Установите набор реплик

В этом руководстве мы преобразуем автономный экземпляр MongoDB в набор реплик. Чтобы преобразовать в набор реплик, выполните следующие действия:

  • Завершение работы уже запущенного сервера MongoDB.

  • Запустите сервер MongoDB, указав параметр — replSet. Ниже приведен основной синтаксис —replSet —

Завершение работы уже запущенного сервера MongoDB.

Запустите сервер MongoDB, указав параметр — replSet. Ниже приведен основной синтаксис —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
  • Он запустит экземпляр mongod с именем rs0 на порту 27017.

  • Теперь запустите командную строку и подключитесь к этому экземпляру mongod.

  • В клиенте Mongo введите команду rs.initiate (), чтобы инициировать новый набор реплик.

  • Чтобы проверить конфигурацию набора реплик, введите команду rs.conf () . Чтобы проверить состояние набора реплик, введите команду rs.status () .

Он запустит экземпляр mongod с именем rs0 на порту 27017.

Теперь запустите командную строку и подключитесь к этому экземпляру mongod.

В клиенте Mongo введите команду rs.initiate (), чтобы инициировать новый набор реплик.

Чтобы проверить конфигурацию набора реплик, введите команду rs.conf () . Чтобы проверить состояние набора реплик, введите команду rs.status () .

Добавить участников в набор реплик

Чтобы добавить участников в набор реплик, запустите экземпляры mongod на нескольких компьютерах. Теперь запустите клиент Монго и введите команду rs.add () .

Синтаксис

Основной синтаксис команды rs.add () следующий:

>rs.add(HOST_NAME:PORT)

пример

Предположим, имя вашего экземпляра mongod — mongod1.net, и он работает через порт 27017 . Чтобы добавить этот экземпляр в набор реплик, введите команду rs.add () в клиенте Mongo.

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

Вы можете добавить экземпляр mongod в набор реплик только тогда, когда вы подключены к первичному узлу. Чтобы проверить, подключены ли вы к основному или нет, введите команду db.isMaster () в клиенте mongo.

MongoDB — Sharding

Sharding — это процесс хранения записей данных на нескольких машинах, и это подход MongoDB к удовлетворению требований роста данных. Поскольку размер данных увеличивается, одной машины может быть недостаточно для хранения данных или обеспечения приемлемой скорости чтения и записи. Sharding решает проблему с горизонтальным масштабированием. С помощью шардинга вы добавляете больше машин для поддержки роста данных и требований операций чтения и записи.

Почему шардинг?

  • При репликации все записи идут на главный узел
  • Запросы, чувствительные к задержке, по-прежнему отправляются мастеру
  • Один набор реплик имеет ограничение в 12 узлов
  • Память не может быть достаточно большой, когда активный набор данных большой
  • Локальный диск недостаточно большой
  • Вертикальное масштабирование слишком дорого

Шардинг в MongoDB

На следующей диаграмме показано сегментирование в MongoDB с использованием сегментированного кластера.

MongoDB Sharding

На следующей диаграмме есть три основных компонента:

  • Осколки — Осколки используются для хранения данных. Они обеспечивают высокую доступность и согласованность данных. В производственной среде каждый осколок представляет собой отдельный набор реплик.

  • Config Servers — серверы Config хранят метаданные кластера. Эти данные содержат сопоставление набора данных кластера с шардами. Маршрутизатор запросов использует эти метаданные для нацеливания операций на определенные сегменты. В производственной среде сегментированные кластеры имеют ровно 3 сервера конфигурации.

  • Query RoutersQuery Routers — это, в основном, экземпляры mongo, взаимодействующие с клиентскими приложениями и направляющие операции в соответствующий сегмент. Маршрутизатор запросов обрабатывает и направляет операции на сегменты, а затем возвращает результаты клиентам. Кластерный кластер может содержать более одного маршрутизатора запросов для разделения нагрузки клиентских запросов. Клиент отправляет запросы одному маршрутизатору запросов. Как правило, у сегментированного кластера есть много маршрутизаторов запросов.

Осколки — Осколки используются для хранения данных. Они обеспечивают высокую доступность и согласованность данных. В производственной среде каждый осколок представляет собой отдельный набор реплик.

Config Servers — серверы Config хранят метаданные кластера. Эти данные содержат сопоставление набора данных кластера с шардами. Маршрутизатор запросов использует эти метаданные для нацеливания операций на определенные сегменты. В производственной среде сегментированные кластеры имеют ровно 3 сервера конфигурации.

Query RoutersQuery Routers — это, в основном, экземпляры mongo, взаимодействующие с клиентскими приложениями и направляющие операции в соответствующий сегмент. Маршрутизатор запросов обрабатывает и направляет операции на сегменты, а затем возвращает результаты клиентам. Кластерный кластер может содержать более одного маршрутизатора запросов для разделения нагрузки клиентских запросов. Клиент отправляет запросы одному маршрутизатору запросов. Как правило, у сегментированного кластера есть много маршрутизаторов запросов.

MongoDB — Создать резервную копию

В этой главе мы увидим, как создать резервную копию в MongoDB.

Дамп данных MongoDB

Чтобы создать резервную копию базы данных в MongoDB, вы должны использовать команду mongodump . Эта команда сбросит все данные вашего сервера в каталог дампа. Есть много доступных вариантов, с помощью которых вы можете ограничить объем данных или создать резервную копию вашего удаленного сервера.

Синтаксис

Основной синтаксис команды mongodump следующий:

>mongodump

пример

Запустите свой сервер Mongod. Предполагая, что ваш сервер mongod работает на локальном хосте и порте 27017, откройте командную строку и перейдите в каталог bin вашего экземпляра mongodb и введите команду mongodump

Считайте, что коллекция mycol имеет следующие данные.

>mongodump

Команда подключится к серверу с 127.0.0.1 и портом 27017 и вернет все данные сервера в каталог / bin / dump / . Ниже приведен вывод команды —

DB Stats

Ниже приведен список доступных параметров, которые можно использовать с командой 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 — DB_NAME Эта команда создаст резервную копию только указанной коллекции указанной базы данных. mongodump —collection mycol —db test

Восстановить данные

Для восстановления данных резервной копии используется команда MongoDB mongorestore . Эта команда восстанавливает все данные из резервного каталога.

Синтаксис

Основной синтаксис команды mongorestore

>mongorestore

Ниже приведен вывод команды —

DB Stats

MongoDB — Развертывание

Когда вы готовите развертывание MongoDB, вы должны попытаться понять, как ваше приложение будет работать в производственном режиме. Хорошей идеей является разработка согласованного, повторяемого подхода к управлению средой развертывания, чтобы вы могли минимизировать любые неожиданности, когда будете работать.

Лучший подход включает в себя создание прототипа вашей установки, проведение нагрузочного тестирования, мониторинг ключевых показателей и использование этой информации для масштабирования вашей установки. Ключевой частью этого подхода является упреждающий мониторинг всей вашей системы — это поможет вам понять, как ваша производственная система будет работать до развертывания, и определить, где вам нужно будет увеличить емкость. Например, понимание потенциальных всплесков использования памяти может помочь потушить срабатывание блокировки записи до ее запуска.

Для мониторинга вашего развертывания MongoDB предоставляет некоторые из следующих команд:

mongostat

Эта команда проверяет состояние всех запущенных экземпляров mongod и возвращает счетчики операций базы данных. Эти счетчики включают вставки, запросы, обновления, удаления и курсоры. Команда также показывает, когда вы сталкиваетесь с ошибками страницы, и показывает ваш процент блокировки. Это означает, что у вас недостаточно памяти, не хватает емкости записи или есть проблемы с производительностью.

Чтобы запустить команду, запустите свой экземпляр Mongod. В другой командной строке перейдите в каталог bin вашей установки mongodb и введите mongostat .

D:\set up\mongodb\bin>mongostat

Ниже приведен вывод команды —

mongostat

mongotop

Эта команда отслеживает и сообщает активность чтения и записи экземпляра MongoDB на основе коллекции. По умолчанию mongotop возвращает информацию каждую секунду, которую вы можете изменить соответствующим образом. Вы должны убедиться, что эта операция чтения и записи соответствует вашему намерению приложения, и вы не запускаете слишком много записей в базу данных за один раз, читаете слишком часто с диска или превышаете размер рабочего набора.

Чтобы запустить команду, запустите свой экземпляр Mongod. В другой командной строке перейдите в каталог bin вашей установки mongodb и введите mongotop .

D:\set up\mongodb\bin>mongotop

Ниже приведен вывод команды —

mongotop

Чтобы команда mongotop реже возвращала информацию, укажите конкретный номер после команды mongotop.

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

Приведенный выше пример будет возвращать значения каждые 30 секунд.

Помимо инструментов MongoDB, 10gen предоставляет бесплатную хостинговую службу мониторинга MongoDB Management Service (MMS), которая предоставляет панель мониторинга и позволяет просматривать показатели всего кластера.

MongoDB — Java

В этой главе мы узнаем, как настроить драйвер JDBC MongoDB.

Монтаж

Прежде чем вы начнете использовать MongoDB в своих программах на Java, вы должны убедиться, что на компьютере установлены драйвер JDBC MongoDB и Java. Вы можете проверить учебник Java для установки Java на вашем компьютере. Теперь давайте проверим, как настроить драйвер JDBC MongoDB.

  • Вам нужно скачать банку с пути Скачать mongo.jar . Обязательно загрузите последнюю версию.

  • Вы должны включить mongo.jar в ваш путь к классам.

Вам нужно скачать банку с пути Скачать mongo.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, вам нужно использовать PHP-драйвер MongoDB. Скачать драйвер с URL Скачать PHP Driver . Обязательно загрузите последнюю версию. Теперь распакуйте архив и поместите 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 — Отношения

Отношения в MongoDB представляют, как различные документы логически связаны друг с другом. Отношения могут быть смоделированы с помощью встроенного и ссылочного подходов. Такими отношениями могут быть 1: 1, 1: N, N: 1 или N: N.

Рассмотрим случай хранения адресов для пользователей. Таким образом, один пользователь может иметь несколько адресов, что делает это отношение 1: N.

Ниже приведен пример структуры документа пользовательского документа.

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

Ниже приведен пример структуры документа адресного документа —

{
   "_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})

Обратите внимание, что в приведенном выше запросе db и users являются базой данных и коллекцией соответственно.

Недостаток заключается в том, что если размер внедренного документа слишком велик, это может повлиять на производительность чтения / записи.

Моделирование ссылочных отношений

Это подход проектирования нормализованных отношений. При таком подходе документы пользователя и адреса будут храниться отдельно, но документ пользователя будет содержать поле, которое будет ссылаться на поле идентификатора документа адреса.

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

Как показано выше, пользовательский документ содержит поле массива address_ids, которое содержит ObjectIds соответствующих адресов. Используя эти ObjectIds, мы можем запросить адресные документы и получить оттуда подробную информацию об адресе. При таком подходе нам понадобятся два запроса: первый для извлечения полей address_ids из пользовательского документа, а второй — для извлечения этих адресов из коллекции адресов .

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

MongoDB — База данных Ссылки

Как видно из предыдущей главы отношений MongoDB, для реализации нормализованной структуры базы данных в MongoDB мы используем концепцию ссылочных отношений, также называемых ручными ссылками, в которой мы вручную сохраняем идентификатор ссылочного документа внутри другого документа. Однако в тех случаях, когда документ содержит ссылки из разных коллекций, мы можем использовать MongoDB DBRefs .

DBRefs vs Руководство Ссылки

В качестве примера сценария, где мы будем использовать DBRef вместо ссылок вручную, рассмотрим базу данных, в которой мы храним различные типы адресов (домашний, офисный, почтовый и т. Д.) В разных коллекциях (address_home, address_office, address_mailing и т. Д.). Теперь, когда документ пользовательской коллекции ссылается на адрес, он также должен указать, какую коллекцию следует просматривать на основе типа адреса. В таких случаях, когда документ ссылается на документы из многих коллекций, мы должны использовать DBRef.

Использование DBRefs

В DBRefs есть три поля —

  • $ ref — это поле указывает коллекцию ссылочного документа

  • $ id — это поле указывает поле _id ссылочного документа

  • $ db — это необязательное поле и содержит имя базы данных, в которой находится ссылочный документ

$ ref — это поле указывает коллекцию ссылочного документа

$ id — это поле указывает поле _id ссылочного документа

$ db — это необязательное поле и содержит имя базы данных, в которой находится ссылочный документ

Рассмотрим пример пользовательского документа с адресом поля DBRef, как показано во фрагменте кода —

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

Поле адреса DBRef здесь указывает, что указанный адресный документ находится в коллекции address_home базы данных tutorialspoint и имеет идентификатор 534009e4d852427820000002.

Следующий код динамически ищет в коллекции, указанной параметром $ ref (в нашем случае address_home ), документ с идентификатором, указанным параметром $ id в DBRef.

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

Приведенный выше код возвращает следующий адресный документ, присутствующий в коллекции address_home

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

MongoDB — покрытые запросы

В этой главе мы узнаем о покрытых запросах.

Что такое закрытый запрос?

Согласно официальной документации MongoDB, покрытый запрос — это запрос, в котором:

  • Все поля в запросе являются частью индекса.
  • Все поля, возвращаемые в запросе, имеют одинаковый индекс.

Поскольку все поля, присутствующие в запросе, являются частью индекса, MongoDB сопоставляет условия запроса и возвращает результат, используя тот же индекс, фактически не заглядывая в документы. Поскольку индексы присутствуют в оперативной памяти, выборка данных из индексов происходит намного быстрее, чем выборка данных путем сканирования документов.

Использование покрытых запросов

Чтобы проверить покрытые запросы, рассмотрите следующий документ в коллекции пользователей

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

Сначала мы создадим составной индекс для коллекции пользователей по полам пола и имени пользователя, используя следующий запрос —

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

Теперь этот индекс будет охватывать следующий запрос —

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

То есть, для вышеупомянутого запроса MongoDB не будет искать документы базы данных. Вместо этого он будет извлекать необходимые данные из проиндексированных данных, что очень быстро.

Поскольку наш индекс не включает поле _id , мы явно исключили его из набора результатов нашего запроса, так как MongoDB по умолчанию возвращает поле _id в каждом запросе. Таким образом, следующий запрос не был бы покрыт внутри индекса, созданного выше —

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

И наконец, помните, что индекс не может покрыть запрос, если —

  • Любое из проиндексированных полей является массивом
  • Любое из проиндексированных полей является вложенным документом

MongoDB — Анализ запросов

Анализ запросов является очень важным аспектом измерения эффективности базы данных и дизайна индексации. Мы узнаем о часто используемых запросах $ объяснение и $ подсказка .

Используя $ объяснение

Оператор $ объяснение предоставляет информацию о запросе, индексах, используемых в запросе, и другую статистику. Это очень полезно при анализе того, насколько хорошо оптимизированы ваши индексы.

В предыдущей главе мы уже создали индекс для коллекции пользователей по полам пола и имени пользователя, используя следующий запрос:

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

Теперь мы будем использовать $ объяснение по следующему запросу —

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

Приведенный выше запрос объяснения () возвращает следующий проанализированный результат —

{
   "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
            }
         ]
      ]
   }
}

Теперь мы рассмотрим поля в этом наборе результатов —

  • Истинное значение indexOnly указывает, что этот запрос использовал индексацию.

  • Поле курсора указывает тип используемого курсора. Тип BTreeCursor указывает, что индекс использовался, а также дает имя используемого индекса. BasicCursor указывает, что полное сканирование было выполнено без использования каких-либо индексов.

  • n указывает количество возвращенных документов.

  • nscannedObjects указывает общее количество отсканированных документов.

  • nscanned указывает общее количество сканированных документов или записей индекса.

Истинное значение indexOnly указывает, что этот запрос использовал индексацию.

Поле курсора указывает тип используемого курсора. Тип BTreeCursor указывает, что индекс использовался, а также дает имя используемого индекса. BasicCursor указывает, что полное сканирование было выполнено без использования каких-либо индексов.

n указывает количество возвращенных документов.

nscannedObjects указывает общее количество отсканированных документов.

nscanned указывает общее количество сканированных документов или записей индекса.

Использование $ hint

Оператор $ hint заставляет оптимизатор запросов использовать указанный индекс для выполнения запроса. Это особенно полезно, когда вы хотите проверить производительность запроса с разными индексами. Например, следующий запрос указывает индекс для полей пол и имя_пользователя, которые будут использоваться для этого запроса —

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

Чтобы проанализировать вышеуказанный запрос с помощью $ объясните —

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

MongoDB — Атомные Операции

MongoDB не поддерживает атомарные транзакции с несколькими документами . Тем не менее, он обеспечивает атомарные операции над одним документом. Таким образом, если документ имеет сто полей, оператор update либо обновит все поля, либо ни одного, следовательно, сохраняя атомарность на уровне документа.

Данные модели для атомарных операций

Рекомендуемый подход к сохранению атомарности заключается в хранении всей связанной информации, которая часто обновляется вместе в одном документе с использованием встроенных документов . Это позволит убедиться, что все обновления для одного документа являются атомарными.

Рассмотрим следующий документ о продуктах —

{
   "_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"
      }
   ]
}

В этом документе мы включили информацию о клиенте, который покупает продукт, в поле product_bought_by . Теперь, когда новый клиент покупает продукт, мы сначала проверяем, доступен ли продукт, используя поле product_available . Если доступно, мы уменьшим значение поля product_available, а также вставим встроенный документ нового клиента в поле product_bought_by. Мы будем использовать команду findAndModify для этой функциональности, потому что она ищет и обновляет документ одновременно.

>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"}} 
   }    
})

Наш подход к встроенному документу и использованию запроса findAndModify гарантирует, что информация о покупке продукта обновляется только в том случае, если продукт доступен. И вся эта транзакция, находящаяся в одном запросе, является атомарной.

В отличие от этого рассмотрим сценарий, в котором мы могли бы отдельно хранить информацию о доступности продукта и информацию о том, кто его купил. В этом случае мы сначала проверим, доступен ли продукт, используя первый запрос. Затем во втором запросе мы обновим информацию о покупке. Однако, возможно, что между выполнением этих двух запросов какой-то другой пользователь приобрел продукт, и он больше не доступен. Не зная этого, наш второй запрос обновит информацию о покупке на основе результата нашего первого запроса. Это сделает базу данных несовместимой, потому что мы продали продукт, который недоступен.

MongoDB — Расширенное индексирование

Рассмотрим следующий документ из коллекции пользователей

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

Приведенный выше документ содержит адресный поддокумент и массив тегов .

Индексирование полей массива

Предположим, мы хотим искать пользовательские документы на основе тегов пользователя. Для этого мы создадим индекс по массиву тегов в коллекции.

Создание индекса для массива, в свою очередь, создает отдельные записи индекса для каждого из его полей. Так что в нашем случае, когда мы создадим индекс по массиву тегов, будут созданы отдельные индексы для его значений музыка, крикет и блоги.

Чтобы создать индекс по массиву тегов, используйте следующий код —

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

После создания индекса мы можем искать в поле тегов коллекции следующим образом:

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

Чтобы убедиться, что используется правильное индексирование, используйте следующую команду объяснения

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

Приведенная выше команда привела к появлению «курсора»: «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"})

MongoDB — Ограничения индексации

В этой главе мы узнаем об ограничениях индексирования и других его компонентах.

Дополнительные накладные расходы

Каждый индекс занимает некоторое пространство, а также вызывает накладные расходы на каждую вставку, обновление и удаление. Поэтому, если вы редко используете свою коллекцию для операций чтения, имеет смысл не использовать индексы.

Использование ОЗУ

Поскольку индексы хранятся в ОЗУ, следует убедиться, что общий размер индекса не превышает лимит ОЗУ. Если общий размер увеличивает размер ОЗУ, он начнет удалять некоторые индексы, что приведет к снижению производительности.

Ограничения запроса

Индексирование нельзя использовать в запросах, которые используют —

  • Регулярные выражения или операторы отрицания, такие как $ nin, $ not и т. Д.
  • Арифметические операторы, такие как $ mod и т. Д.
  • пункт $ где

Следовательно, всегда желательно проверять использование индекса для ваших запросов.

Пределы индекса ключа

Начиная с версии 2.6, MongoDB не будет создавать индекс, если значение существующего поля индекса превышает ограничение ключа индекса.

Вставка документов, превышающих предел индекса ключа

MongoDB не будет вставлять какие-либо документы в индексированную коллекцию, если значение индексированного поля этого документа превышает ограничение ключа индекса. То же самое в случае с mongorestore и mongoimport.

Максимальные диапазоны

  • Коллекция не может иметь более 64 индексов.
  • Длина имени индекса не может превышать 125 символов.
  • Составной индекс может содержать максимум 31 поле.

MongoDB — ObjectId

Мы использовали идентификатор объекта MongoDB во всех предыдущих главах. В этой главе мы поймем структуру ObjectId.

ObjectId — это 12-байтовый тип BSON, имеющий следующую структуру:

  • Первые 4 байта, представляющие секунды с эпохи Unix
  • Следующие 3 байта являются идентификатором машины
  • Следующие 2 байта состоят из идентификатора процесса
  • Последние 3 байта являются случайным значением счетчика

MongoDB использует ObjectIds в качестве значения по умолчанию поля _id каждого документа, которое генерируется при создании любого документа. Сложная комбинация ObjectId делает все поля _id уникальными.

Создание нового ObjectId

Для создания нового ObjectId используйте следующий код —

>newObjectId = ObjectId()

Вышеуказанный оператор вернул следующий уникально сгенерированный идентификатор —

ObjectId("5349b4ddd2781d08c09890f3")

Вместо MongoDB, генерирующего ObjectId, вы также можете предоставить 12-байтовый идентификатор —

>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 — Карта Уменьшить

Согласно документации MongoDB, Map-Reduction — это парадигма обработки данных для объединения больших объемов данных в полезные агрегированные результаты. 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 — это функция JavaScript, которая отображает значение с ключом и испускает пару ключ-значение

  • Reduce — это функция JavaScript, которая уменьшает или группирует все документы, имеющие одинаковый ключ.

  • out указывает местоположение результата запроса на уменьшение карты

  • В запросе указываются необязательные критерии выбора для выбора документов.

  • sort определяет необязательные критерии сортировки

  • Лимит определяет необязательное максимальное количество документов, которые будут возвращены

map — это функция JavaScript, которая отображает значение с ключом и испускает пару ключ-значение

Reduce — это функция JavaScript, которая уменьшает или группирует все документы, имеющие одинаковый ключ.

out указывает местоположение результата запроса на уменьшение карты

В запросе указываются необязательные критерии выбора для выбора документов.

sort определяет необязательные критерии сортировки

Лимит определяет необязательное максимальное количество документов, которые будут возвращены

Использование MapReduce

Рассмотрим следующую структуру документа, в которой хранятся сообщения пользователей. Документ хранит user_name пользователя и статус поста.

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

Теперь мы будем использовать функцию mapReduce в нашей коллекции постов, чтобы выбрать все активные посты, сгруппировать их по имени пользователя и затем подсчитать количество постов каждого пользователя, используя следующий код —

>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 документа соответствовали запросу (статус: «активный»), функция карты выдавала 4 документа с парами ключ-значение и, наконец, функция уменьшения сгруппировала сопоставленные документы с одинаковыми ключами в 2.

Чтобы увидеть результат этого запроса mapReduce, используйте оператор find —

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

Приведенный выше запрос дает следующий результат, который указывает на то, что оба пользователя tom и mark имеют два сообщения в активных состояниях —

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

Аналогичным образом запросы MapReduce можно использовать для построения больших сложных запросов агрегации. Использование пользовательских функций Javascript делает использование MapReduce очень гибким и мощным.

MongoDB — текстовый поиск

Начиная с версии 2.4, MongoDB начал поддерживать текстовые индексы для поиска внутри строкового содержимого. В текстовом поиске используются методы определения основ для поиска указанных слов в строковых полях путем удаления таких слов, как a, an, the и т. Д. В настоящее время MongoDB поддерживает около 15 языков.

Включение текстового поиска

Первоначально текстовый поиск был экспериментальной функцией, но, начиная с версии 2.6, конфигурация включена по умолчанию. Но если вы используете предыдущую версию MongoDB, вы должны включить текстовый поиск с помощью следующего кода —

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

Создание текстового указателя

Рассмотрим следующий документ под коллекцией сообщений, содержащий текст сообщения и его теги:

{
   "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 — регулярное выражение

Регулярные выражения часто используются на всех языках для поиска шаблона или слова в любой строке. MongoDB также обеспечивает функциональность регулярных выражений для сопоставления строковых шаблонов с использованием оператора $ regex . MongoDB использует PCRE (Perl-совместимое регулярное выражение) в качестве языка регулярных выражений.

В отличие от текстового поиска, нам не нужно выполнять какие-либо настройки или команды для использования регулярных выражений.

Рассмотрим следующую структуру документа в коллекции сообщений, содержащей текст сообщения и его теги:

{
   "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, или tutorial, или tutorialpoint, или tutorialphp), вы можете использовать следующий код:

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

Оптимизация запросов регулярных выражений

  • Если поля документа проиндексированы , запрос будет использовать make с использованием индексированных значений, чтобы соответствовать регулярному выражению. Это делает поиск очень быстрым по сравнению с регулярным выражением, сканирующим всю коллекцию.

  • Если регулярное выражение является префиксным выражением , все совпадения должны начинаться с определенных строковых символов. Например, если выражение регулярного выражения равно ^ tut , запрос должен искать только те строки, которые начинаются с tut .

Если поля документа проиндексированы , запрос будет использовать make с использованием индексированных значений, чтобы соответствовать регулярному выражению. Это делает поиск очень быстрым по сравнению с регулярным выражением, сканирующим всю коллекцию.

Если регулярное выражение является префиксным выражением , все совпадения должны начинаться с определенных строковых символов. Например, если выражение регулярного выражения равно ^ tut , запрос должен искать только те строки, которые начинаются с tut .

Работа с RockMongo

RockMongo — это инструмент администрирования MongoDB, с помощью которого вы можете управлять своим сервером, базами данных, коллекциями, документами, индексами и многим другим. Он обеспечивает очень удобный способ чтения, записи и создания документов. Это похоже на инструмент PHPMyAdmin для PHP и MySQL.

Загрузка RockMongo

Вы можете скачать последнюю версию RockMongo здесь: https://github.com/iwind/rockmongo

Установка RockMongo

После загрузки вы можете разархивировать пакет в корневой папке вашего сервера и переименовать извлеченную папку в rockmongo . Откройте любой веб-браузер и зайдите на страницу index.php из папки rockmongo. Введите admin / admin как имя пользователя / пароль соответственно.

Работа с RockMongo

Теперь мы рассмотрим некоторые основные операции, которые вы можете выполнять с RockMongo.

Создание новой базы данных

Чтобы создать новую базу данных, нажмите вкладку Базы данных . Нажмите Создать новую базу данных . На следующем экране введите имя новой базы данных и нажмите « Создать» . Вы увидите добавление новой базы данных на левой панели.

Создание новой коллекции

Чтобы создать новую коллекцию в базе данных, щелкните по этой базе данных на левой панели. Нажмите на ссылку Новая коллекция вверху. Укажите требуемое название коллекции. Не беспокойтесь о других полях Is Capped, Size и Max. Нажмите на Создать . Новая коллекция будет создана, и вы сможете увидеть ее на левой панели.

Создание нового документа

Чтобы создать новый документ, щелкните коллекцию, в которую вы хотите добавить документы. Когда вы нажмете на коллекцию, вы сможете увидеть все документы в этой коллекции, перечисленные там. Чтобы создать новый документ, нажмите на ссылку Вставить вверху. Вы можете ввести данные документа в формате JSON или массива и нажать « Сохранить» .

Экспорт / Импорт данных

Чтобы импортировать / экспортировать данные любой коллекции, щелкните эту коллекцию, а затем нажмите ссылку « Экспорт / импорт» на верхней панели. Следуйте следующим инструкциям, чтобы экспортировать данные в формате zip, а затем импортировать тот же zip-файл для импорта обратно данных.

MongoDB — GridFS

GridFS — это спецификация MongoDB для хранения и извлечения больших файлов, таких как изображения, аудиофайлы, видеофайлы и т. Д. Это своего рода файловая система для хранения файлов, но ее данные хранятся в коллекциях MongoDB. GridFS имеет возможность хранить файлы даже больше, чем его ограничение размера документа 16 МБ.

GridFS делит файл на куски и сохраняет каждый кусок данных в отдельном документе, каждый из которых имеет максимальный размер 255 КБ.

GridFS по умолчанию использует две коллекции fs.files и fs.chunks для хранения метаданных файла и фрагментов. Каждый блок идентифицируется уникальным полем _id ObjectId. Файл fs.files является родительским документом. Поле 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

Теперь мы будем хранить mp3-файл, используя GridFS, используя команду put . Для этого мы будем использовать утилиту mongofiles.exe, которая находится в папке bin установочной папки MongoDB.

Откройте командную строку, перейдите к файлу mongofiles.exe в папке bin установочной папки MongoDB и введите следующий код —

>mongofiles.exe -d gridfs put song.mp3

Здесь gridfs — это имя базы данных, в которой будет храниться файл. Если база данных отсутствует, MongoDB автоматически создаст новый документ на лету. Song.mp3 — это имя загруженного файла. Чтобы просмотреть документ файла в базе данных, вы можете воспользоваться поиском запроса —

>db.fs.files.find()

Приведенная выше команда вернула следующий документ —

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

Мы также можем увидеть все фрагменты, присутствующие в коллекции fs.chunks, связанные с сохраненным файлом, со следующим кодом, используя идентификатор документа, возвращенный в предыдущем запросе:

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

В моем случае запрос вернул 40 документов, а это означает, что весь mp3-документ был разделен на 40 блоков данных.

MongoDB — ограниченные коллекции

Закрытые коллекции — это круглые коллекции фиксированного размера, которые следуют порядку вставки для поддержки высокой производительности операций создания, чтения и удаления. По кругу это означает, что, когда фиксированный размер, выделенный для коллекции, исчерпан, он начнет удалять самый старый документ в коллекции без предоставления каких-либо явных команд.

Ограниченные коллекции ограничивают обновления документов, если обновление приводит к увеличению размера документа. Поскольку закрытые коллекции хранят документы в порядке хранения на диске, это гарантирует, что размер документа не увеличит размер, выделенный на диске. Ограниченные коллекции лучше всего подходят для хранения информации журнала, данных кэша или любых других больших объемов данных.

Создание закрытой коллекции

Чтобы создать ограниченную коллекцию, мы используем обычную команду createCollection, но с параметром capped в качестве true и указанием максимального размера коллекции в байтах.

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

Помимо размера коллекции, мы также можем ограничить количество документов в коллекции, используя параметр max

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

Если вы хотите проверить, является ли коллекция ограниченной или нет, используйте следующую команду isCapped

>db.cappedLogCollection.isCapped()

Если существует существующая коллекция, которую вы планируете преобразовать в ограниченную, вы можете сделать это с помощью следующего кода:

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

Этот код преобразовал бы наши существующие сообщения коллекции в ограниченную коллекцию.

Запрашивая ограниченную коллекцию

По умолчанию поисковый запрос для ограниченной коллекции будет отображать результаты в порядке вставки. Но если вы хотите, чтобы документы были получены в обратном порядке, используйте команду сортировки, как показано в следующем коде —

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

Есть несколько других важных моментов, касающихся ограниченных коллекций, которые стоит знать.

  • Мы не можем удалить документы из закрытой коллекции.

  • В закрытой коллекции нет индексов по умолчанию, даже в поле _id.

  • При вставке нового документа MongoDB не нужно на самом деле искать место для размещения нового документа на диске. Он может вслепую вставить новый документ в хвост коллекции. Это делает операции вставки в ограниченные коллекции очень быстрыми.

  • Аналогично, при чтении документов MongoDB возвращает документы в том же порядке, что и на диске. Это делает операцию чтения очень быстрой.

Мы не можем удалить документы из закрытой коллекции.

В закрытой коллекции нет индексов по умолчанию, даже в поле _id.

При вставке нового документа MongoDB не нужно на самом деле искать место для размещения нового документа на диске. Он может вслепую вставить новый документ в хвост коллекции. Это делает операции вставки в ограниченные коллекции очень быстрыми.

Аналогично, при чтении документов MongoDB возвращает документы в том же порядке, что и на диске. Это делает операцию чтения очень быстрой.

MongoDB — Автоинкрементная последовательность

MongoDB не имеет встроенной функции автоинкремента, как базы данных SQL. По умолчанию он использует 12-байтовый ObjectId для поля _id в качестве первичного ключа для уникальной идентификации документов. Однако могут быть сценарии, в которых мы можем захотеть, чтобы поле _id имело какое-то автоматически увеличиваемое значение, кроме ObjectId.

Поскольку это не функция по умолчанию в MongoDB, мы программно достигнем этой функциональности, используя коллекцию счетчиков, как предложено в документации MongoDB.

Использование коллекции счетчиков

Рассмотрим следующий документ по продуктам . Мы хотим, чтобы поле _id было целочисленной последовательностью с автоинкрементом, начиная с 1,2,3,4 до n.

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

Для этого создайте коллекцию счетчиков , которая будет отслеживать последнее значение последовательности для всех полей последовательности.

>db.createCollection("counters")

Теперь мы вставим следующий документ в коллекцию счетчиков с ключом productid

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

Поле sequence_value отслеживает последнее значение последовательности.

Используйте следующий код для вставки этого документа последовательности в коллекцию счетчиков —

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

Создание функции Javascript

Теперь мы создадим функцию 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;
}

Использование функции Javascript

Теперь мы будем использовать функцию getNextSequenceValue при создании нового документа и назначении возвращенного значения последовательности в качестве поля _id документа.

Вставьте два образца документа, используя следующий код —

>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 —