Shulou(Shulou.com)05/31 Report--

How do I use the Shell command in MongoDB? In view of this problem, this article introduces the corresponding analysis and answers in detail, hoping to help more partners who want to solve this problem to find a more simple and feasible way.

-Database content-

View all databases

Show dbs

Delete database

Db.dropDatebase ()

-Collection content-

Create a collection

Db.createCollection ()

View all collections\ tables

Show collectionsshow tables

Select a collection

Use db_name

View information about the collection

Db.stats ()

Delete a collection, but you need to specify a database first, that is, execute use db_name first

Db.dropDatabase ()

Modify the name of the collection

Db.collection_name.renameCollection ('new_name')

-- document content--

Insert data

Db.collection_name.insert (document) db.collection_name.save (document)

Query data multiple pieces of data

Db.collection_name.find ()

1. You can specify what is returned.

Parameter interpretation

Db.collection_name.find ({query_term:value}, return_key_name:1})

The first parameter of a find () function is the query condition, that is, all documents that match the content will be filtered out. If there is no query condition, enter {}, which cannot be empty.

The second parameter of the b find () function is to specify the returned content. For example, a xiaoming document in a collection of student contains multiple items, such as name, student number, home address, and so on. Now I only want to see the name. When I do not want to query, I can return all the contents of the xiaoming document, so I can use the form of 'key name: 1'. The following 1 indicates that the content is filtered out and output in positive order. 0 means the rest of the content is filtered out, and-1 means the result is the same as 1 in reverse order.

C can return multiple records. This is just an example, or take the example of ixaoming.

{'name':1,'student_id':1}

This returns two messages, one name and one student_id

2. Query nested information

Understand the following information with a two-dimensional array

{'name':'yang','sex':'man','skill': [{' php':1}, {'mongodb':4}, {' redis':5}], 'favorite_food':'meat'}

If you use skill as the query condition of find (), don't write it like this.

-error examples-

Db.self.find ({'skill': [{' php':1}]})

This cannot be found, because mongodb will parse {'skill': [{' php':1}]} into a record containing only 'php':1' under the skill array. The above example obviously does not meet this requirement, so the query cannot be found.

-the right example

Db.self.find ({'skill.php':1})

It is used here. Tell the mongodb database to match the contents of php 1 under the skill array, focusing on whether there is a record of 'php':1' under skill.

-correct example 2 Muhami-

If you must use the error example above to query the data, you can use the $elemMatch parameter and pay attention to where it is used

Db.self.find ({'skill': {$elemMatch: {' php':1})

The $elemMatch here is used as a conditional operator

Query single piece of data

Db.collection_name.findOne ()

Skip skips the initial number of queries, limit, limits the number of returns, sort, when XRV 1 indicates positive order, XRV Mel 1 indicates reverse order

Db.collection_name.find () .skip (Number) .limit (Number) .sort ({x Number 1})

Calculate the number of documents that meet the query criteria

Db.collection_name.find () .count ()

The count () function ignores the skip () or limit () functions by default. For example, if there are four documents in the student collection, the following three statements will show different results.

Db.student.find (). Limit (1). Count () results in 4 and ignores the condition of limit (1)

Db.student.find () .limit (1) .count (true) result is 1, passing the parameter true for count ()

Get the unique value of the result

Db.collection_name.distinct ('key_name')

It is also a function of query, except that compared to find (), it will display the unique value of the query result, rather than based on the number of documents in the original collection, combined with the distinct in the relational database, to understand, for example, there is a collection of books-- books, under which there is information about the title, author, publication date and so on. Note that an author may have written a lot of books. Now I want to see how many authors there are in this collection, if I search directly using the find () function above

Db.books.find ({}, {'writer':1})

This lists all the authors, but many are duplicated because find () returns the results based on the number of documents, while distinct () filters the results

The repetitive part of it

Db.books.distinct ('writer')

Group query results

Db.collection_name.group ()

Parameter 1 key is grouped according to this key

Parameter 2 initial sets the variable, which will be in the final output. Note that this variable is defined for each group, and a new group is recreated as soon as it starts.

Parameter 3 reduce a function that is executed during document grouping, that is, once a document is grouped, two parameters are passed in, one is the parameter representing initial, and the other is the document currently grouped. For ease of understanding, it is named out and doc respectively.

Parameter 4 keyf, optional, works the same as key, but you can specify a function to create a field that does not originally exist in the document as a basis for grouping. You need to pass in a parameter of the current document.

Parameter 5 cond filter condition, only documents that meet this condition can participate in grouping

Parameter 6 finalize is the function executed after the grouping is completed, passing in the parameter representing initial

Let's take a look at an example to get a general idea. First pass a few documents into the orders collection.

Data1= {"_ id": ObjectId ("552a330e05c27486b9b9b650"), "_ class": "com.mongo.model.Orders", "onumber": "002", "date": ISODate ("2014-01-03T16:03:00Z"), "cname": "zcy", "item": {"quantity": 1, "price": 4.0 "pnumber": "p002"}} data2= {"_ id": ObjectId ("552a331d05c275d8590a550d"), "_ class": "com.mongo.model.Orders", "onumber": "003", "date": ISODate ("2014-01-04T16:03:00Z"), "cname": "zcy", "item": {"quantity": 10, "price": 2.0 "pnumber": "P001"} data3= {"_ id": ObjectId ("552a333105c2f28194045a72"), "_ class": "com.mongo.model.Orders", "onumber": "003", "date": ISODate ("2014-01-04T16:03:00Z"), "cname": "zcy", "item": {"quantity": 30, "price": 4.0 "pnumber": "p002"}} data4= {"_ id": ObjectId ("552a333f05c2b62c01cff50e"), "_ class": "com.mongo.model.Orders", "onumber": "004"," date ": ISODate (" 2014-01-05T16:03:00Z ")," cname ":" zcy "," item ": {" quantity ": 5," price ": 4.0 "pnumber": "p002"} db.orders.insert (data1) db.orders.insert (data2) db.orders.insert (data3) db.orders.insert (data4)

Next, show the group () function.

Example 1

Db.orders.group ({key: {data:1,'item.pnumber':1}, initial: {'total':0}, reduce:function (doc,out) {out.total+=doc.item.quantity}})

The first is grouped according to the pnumber in the data and ietm arrays

Then the output variable total is defined to record the total number of each product.

The next step is to define the processing function, that is, the function in reduce. Note the order in which the parameters are passed. The first parameter represents the document currently grouped, and the second parameter represents initial, so doc can directly call doc.item.quantity, that is, the content of the document, and out can call out.total, that is, the content of initial.

Example 2

Db.orders.group ({keyf:function (doc) {return {'month':doc.date.getMonth () + 1};}, initial: {' total':0,'money':0}, reduce:function (doc,out) {out.total+=doc.item.quantity*doc.item.price}, finalize:function (out) {out.avg=out.money/out.total;return out;}})

First, this example shows the use of keyf. It returns a new field, month, and then mongodb classifies it according to the calculation results of month.

Next, there are parameters passed in the functions of keyf and finalize. In fact, this parameter has nothing to do with the name of the parameter in reduce. It is written here mainly to make it easier to understand its meaning.

Finally, a variable avg is temporarily created in finalize, and this avg will also be output at the end.

Finally, the result of processing in the function will be return.

-use conditional operators to filter query results-

It is usually used inside the first parameter of find () as a filter condition.

-$gt,$lt,$get,$lte,$ne

Db.collection_name.find ({key_name: {$gt:value}})

Pay attention to the position of the operator. The example is easy to understand.

Db.student.find ({'height': {$gt:180}})

It means to screen out the students who are taller than 180 in the student collection.

You can use two operators at the same time to specify a range

Db.student.find ({'height': {$gt:180,$lt:220}})

The use of these two is the same as above, but it needs to be mentioned separately, because it is a bit special.

-$in,$nin

Db.student.find ({'height': {$in: [170180190200]}})

It means to screen out students with a height of 170180190200, and $nin means to screen students other than 170180190200.

-$all

The content in the above $in is in the form of'or'. As long as your height is 170,180,190,200, then you meet the screening criteria, while $all is and.

Db.student.find ({'height': {$all: [170180190200]}})

This means that it takes you 170, 180, 190 and 200 to meet the requirements.

-$or

Db.student.find ({$or: [{'score':100}, {' sex':man}]})

In the above example, the relationship between score:100 and sex:man is'or'. Combined with the following example, we can see the role of $or.

Db.student.find ({'score':100,'sex':'man'})

The relationship between score:100 and sex:man

Limit (x) function plus skip (y) function = $slice: [YPerry x]

Specific usage can be seen in the following example

Db.student.find ({}, {'height': {$slice: [10jue 5]}})

As the old saying goes, pay attention to the position of $slice, which means to filter people with height from 11 to 15, the first parameter is the parameter of skip (), and the second is limit ()

The limit () function limits the number of documents returned, and $size filters arrays that match the number, as shown in the following example

First add the following information to the database

Message= {'cds': [{' first_song':'hello'}, {'second_song':'world'}, {' third_song':'again'}]} db.songs.insert (message)

Next, let's check the above results.

Db.songs.find ({'cds': {$size:2}})

No result is returned because there are three sets of data in the cds array

Db.songs.find ({'cds': {$size:3}})

Return all the results. Note that this is passed in as the first parameter of the find () function, so it is a filter condition.

Filter values that contain specific fields

Db.collection_name.find ({key_name: {$exit:true}})

Return the document where the field exists. Note that the field exists here, and the specific content of the field is not specified.

Filter the returned results by data type

Db.collection_name.find ({'key_name': {$type:x}})

There are many values of x, so I won't introduce them here, because it's too much to read it once.

Use regular expressions in filtering

Db.collection_name.find ({'key_name':/ /})

Add the contents of the regular expression to / /

Update data

Db.collection_name.update ({original_key:original_value}, {new_key:new_value})

1. As long as the original collection contains original_key:original_value, it will be selected as the operation object.

2. The entire collection will be updated to new_key:new_value, not just original_key:original_value.

Instead of updating the entire collection above, the form of $set: is added below to update only some of the fields

Db.collection_name.update ({original_key:original_value}, {$set: {new_key:new_value}})

A field is updated with $set above, and a field can be deleted using $unset

Db.collection_name.update {{}, {$unset: {key:value}

If this update data does not exist, create this data, and add the third parameter to true.

Db.collection_name.update ({original_key:original_value}, {new_key:new_value}, true)

Or the following form is fine.

Db.collection_name.update ({original_key:original_value}, {new_key:new_value}, {upsert:true})

Update only updates the first record that meets the criteria, but when you want to update multiple records, set the third parameter to false, the fourth parameter to true, and also set $set

Db.collection_name.update ({original_key:original_value}, {$set {new_key:new_value}}, false,true)

-insert data-- array part--

Insert data

Db.collection_name.update ({original_key:value}, {$push: {new_key:new:value}})

Note that if original_key does not exist, it will be created and defined as an array, with new_key:value as the first value

Insert new_key:value if original_key exists and array, or error if it is not an array

Insert multiple values at once. Use $push to insert one value at a time. If you want to insert more than one value, you need to use the following

Db.collection_name.update ({original_key:value}, {$push: {new_key: {$each: ['value1','value2','value3']})

Note that the $push here operates on the array, that is, everything after $each will be added to the array of new_key.

Corresponding to $push, $pop deletes the data in the array

Db.collection_name.update ({original_key:value}, {$pop: {{original_key:1})

Note that the 1 here indicates the number of deletions, which can be an integer such as 2 and 3, indicating deletion from the back end of the array, or a negative number such as-1, indicating deletion from the front end of the array.

The previous $pop can specify the number of deletions, but cannot specify the conditions for deletion, and $pull can

Db.collection_name.update ({original_key:value}, {$pull: {key1:value1}})

Similar to $pull, $pullAll can delete multiple data

Db.collection_name.update ({original_key:value}, {$pullAll: {key1: ['value1','value2','value3']}})

AddToSet is a very useful command to add data to an array. If the data does not exist, it will not be added repeatedly.

Db.collection_name.update ({original_key:value}, {$addToSet: {new_key: {$each: ['value1','value2','value3']})

Imagine that if you don't add $each here, if you don't add $each, you will add a new array directly to the array new_key.

['value1','value2','value3']

You can try to understand the function of $each and go back to $addToSet. If there is a value1,value2,value3 in the original array, it will not be added. If it does not exist, it will add what it does not have, and some will not be added repeatedly, and it will not affect each other.

Atomic operation

We don't explain what atomic operation is here, as long as we users know how to use atomic operation.

Db.collection_name.findAndModify ({query: {key:value}, sort: {key2:1/-1}, update/remove:true,new:true})

Query specifies the document for the query

The meaning of sort sort, 1m Mei 1 is not explained here, as above

Update/remove represents operation

New indicates that the final modification result is returned. It can be left empty.

Delete all found data

Db.coolection_name.remove ({key:value})

Delete a table

Db.collection_name.drop ()

View the index of the collection

Db.collection_name.getIndexes ()

Create an index

Db.collection_name.ensureIndex ({key:value})

The previous index is created in the form of key:value, and then the index is created for all fields of a collection

Db.collection_name.ensureIndex ({key:1})

The creation of a composite index is to add a few more contents to it.

Delete index

Db.collection_name.dropIndex ({key:value})

Delete all indexes

Db.collection_name.dropIndexes ()

The previous operation is a collection, and then we will learn to simply operate multiple collections, there are two ways, manually or using DBRef

Create two collections first

Collection1= {'name':'yang','sex':'man'} collection2= {' id':1,'name':'yang','math':60,'pe':30,'chinese':60} db.student.save (collection2) db.yang.save (collection)

Then there is a general train of thought.

Yang=db.yang.findOne () db.student.find ({'name':yang.name}) this is the answer to the question about how to use the Shell command in MongoDB. I hope the above content can be of some help to you. If you still have a lot of doubts to solve, you can follow the industry information channel for more related knowledge.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.