Detailed explanation of the simple comparison table based on MySQL to MongoDB

Query:
MySQL:
SELECT * FROM user
Mongo:
()
MySQL:
SELECT * FROM user WHERE name = 'starlee'
Mongo:
({‘name' : 'starlee'})
insert:
MySQL:
INSERT INOT user (`name`, `age`) values ('starlee',25)
Mongo:
({‘name' : 'starlee', ‘age' : 25})
If you want to add a field in MySQL, you must:
ALTER TABLE user….
But in MongoDB you only need:
({‘name' : 'starlee', ‘age' : 25, ‘email' : 'starlee@'})
delete:
MySQL:
DELETE * FROM user
Mongo:
({})
MySQL:
DELETE FROM user WHERE age < 30
Mongo:
({‘age' : {$lt : 30}})
$gt : > ; $gte : >= ; $lt : < ; $lte : <= ; $ne : !=
renew:
MySQL:
UPDATE user SET `age` = 36 WHERE `name` = 'starlee'
Mongo:
({‘name' : 'starlee'}, {$set : {‘age' : 36}})
MySQL:
UPDATE user SET `age` = `age` + 3 WHERE `name` = 'starlee'
Mongo:
({‘name' : 'starlee'}, {$inc : {‘age' : 3}})
MySQL:
SELECT COUNT(*) FROM user WHERE `name` = 'starlee'
Mongo:
({‘name' : 'starlee'}).count()
MySQL:
SELECT * FROM user limit 10,20
Mongo:
().skip(10).limit(20)
MySQL:
SELECT * FROM user WHERE `age` IN (25, 35,45)
Mongo:
({‘age' : {$in : [25, 35, 45]}})
MySQL:
SELECT * FROM user ORDER BY age DESC
Mongo:
().sort({‘age' : -1})
MySQL:
SELECT DISTINCT(name) FROM user WHERE age > 20
Mongo:
(‘name', {‘age': {$lt : 20}})
MySQL:
SELECT name, sum(marks) FROM user GROUP BY name
Mongo:
({
key : {‘name' : true},
cond: {‘name' : ‘foo'},
reduce: function(obj,prev) { += ; },
initial: {msum : 0}
});
MySQL:
SELECT name FROM user WHERE age < 20
Mongo:
(‘ < 20′, {name : 1})
I found that many people are searching for MongoDB loop insertion data, and the following is the method of inserting MongoDB loop into the following:
for(var i=0;i<100;i++)({uid:i,uname:'nosqlfan'+i});
One hundred pieces of data are inserted at one time, and the rough structure is as follows:
{ “_id” : ObjectId(“4c876e519e86023a30dde6b8″), “uid” : 55, “uname” : “nosqlfan55″ }
{ “_id” : ObjectId(“4c876e519e86023a30dde6b9″), “uid” : 56, “uname” : “nosqlfan56″ }
{ “_id” : ObjectId(“4c876e519e86023a30dde6ba”), “uid” : 57, “uname” : “nosqlfan57″ }
{ “_id” : ObjectId(“4c876e519e86023a30dde6bb”), “uid” : 58, “uname” : “nosqlfan58″ }
{ “_id” : ObjectId(“4c876e519e86023a30dde6bc”), “uid” : 59, “uname” : “nosqlfan59″ }
{ “_id” : ObjectId(“4c876e519e86023a30dde6bd”), “uid” : 60, “uname” : “nosqlfan60″ }
Simple comparison table
SQL Statement                                                  Mongo Query Language Statement
CREATE TABLE USERS (a Number, b Number)         implicit; can be done explicitly
INSERT INTO USERS VALUES(1,1)                             ({a:1,b:1})
SELECT a,b FROM users                                           ({}, {a:1,b:1})
SELECT * FROM users                                              ()
SELECT * FROM users WHERE age=33                      ({age:33})
SELECT a,b FROM users WHERE age=33                   ({age:33}, {a:1,b:1})
SELECT * FROM users WHERE age=33 ORDER BY name                ({age:33}).sort({name:1})
SELECT * FROM users WHERE age>33                     ({'age':{$gt:33}})})
SELECT * FROM users WHERE age<33                     ({'age':{$lt:33}})})
SELECT * FROM users WHERE name LIKE "%Joe%"                                   ({name:/Joe/})
SELECT * FROM users WHERE name LIKE "Joe%"                               ({name:/^Joe/})
SELECT * FROM users WHERE age>33 AND age<=40                                   ({'age':{$gt:33,$lte:40}})})
SELECT * FROM users ORDER BY name DESC                                   ().sort({name:-1})
CREATE INDEX myindexname ON users(name)                                   ({name:1})
CREATE INDEX myindexname ON users(name,ts DESC)                                   ({name:1,ts:-1})
SELECT * FROM users WHERE a=1 and b='q'                                   ({a:1,b:'q'})
SELECT * FROM users LIMIT 10 SKIP 20                                   ().limit(10).skip(20)
SELECT * FROM users WHERE a=1 or b=2                          ( { $or : [ { a : 1 } , { b : 2 } ] } )
SELECT * FROM users LIMIT 1                                          ()
EXPLAIN SELECT * FROM users WHERE z=3                                   ({z:3}).explain()
SELECT DISTINCT last_name FROM users                                   ('last_name')
SELECT COUNT(*y) FROM users                                            ()
SELECT COUNT(*y) FROM users where AGE > 30                             ({age: {'$gt': 30}}).count()
SELECT COUNT(AGE) from users                                       ({age: {'$exists': true}}).count()
UPDATE users SET a=1 WHERE b='q'                                   ({b:'q'}, {$set:{a:1}}, false, true)
UPDATE users SET a=a+2 WHERE b='q'                                   ({b:'q'}, {$inc:{a:2}}, false, true)
DELETE FROM users WHERE z="abc"                                    ({z:'abc'});
###################################################
1. Operator
I believe everyone knows the operators, which are equal, greater than, less than, not equal, greater than or equal, less than or equal, but these operators cannot be used directly in mongodb. The operator in mongodb is represented as follows:
(1) $gt > (greater than)
(2) $lt< (less than)
(3) $gte>= (greater than or equal to)
(4) $lt<= (less than or equal to)
(5) $ne!= (not equal to)
(6) $inin (included)
(7) $ninnot in (not included)
(8) $existsexist (whether the field exists)
(9) $inc adds value to a numeric field field
(10) $set is equivalent to sql set field = value
(11) $unset is to delete the field
(12) $push appends the value to the field. The field must be an array type. If the field does not exist, a new array type will be added and added.
(13) $pushAll is the same as $push, it can only append multiple values ​​to an array field at a time
(14) $addToSet adds a value to the array, and only increases if this value is not in the array.
(15) $pop deletes the last value: { $pop : { field : 1 } } Deletes the first value: { $pop : { field : -1 } } Note that only one value can be deleted, that is, only 1 or -1 can be used, and 2 or -2 cannot be used to delete two items. mongodb 1.1 and later versions can only be used
(16) $pull removes a value equal to the value from the array field
(17) $pullAll is the same as $pull, and multiple values ​​in the array can be deleted at once.
(18) The $ operator means himself, representing himself in the array found according to the conditions. I won’t talk about this relatively close entrance.
2. CURD Add, modify, read, delete
Increase

Is it very simple? It's that simple. It has no field restrictions. You can name it at will and insert data.

Query

You can see that I used two different ways of writing inquiry. Why is this? In fact, this is the same as cooking. Add different seasonings and the fried dishes have different flavors. Let me tell you the different functions of these two seasonings.
findOne() returns only one document object, find() returns a collection list.
That is to say, for example, if we only want to check the details of a specific data, we can use findOne();
If you want to query a certain set of information, such as a news list, we can use find();
Then I think everyone will definitely think of me at this time that I want to sort this list. No problem mongodb will serve you wholeheartedly

delete
There are two operations to remove() and drop()

distinct operation

2. Be familiar with MongoDB's data operation statements, and are of SQL
Database operation syntax
mongo --path
(username,password) Add user
(username,password) Set up database connection verification
(fromhost) Clone a database from the target server
(name) returns the help for the command
(fromdb,todb,fromhost) Copy database fromdb---source database name, todb---target database name, fromhost---source database server address
(name,{size:3333,capped:333,max:88888}) Create a data set, equivalent to a table
() Cancel the current operation of the current library
() Delete the current database
(func,args) run code server-side
(cname) Get a data set, same usage: db['cname'] or
() Get the name list of all data collections
() Return the last error message
() Return the last wrong object
() Get the server connection object
().setSlaveOk() allow this connection to read from then nonmaster membr of a replica pair
() Returns the name of the database when operating
() Return the previous error object
() ?What level
() ?What information
(name) get the db at the same server as this onew
() Stop (kill) the current operation in the current library
() Returns the dataset status of the current library
()
()
() Returns whether the current database is a shared database
(username) Delete user
() Repair the current database
()
(cmdObj) run a database command. if cmdObj is a string, turns it into {cmdObj:1}
(level) 0=off,1=slow,2=all
() Close the current service program
() Return the version information of the current program
Dataset (table) operation syntax
({id:10}) Returns the dataset with linlin dataset ID=10
({id:10}).count() Returns the total number of data with linlin dataset ID=10
({id:10}).limit(2) Returns the dataset with linlin dataset ID=10 starting from the second item
({id:10}).skip(8) Returns the dataset with linlin dataset ID=10 from 0 to 8th item
({id:10}).limit(2).skip(8) Returns the data from the second to the eighth item with linlin dataset ID=1=
({id:10}).sort() Returns the sorted dataset with linlin dataset ID=10
([query]) Returns a data that meets the criteria
() Returns the database name to which this dataset belongs
() Returns the index information of some data sets
({key:...,initial:...,reduce:...[,cond:...]})
(mayFunction,reduceFunction,<optional params>)
(query) Delete a data in the dataset
(newName) Rename the dataset names
(obj) Insert a data into the dataset
() Returns the status of this dataset
() Returns the storage size of this dataset
() Returns the index file size of this dataset
() Returns the total size of some data sets
(query,object[,upsert_bool]) Update a data set in this data set
() Verify this dataset
() Return the dataset shared version number