Как найти значение mongodb

Выборка и фильтрация

Последнее обновление: 29.07.2022

Наиболее простой способом выборки документов из коллекции представляет использование функции find().
Действие этой функции во многом аналогично обычному запросу SELECT * FROM Table, который применяется в SQL и который извлекает все строки. Например, чтобы извлечь все
документы из коллекции users, созданной в прошлой теме, мы можем использовать команду:

db.users.find()

Фильтрация данных

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

db.users.insertOne({"name": "Tom", "age": 28, languages: ["english", "spanish"]})
db.users.insertOne({"name": "Bill", "age": 32, languages: ["english", "french"]})
db.users.insertOne({"name": "Tom", "age": 32, languages: ["english", "german"]})

Выведем все документы, в которых name=Tom:

db.users.find({name: "Tom"})

Такой запрос выведет нам два документа, в которых name=Tom.

test> db.users.find({name: "Tom"})
[
  {
    _id: ObjectId("62e2d6a5e75ce6a476c170b3"),
    name: 'Tom',
    age: 28,
    languages: [ 'english', 'spanish' ]
  },
  { _id: ObjectId("62e2d348e75ce6a476c170ae"),
    _id: ObjectId("62e2d6a5e75ce6a476c170b5"),
    name: 'Tom',
    age: 32,s: [ 'english', 'spanish' ]
    languages: [ 'english', 'german' ]
  }
]   _id: ObjectId("62e2d3d5e75ce6a476c170af"),
test>

Теперь более сложный запрос: нам надо вывести те объекты, у которых name=Tom и одновременно age=32. То есть на языке SQL это могло бы
выглядеть так: SELECT * FROM Table WHERE Name='Tom' AND Age=32. Данному критерию у нас соответствует последний добавленный
объект. Тогда мы можем написать следующий запрос:

db.users.find({name: "Tom", age: 32})

Фильтрация по отсутствующим свойствам

Какие-то документы могут иметь определенное свойство, другие могут его не иметь. Что если мы хотим получить документы, в которых отсутствует определенное
свойство? В этом случае для свойства передается значение null. Например, найдем все документы, где отсутствует свойство languages:

db.users.find({languages: null})

Или найдем все документы, где name="Tom", но свойство languages не определено.

db.users.find({name: "Tom", languages: null})

Фильтрация по элементам массива

Также несложно отыскать по элементу в массиве. Например, следующий запрос выводит все документы, у которых в массиве languages есть english:

db.users.find({languages: "english"})

Усложним запрос и получим те документы, у которых в массиве languages одновременно два языка: “english” и “german”:

db.users.find({languages: ["english", "german"]})

Причем именно в этом порядке, где “english” определен первым, а “german” – вторым.

Теперь выведем все документы, в которых “english” в массиве languages находится на первом месте:

db.users.find({"languages.0": "english"})

Обратите внимание, что "languages.0" предоставляет сложное свойство и поэтому берется в кавычки. Соответственно если нам надо вывести документы, где english на втором месте (например, ["german", "english"]),
то вместо нуля ставим единицу: "languages.1".

Рассмотрим более сложный пример, где элемент массива представляет сложный объект. Допустим, у нас в базе данных следующие документы:

db.users.insertOne({"name": "Bob", "age": 28, friends: [{"name": "Tim"}, {"name": "Tom"}]})
db.users.insertOne({"name": "Tim", "age": 29, friends: [{"name": "Bob"}, {"name": "Tom"}]})
db.users.insertOne({"name": "Sam", "age": 31, friends: [{"name": "Tom"}]})
db.users.insertOne({"name": "Tom", "age": 32, friends: [{"name": "Bob"}, {"name": "Tim"}, {"name": "Sam"}]})

Выберем все документы, где в массиве friends свойство name первого элемента равно “Bob”:

test> db.users.find({"friends.0.name": "Bob"})

Консольный вывод:

test> db.users.find({"friends.0.name": "Bob"})
[
  {
    _id: ObjectId("62e39da1c881653067e87901"),
    name: 'Tim',
    age: 29,
    friends: [ { name: 'Bob' }, { name: 'Tom' } ]
  },
  {
    _id: ObjectId("62e39da1c881653067e87903"),
    name: 'Tom',
    age: 32,
    friends: [ { name: 'Bob' }, { name: 'Tim' }, { name: 'Sam' } ]
  }
]
test>

Проекция

Документ может иметь множество полей, но не все эти поля нам могут быть нужны и важны при запросе. И в этом случае мы можем включить
в выборку только нужные поля, использовав проекцию. Например, выведем только порцию информации, например, значения полей “age” у все документов,
в которых name=Tom:

db.users.find({name: "Tom"}, {age: 1})

Использование единицы в качестве параметра {age: 1} указывает, что запрос должен вернуть только содержание свойства age.

test> db.users.find({name: "Tom"}, {age: 1})
[
  { _id: ObjectId("62e2d6a5e75ce6a476c170b3"), age: 28 },
  { _id: ObjectId("62e2d6a5e75ce6a476c170b5"), age: 32 },
  { _id: ObjectId("62e2d799e75ce6a476c170b7"), age: 28 },
  { _id: ObjectId("62e39da1c881653067e87903"), age: 32 }
]
test>

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

db.persons.find({name: "Tom"}, {age: 0})

При этом надо учитывать, что даже если мы отметим, что мы хотим получить только поле name, поле _id также будет включено в результирующую выборку.
Поэтому, если мы не хотим видеть данное поле в выборке, то надо явным образом указать: {"_id":0}

Альтернативно вместо 1 и 0 можно использовать true и false:

db.users.find({name: "Tom"}, {age: true, _id: false})

Если мы не хотим при этом конкретизировать выборку, а хотим вывести все документы, то можно оставить первые фигурные скобки пустыми:

db.users.find({}, {age: 1, _id: 0})

Запрос к вложенным объектам

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

db.users.insertOne({"name": "Alex", "age": 28, company: {"name":"Microsoft", "country":"USA"}})

Здесь определяется вложенный объект с ключом company. И чтобы найти все документы, у которых в ключе company вложенное свойство name=microsoft,
нам надо использовать оператор точку:

db.users.find({"company.name": "Microsoft"})

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

Кроме выполнения запросов к базе данных мы можем выполнять выражения JavaScript. Например, мы можем создать какую-нибудь функцию и
применять ее:

function sqrt(n) { return n*n; }
sqrt(5)

Консольный вывод:

test> function sqrt(n) { return n*n; }
[Function: sqrt]
test> sqrt(5)
25
test>

И подобные функции и выражения JavaScript мы можем применять в запросах к БД. Например, найдем все документы, где поле age равно sqrt(5)+3:

test> db.users.find({age: sqrt(5)+3})
[
  {
    _id: ObjectId("62e2d6a5e75ce6a476c170b3"),
    name: 'Tom',
    age: 28,
    languages: [ 'english', 'spanish' ]
  },
  { _id: ObjectId("62e2d76ae75ce6a476c170b6"), name: 'Tomas', age: 28 },
  { _id: ObjectId("62e2d799e75ce6a476c170b7"), name: 'Tom', age: 28 },
  {
    _id: ObjectId("62e39da1c881653067e87900"),
    name: 'Bob',
    age: 28
  }
]
test>

Использование регулярных выражений

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

db.users.find({name:/^Bw+/i})

Примерный консольный вывод:

test> db.users.find({name:/^Bw+/i})
[
  {
    _id: ObjectId("62e2d6a5e75ce6a476c170b4"),
    name: 'Bill',
    age: 32,
    languages: [ 'english', 'french' ]
  },
  {
    _id: ObjectId("62e39da1c881653067e87900"),
    name: 'Bob',
    age: 28
  }
]
test>

Поиск одиночного документа

Если все документы извлекаются функцией find, то одиночный документ извлекается функцией findOne

Например, выберем один элемент с name="Tom":

test> db.users.findOne({name: "Tom"})
{
  _id: ObjectId("62e2d6a5e75ce6a476c170b3"),
  name: 'Tom',
  age: 28,
  languages: [ 'english', 'spanish' ]
}
test>

Курсоры

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

var cursor = db.users.find()

Курсоры инкапсулируют в себе наборы получаемых из бд объектов. Используя синтаксис языка javascript и методы курсоров, мы можем вывести полученные
документы на экран и как-то их обработать. Например:

var cursor = db.users.find()

while(cursor.hasNext()){
  obj = cursor.next();
  print(obj["name"]);
}

Курсор обладает методом hasNext, который показывает при переборе, имеется ли еще в наборе документ.
А метод next извлекает текущий документ и перемещает курсор к следующему документу в наборе. В итоге в переменной
obj оказывается документ, к полям которого мы можем получить доступ.

test> var cursor = db.users.find()

test> while(cursor.hasNext()){
...   obj = cursor.next();
...   print(obj["name"]);
... }
Tom
Bob
Sam

test>

Также для перебора документов в курсоре в качестве альтернативы мы можем использовать конструкцию итератора javascript – forEach:

var cursor = db.users.find()
cursor.forEach(function(obj){
  print(obj.name);
})

Время на прочтение
4 мин

Количество просмотров 216K

Хоть и некоторые писали относительно моего предыдущего топика MongoDB: Создание, обновление и удаление документов, что это пересказ офф. документации, я с этим не полностью согласен. Мне показалось, что информация в нём оказалось кому-то полезной, поэтому выкладываю продолжение.

Find — аналог SELECT в MySQL. Используется для выборки документов из MongoDB. Возвращает массив документов в виде коллекции, если документов нет — пустую коллекцию. Пример:

> db.users.find();

Вернёт всех пользователей из коллекции.

> db.users.find( { age: 27 } );

Вернёт всех пользователей, у которых возраст равен 27.

Можно указывать несколько параметров, например, вот так:

> db.users.find( { username: “joe”, age: 27 } );

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

> db.users.find( { }, { username: 1, email: 1 } );

В итоге получим всех пользователей только с полями «username» и «email» + поле “_id”, которое возращается всегда по умолчанию. Если поле “_id” или какое-либо другое не нужно, мы можем это указать вот так:

> db.users.find( { }, { username: 1, email: 1, _id: 0 } );

Запросы с условием

Операторы: $lt — меньше, $lte — меньше или равно, $gt — больше, $gte — больше или равно, $ne — не равно.
Примеры использования:
Получаем всех пользователей, возраст которых больше 18 и меньше 30

> db.users.find( { age: { $gte: 18, $lte: 30 } } );

Получаем всех пользователей, «username» которых не равен “joe”

> db.users.find( { username: { $ne: “joe” } } );

Допустим, у нас коллекция хранит лотерейные билеты с номерами и нам нужно найти только те, в которых есть победившие номера 390, 754, 454. В таком случае мы используем оператор $in:

> db.users.find( { numbers: { $in: [ 390, 754, 454 ] } } );

т.е. билет должен содержать один из этих номеров.
Противоположным оператору $in является $nin. Он, по аналогии, получает только те билеты, где нет, указанных выше, номеров.
Оператор $or используется при запросах, когда нужно выбрать документы по совпадению одному из значений. Например, нам нужно выбрать все билеты с номером 547 или где поле «winner» равно true:

> db.users.find( { $or: [ { tickect_number: 547 }, { winner: true } ] } );

Оператор $mod используется для выборки ключей, значения которых делятся на первый аргумент и остаток от деления получается равным второму аргументу. Звучит непонятно, вот более наглядно:

> db.users.find( { user_id: { $mod: [ 5, 1 ] } } );

Такой запрос вернёт всех пользователей, «user_id» которых равен 1, 6, 11, 16 и так далее.
Чтоб получить всех пользователей, кроме вышеуказанных можно использовать оператор $not:

> db.users.find( { user_id: { $not: { $mod: [ 5, 1 ] } } } );

Получим пользователей с «user_id» 2, 3, 4, 5, 7, 8, 9, 10, 12 и так далее.
Существует также оператор для проверки существует ли какой то ключ или нет — $exist

> db.c.find({"z" : {"$in" : [null], "$exists" : true}});

Так можно выбрать все документы коллекции, где существует ключ “z” и он равен null.

Регулярные выражения

Все мы знаем, что регулярные выражения очень мощная штука. MongoDB использует Perl-совместимые регулярные выражения.
Вот так можно найти всех пользователей с именем joe или Joe:

> db.users.find( { "name" : /^joe$/i } );

Вообщем есть где разгуляться. Есть куча сервисов для того же javascript’a, где можно писать и проверять свои регулярки.

Запросы в массивах

Допустим есть у нас коллекция food и мы туда вставляем документ с массивом фруктов

> db.food.insert( { "fruit" : [ "apple", "banana", "peach" ] } );

То вот такой запрос

> db.food.find({"fruit" : "banana"});

успешно его найдёт.
Если нужно выбрать документы больше, чем по одному элементу массива, то мы можем использовать оператор $all

> db.food.find( { fruits: { $all : [ "apple", "banana" ] } } );

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

> db.food.find( { fruits: [ "apple", "banana", "peach" ] } );

Есть у нас блог, в нём хранятся комментарии. Мы хотим получить первые 10 комментариев. На помощь нам приходит оператор $slice:

> db.blog.posts.findOne( { }, { "comments" : { "$slice" : 10 } } );

findOne — работает аналогично find, но возвращает первый совпавший документ.

Если нужно получить последние 10 комментариев пишем вот так:

> db.blog.posts.findOne( { }, { "comments" : { "$slice" : -10 } } );

Также $slice умеет получать документы из середины:

> db.blog.posts.findOne( { }, { comments : { "$slice" : [ 23, 10 ] } });

в этом случае будет пропущено 23 начальных элемента и вернутся элементы с 24 по 34, если это возможно

Команды limit, skip и sort

Для того, чтоб получить ограниченное количество документов по запросу используется команда limit:

> db.users.find().limit(3);

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

> db.users.find().skip(3);

Получаем всех пользователей, кроме первых трёх.
Для сортировки используется команда sort. Сортировка может быть по возрастанию (1) и по убыванию (- 1). Сортировка может производится по нескольким ключам в порядке их приоритета:

> db.users.find().sort( { username : 1, age : -1 } );

Все эти три команды можно использовать вместе:

> db.stock.find( { "desc" : "mp3" } ).limit(50).skip(50).sort( { "price" : -1 } );

Использование команды skip с большими значениями работает не особо быстро. Рассмотрим это на примере пагинации:

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

> var page1 = db.foo.find(criteria).limit(100)
> var page2 = db.foo.find(criteria).skip(100).limit(100)
> var page3 = db.foo.find(criteria).skip(200).limit(100)

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

> var page1 = db.foo.find().sort( {"date" : -1} ).limit(100);

Сортируем по убыванию и берём первые 100. Чтоб не делать skip мы можем получить дату последнего документа и сделать запрос уже относительно этой даты:

var page2 = db.foo.find( { "date" : { "$gt" : latest.date } } );

Так можно избежать использования команды skip для больших значений.

По сути это основные вещи относительно запросов в MongoDB. Надеюсь это кому-нибудь пригодится.

MongoDB provides a good technique that is text search. Using this technique we can find a piece of text or a specified word from the string fields. Or in other words, MongoDB allows you to perform a query operation to find the specified text from the string. In MongoDB, we can perform text search using text index and $text operator.

Text index: MongoDB proved text indexes that are used to find the specified text from the string content. Text indexes should be either a string or an array of string elements. When you perform a text search query always remember that your collection must contain a text index and a collection can only contain one text index but this single text index covers multiple fields. We can create a text index using createIndex() method. 

Syntax:

db.collectionName.createIndex( { field: “text” } )

$text Operator: You can also search text index using the $text operator. This operator is used to perform text search operations on the collection with a text index. This operator tokenized each search string with whitespace and it treats most punctuations as delimiters except – and ”. After tokenizing the search string it performs logical OR operation on the tokens. If you want to sort the resultant documents then use the $meta query operator.

Syntax:

$text:

{

     $search: <string>,

     $language: <string>,

     $caseSensitive: <boolean>,

     $diacriticSensitive: <boolean>

}

How to search text?

Using the following steps we can search text in MongoDB:

Step 1: First, we create a collection and add some documents to the collection:  

In the following example, we are working with:

Database: gfg

Collection: content

Document: The content collection contains the three documents.

Step 2: Create index:

Now we create a string index on the name and pet field with the help of the createIndex() method. So we can search text over the name and line fields:

db.content.createIndex({name:"text",line:"text"})

Step 3: Search Text:

Now we are ready to search text. For example, we are going to search all the document which contain text love.

db.content.find({$text:{$search:"love"}})  

Note: $text is a query operator that performs text searches on a collection with a text index.

One more example in which we are going to search all the document which contain dog text:

db.content.find({$text:{$search:"dog"}})

How to search phrases?

Instead of searching a single word you are also allowed to search for a phrase by wrapping the phrase in double quotes(“”). Generally, the phrase search performs OR operation in between the specified keywords. For example, the phrase is “I like Mango”, then phase search looks for all the documents that contain keywords either I, like, or Mango. And if you want to perform an exact phrase search then wrap the phase in between escaped double quotes(”).

Syntax:

For Phrase search:

db.collectionName.find({$text:{$search:”Phrase”}})

For exact phrase search:

db.collectionName.find({$text:{$search:””Phrase””}})

Examples:

In the following examples, we are working with:

Database: gfg

Collection: content

Document: The content collection contains the three documents.

• Find the phrase:

db.content.find({$text:{$search:"I love dogs"}})

Here, we search for the phrase “I love dogs”. So, in the result, we get all the documents that contain keywords I, love, or dogs.

• Find the exact phrase:

db.content.find({$text:{$search:""I love dogs""}})

Here, we search for the exact phrase by wrapping the phase in between escaped double quotes(”).i.e., “”I love dogs””. So, in the result, we only get those documents that contain the specified exact phrase.

How to exclude a term from the search?

Exclusion of term means when you perform search operation and does not want to display the document that contains the specified term, so you can exclude the term by prefixing a search keyword with the minus sign(-). Using minus sign(-) you can exclude all the documents that contain exclude term. For example, you want to display all the documents that contain the keyword “Car” but not the “Cycle” keyword so you can use the following query:

dn.collectionName.find({$text:{$search:"Car -Cycle"}})

For Example:

In the following example, we are working with:

Database: gfg

Collection: content

Document: The content collection contains the three documents.

db.content.find({$text:{$search:"dog -cow"}})

Here, we only display those documents that contain dog not cow.

Search text using aggregation pipeline

We can search text using the aggregation pipeline with the help of the $text query operator in the $match stage. But there are some restrictions for using the $text operator:

• The first stage in the pipeline must be the $match stage that contains the $text operator.
• Only once in the stage will a text operator occur.
• The expression of the text operator cannot appear in expressions of $or or $not.
• By default, the text search does not return matching documents in the order of the matched scores. If you want to sort in descending score, then use the $meta aggregation expression in the $sort stage.

Note: Text score is a score that is assigned to each document that holds the search term in the index field by the $text operator. The score reflects a document’s importance to a given text search query.

Example:

In the following example, we are working with:

Database: gfg

Collection: people

Document: The people collection contains the five documents.

• Count the number of the document in which pet value is a cat:

db.people.aggregate([{$match:{$text:{$search:"Cat"}}},
             {$group:{_id:null,total:{$sum:1}}}])

• Count the number of the document in which pet value is a dog:

db.people.aggregate([{$match:{$text:{$search:"Dog"}}},
             {$group:{_id:null,total:{$sum:1}}}])

• Return the Sorted result by using text score:

db.people.aggregate([{$match:{$text:{$search:"Dog"}}},
                     {$sort:{score:{$meta:"textScore"}}},
                     {$project:{_id:0,name:1}}])

Here, we return the result(all the documents that contain the specified text,i.e., “Dog”) in the sorted form using textScore.

Краткая шпаргалка составлена на основе развернутого «Онлайн-руководства по MongoDB», которое для более подробного изучения можно найти здесь Онлайн-руководство по MongoDB.

Для удобства использования из командной строки нужно указать PATH к папке bin в установленном каталоге mongo.

Основы

Получение статистики

Добавление данных и создание коллекций

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

когда в коллекции уже нет места, наиболее старые документы удаляются, и в конец добавляются новые данные. Когда в коллекции уже нет места, наиболее старые документы удаляются, и в конец добавляются новые данные. если все место под коллекцию заполнено (например, выделенные нами 9500 байтов), а количество документов еще не достигло максимума, в данном случае 150, то в этом случае при добавлении нового документа самый старый документ будет удаляться, а на его место будет вставляться новый документ.

Выборка из БД

Запрос к вложенным объектам

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

Использование регулярных выражений

Настройка запросов и сортировка

Оператор $slice

$slice является в некотором роде комбинацией функций limit и skip. Но в отличие от них $slice может работать с массивами.
Оператор $slice принимает два параметра. Первый параметр указывает на общее количество возвращаемых документов. Второй параметр необязательный, но если он используется, тогда первый параметр указывает на смещение относительно начала (как функция skip), а второй — на ограничение количества извлекаемых документов.

Курсоры

Результат выборки, получаемой с помощью функции find, называется курсором:

Команды группировки

Группировка и метод group

аналогично применению выражения GROUP BY в SQL

Использование метода group аналогично применению выражения GROUP BY в SQL. Метод group принимает три параметра:

• key: указывает на ключ, по которому надо проводить группировку
• initial: представляет базовое значение для сгруппированного результата
• reduce: представляет функцию, возвращающую количество элементов. Эта функция принимает в качестве аргументов два параметра: items и prev
• keyf: необязательный параметр. Используется вместо параметра key и представляет функцию, которая возвращает объект key
• cond: необязательный параметр. Представляет собой условие, которое должно возвращать true, иначе документ не примет участия в группировке. Если данный параметр неуказан, то в группировке участвуют все документы
• finalize: необязательный параметр. Представляет функцию, которая срабатывает перед тем, как будут возвращены результаты группировки.

db.users.group ({key: {name : true}, initial: {total : 0},

reduce : function (items,prev){prev.total += 1}})

• $gt (больше чем)
• $lt (меньше чем)
• $gte (больше или равно)
• $lte (меньше или равно)
• $ne, который извлекает все документы, не соответствующие некоторому условию

Обновление данных

save

В качестве параметра этот метод принимает документ.

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

Если параметр _id не указан, то документ вставляется, а параметр _id генерируется автоматически как при обычном добавлении через функцию insert:

update

Более детальную настройку при обновлении предлагает функция update. Она принимает три параметра:

• query: принимает запрос на выборку документа, который надо обновить
• objNew: представляет документ с новой информацией, который заместит старый при обновлении
• options: определяет дополнительные параметры при обновлении документов. Может принимать два аргумента: upsert иmulti.Если параметр upsert имеет значение true, что mongodb будет обновлять документ, если он найден, и создавать новый, если такого документа нет. Если же он имеет значение false, то mongodb не будет создавать новый документ, если запрос на выборку не найдет ни одного документа.

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

db.users.update({name : "Tom"}, {name: "Tom", age : 25, married : false}, {upsert: true})

Обновление отдельного поля

db.users.update({name : "Eugene", age: 29}, {$set: {age : 30}})

Указав значение multi:true, мы можем обновить все документы выборки:

db.users.update({name : "Tom"}, {$set: {name: "Tom", age : 25, married : false}}, {multi:true})

Для простого увеличения значения числового поля на определенное количество единиц применяется оператор $inc. Если документ не содержит обновляемое поле, то оно создается. Данный оператор применим только к числовым значениям.

> db.users.update({name : «Tom»}, {$inc: {salary:100}})

Удаление данных

Установка ссылок в БД

Ручная установка ссылок

Cначала добавим в коллекцию companies документ представляющий компанию:

db.companies.insert({«_id» : «microsoft», year: 1974})

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

db.users.insert({name: "Tom", age: 28, company: "microsoft"})

И теперь найдем ссылку на его компанию в коллекции companies:

user = db.users.findOne()

db.companies.findOne({_id: user.company})

Автоматическое связывание

Вначале добавим новый документ в коллекцию companies:

> apple=({«name» : «apple», «year»: 1976})
> db.companies.save(apple)

Теперь создадим новый документ для коллекции person, у которого ключ company свяжем с только что добавленным документом apple:

… далее — Команды группировки