SELECT column_name1,column_name2 FROM table_name;
SELECT * FROM table_name;

UPDATE table_name SET column1=value1,column2=value2,... WHERE some_column=some_value;

DELETE FROM table_name WHERE some_column=some_value;

INSERT INTO table_name VALUES (value1,value2,value3,...);
INSERT INTO table_name (column1,column2,column3,...) VALUES (value1,value2,value3,...);

create database test;

CREATE TABLE Persons
(
    PersonID int,
    LastName varchar(255),
    FirstName varchar(255),
    Address varchar(255),
    City varchar(255)
);

alter table x modify column_name null;
alter table x modify column_name not null;

ALTER TABLE Persons ADD CONSTRAINT uc_PersonID UNIQUE (P_Id,LastName);
--撤销 UNIQUE:
--MySQL
ALTER TABLE Persons DROP INDEX uc_PersonID
--MsSQL
ALTER TABLE Persons DROP CONSTRAINT uc_PersonID

ALTER TABLE Persons ADD CONSTRAINT pk_PersonID PRIMARY KEY (P_Id,LastName);
--撤销 PRIMARY KEY:
--MySQL
ALTER TABLE Persons DROP PRIMARY KEY
--MsSQL
ALTER TABLE Persons DROP CONSTRAINT pk_PersonID

ALTER TABLE Orders ADD FOREIGN KEY (P_Id) REFERENCES Persons(P_Id);
--命名 FOREIGN KEY 约束，并定义多个列的 FOREIGN KEY 约束
ALTER TABLE Orders ADD CONSTRAINT fk_PerOrders FOREIGN KEY (P_Id) REFERENCES Persons(P_Id)
--撤销 FOREIGN KEY:
--MySQL
ALTER TABLE Orders DROP FOREIGN KEY fk_PerOrders
--MsSQL
ALTER TABLE Orders DROP CONSTRAINT fk_PerOrders

ALTER TABLE Persons ADD CONSTRAINT chk_Person CHECK (P_Id>0 AND City='Sandnes');
--撤销 CHECK:
--MySQL
ALTER TABLE Persons DROP CHECK chk_Person
--MsSQL
ALTER TABLE Persons DROP CONSTRAINT chk_Person

--添加default
--MySQL
ALTER TABLE Persons ALTER City SET DEFAULT 'SANDNES'
--MsSQL
ALTER TABLE Persons ADD CONSTRAINT ab_c DEFAULT 'SANDNES' for City
--撤销default
--MySQL
ALTER TABLE Persons ALTER City DROP DEFAULT
--MsSQL
ALTER TABLE Persons ALTER COLUMN City DROP DEFAULT

ALTER TABLE table_name ADD column_name datatype;
ALTER TABLE table_name DROP COLUMN column_name

DROP TABLE table_name;
DROP DATABASE database_name;

CREATE INDEX index_name ON table_name (column_name);
CREATE UNIQUE INDEX index_name ON table_name (column_name)

SELECT * FROM Websites WHERE name LIKE 'G%';
--选取 name 以 "G"、"F" 或 "s" 开始
SELECT * FROM Websites WHERE name REGEXP '^[GFs]';
--选取 name 以 A 到 H 字母开头
SELECT * FROM Websites WHERE name REGEXP '^[A-H]';
--选取 name 不以 A 到 H 字母开头
SELECT * FROM Websites WHERE name REGEXP '^[^A-H]';
--将搜索下列字符串：Carsen、Karsen、Carson 和 Karson（如 Carson）。
SELECT * FROM Websites WHERE name LIKE '[CK]ars[eo]n';
--将搜索以字符串 inger 结尾、以从 M 到 Z 的任何单个字母开头的所有名称（如 Ringer）。
SELECT * FROM Websites WHERE name LIKE '[M-Z]inger';
--将搜索以字母 M 开头，并且第二个字母不是 c 的所有名称（如MacFeather）。
SELECT * FROM Websites WHERE name LIKE 'M[^c]%';
--'%a'          以a结尾的数据
--'a%'          以a开头的数据
--'%a%'         含有a的数据
--'_a_'         三位且中间字母是a的
--'_a'          两位且结尾字母是a的
--'a_'          两位且开头字母是a的
--[charlist]	字符列中的任何单一字符
--[^charlist]   不在字符列中的任何单一字符
--[!charlist]	不在字符列中的任何单一字符

select * from Websites where name in ('value1','value2');
select * from Websites where name='value1' or name='value2';
--mysql会转化为exists，弊端：a表(外表)使用不了索引，必须全表扫描，因为是拿a表的数据到b表查。而且必须得使用a表的数据到b表中查（外表到里表中），顺序是固定死的。
select * from a where exists(select * from b where b.id=a.id );

select * from a where id in (select id from b );
改为
select * from a inner join b on a.id=b.id;

SELECT column_name(s) FROM table_name WHERE column_name BETWEEN value1 AND value2;
SELECT * FROM Websites WHERE alexa NOT BETWEEN 1 AND 20;
SELECT * FROM Websites WHERE name BETWEEN 'A' AND 'H';
SELECT * FROM Websites WHERE name NOT BETWEEN 'A' AND 'H';
SELECT * FROM access_log WHERE date BETWEEN '2016-05-10' AND '2016-05-14';

SELECT column_name AS column_alias_name FROM table_name AS table_alias_name;

--on条件成立，且table1与table2不能出现null，组合成新表
SELECT column_name(s) FROM table1 INNER JOIN table2 ON table1.column_name=table2.column_name;
--on条件成立，且table1不能出现null，table2可出现null，组合成新表
SELECT column_name(s) FROM table1 LEFT JOIN table2 ON table1.column_name=table2.column_name;
--on条件成立，且table1可出现null，table2不能出现null，组合成新表
SELECT column_name(s) FROM table1 RIGHT JOIN table2 ON table1.column_name=table2.column_name;
--on条件成立，且table1与table2可出现null，组合成新表
SELECT column_name(s) FROM table1 FULL OUTER JOIN table2 ON table1.column_name=table2.column_name;
--mysql实现FULL OUTER JOIN
SELECT column_name(s) FROM table1 LEFT JOIN table2 ON table1.column_name=table2.column_name
UNION
SELECT column_name(s) FROM table1 RIGHT JOIN table2 ON table1.column_name=table2.column_name

SELECT column_name(s) FROM table1
UNION
SELECT column_name(s) FROM table2;

SELECT column_name(s) FROM table1
UNION ALL
SELECT column_name(s) FROM table2;

SELECT column_name(s) INTO newtable FROM table1;

CREATE TABLE 新表
AS
SELECT * FROM 旧表

INSERT INTO table1 (a, b) SELECT c, d FROM table2 WHERE id=1;

drop 类型(表，列，索引) 名字

alert 类型(表，列，索引) 名字 操作(add,drop,modify) 类型(表，列，索引) 名字 [新值]

CREATE VIEW view_name AS SELECT column_name(s) FROM table_name WHERE condition;
CREATE VIEW [Products Above Average Price] AS SELECT ProductName,UnitPrice FROM Products WHERE UnitPrice>(SELECT AVG(UnitPrice) FROM Products)

CREATE OR REPLACE VIEW view_name AS SELECT column_name(s) FROM table_name WHERE condition
DROP VIEW view_name

SELECT LastName,FirstName,Address FROM Persons WHERE Address IS NULL;
SELECT LastName,FirstName,Address FROM Persons WHERE Address IS NOT NULL

backup database [name] to disk = 'D:\name.bak' with format;

SELECT site_id, count FROM access_log WHERE count > (SELECT AVG(count) FROM access_log);

SELECT COUNT(column_name) FROM table_name;--排除null
SELECT COUNT(*) FROM table_name;
SELECT COUNT(DISTINCT column_name) FROM table_name;--不同值

SELECT MAX(column_name) FROM table_name;

SELECT MIN(column_name) FROM table_name;

SELECT SUM(column_name) FROM table_name;

SELECT UCASE(column_name) FROM table_name;
--mssql
SELECT UPPER(column_name) FROM table_name;

SELECT LCASE(column_name) FROM table_name;
--mssql
SELECT LOWER(column_name) FROM table_name;

SELECT MID(column_name,start[,length]) FROM table_name;

SELECT LEN(column_name) FROM table_name;
--mysql
SELECT LENGTH(column_name) FROM table_name;

SELECT ROUND(column_name,decimals) FROM table_name;

SELECT name, url, Now() AS date FROM Websites;

SELECT name, url, DATE_FORMAT(Now(),'%Y-%m-%d') AS date FROM Websites;

SELECT site_id, SUM(access_log.count) AS nums FROM access_log GROUP BY site_id;

SELECT Websites.name, Websites.url, SUM(access_log.count) AS nums FROM (access_log INNER JOIN Websites ON access_log.site_id=Websites.id) GROUP BY Websites.name HAVING SUM(access_log.count) > 200;

select [id],[account],[name],[identification] ,rank() over (partition by account,[name],identification order by [count]) as m from Participants

CREATE DATABASE [ IF NOT EXISTS] test [ CHARACTER SET utf8 ];
use test;

create table tutorials_tbl(
                              tutorial_id INT NOT NULL AUTO_INCREMENT,
                              tutorial_title VARCHAR(100) NOT NULL,
                              tutorial_author VARCHAR(40) NOT NULL,
                              submission_date DATE,
                              PRIMARY KEY ( tutorial_id )
);

ALTER TABLE table_name
    MODIFY COLUMN column_name datatype

ALTER TABLE testalter_tbl  DROP i;

ALTER TABLE testalter_tbl ADD i INT;

-- 指定新增字段的位置 
ALTER TABLE testalter_tbl DROP i;
ALTER TABLE testalter_tbl ADD i INT FIRST; -- 设定位第一列
ALTER TABLE testalter_tbl DROP i;
ALTER TABLE testalter_tbl ADD i INT AFTER c; -- 设定位于某个字段之后

--  在 CHANGE 关键字之后，紧跟着的是你要修改的字段名，然后指定新字段名及类型。
ALTER TABLE testalter_tbl CHANGE i j BIGINT;

ALTER TABLE testalter_tbl MODIFY j BIGINT NOT NULL DEFAULT 100;

--1.将名为"例二数据库"的数据库改名为"例七数据库"
alter database 例二数据库
modify name = 例七数据库

--2.为"例六数据库"增加一个数据文件
alter database 例六数据库
add file (
    name=增加的数据文件,
    filename='c:\dbtest\例六数据库增加的数据文件.ndf'
)
--3.为"例六数据库"增加一个日志文件

alter database 例六数据库
add log file (
    name=例六增加的日志文件,
    filename='c:\dbtest\例六增加的日志文件.ldf',
    size=3MB,
    maxsize=50MB,
    filegrowth=10%
)

--4.将"例六数据库"名为"增加的数据文件"的数据库文件改名
alter database 例六数据库
modify file (
    name=增加的数据文件,
    newname=例六数据文件,
    filename='c:\dbtest\例六数据文件.ndf'
)
--5.修改"例六数据库"的排序规则
alter database 例六数据库
collate Chinese_PRC_CI_AS_KS

--6.在"例六数据库"里删除一个数据文件
alter database 例六数据库
remove file 例六数据文件

--7.在"例六数据库"里添加一个文件组
alter database 例六数据库
add filegroup 例十三文件组

--8.在"例六数据库"里为一个文件组改名
alter database 例六数据库
modify filegroup 例十三文件组
name=例十四文件组

--9.在"例六数据库"里添加一个数据文件到一个文件组，并将该文件祖设为默认文件组。
--alter database一次只能修改数据库的一个属性
alter database 例六数据库
add file 
(
    name=例十五数据文件,
    filename='c:\dbtest\例十五数据文件.ndf'
)
to filegroup 例十四文件组
go
alter database 例六数据库
modify filegroup 例十四文件组 default
go

--10.在"例六数据库"里删除"例十四文件组"。
alter database 例六数据库
modify filegroup [primary] default
--将primary文件组设为默认文件组
go
alter database 例六数据库
remove file 例十五数据文件
--删除"例十四文件组"中包含的"例十五数据文件"
go
alter database 例六数据库
remove filegroup 例十四文件组
--删除"例十四文件组"
go

--11.将"例六数据库"里一个文件组设为只读的。
显示代码打印
alter database 例六数据库
add filegroup 例十七文件组
--先添加一个文件组，因为primary文件组不能设为只读
go
alter database 例六数据库
add file 
(
    name=例十七数据文件,
    filename='c:\dbtest\例十七数据文件.ndf'
)
to filegroup 例十七文件组
--添加一个文件到文件组中，因为空文件组不能设为只读
go
alter database 例六数据库
modify filegroup 例十七文件组 read_only
--将文件组设为只读
go

--12.将"例六数据库"设为只有一个用户可访问
alter database 例六数据库
set single_user

--13.设置"例六数据库"可自动收缩
alter database 例六数据库
set auto_shrink on

ALTER TABLE table_name DROP INDEX index_name

select top10 * from (select top 20 * from order by column) order by column desc

SELECT ProductName,UnitPrice*(UnitsInStock+ISNULL(UnitsOnOrder,0)) FROM Products

--一个月内
select createtime from user where DATE_SUB(CURDATE(), INTERVAL 1 MONTH) <= date(createtime);
--一周INTERVAL 7 DAY

use master
go

if exists(select * from sysdatabases where name='student')
drop database student
go

-- 数据库文件
create database student
on
(
    name='student_data',
    filename='student_data.mdf',
    size=10mb,
    maxsize=100mb,
    filegrowth=1mb
)

-- 日志文件
log on
(
    name='student_log',
    filename='student_log.ldf',
    size=10mb,
    maxsize=100mb,
    filegrowth=1mb
)

USE School

IF EXISTS (SELECT *FROM sysobjects WHERE name='teacher')
DROP TABLE teacher

CREATE TABLE Teacher
(
    Id INT IDENTITY(1,1),
    NAME NVARCHAR(50) NOT NULL,
    ClassId INT NOT NULL,
    Gender BIT NOT NULL,
    Age INT,
    Salary MONEY,
    Birthary DATETIME
)

ALTER TABLE table_name
ALTER COLUMN column_name datatype

alter datebase db_name
add file
(
    name = 'file_name',
    filename = 'F:\data\file_name.ndf',
    size = 2MB,
    maxsize = 100MB,
    filegrowth = 5MB
) to filegroup **

alert database db_name
modify file
(
    name = file_name,--file_name 是要修改的数据库文件名
    size = 4MB
)

DROP INDEX table_name.index_name

select * from tablename where LIMIT 9,10

SELECT ProductName,UnitPrice*(UnitsInStock+IFNULL(UnitsOnOrder,0)) FROM Products
SELECT ProductName,UnitPrice*(UnitsInStock+COALESCE(UnitsOnOrder,0)) FROM Products

--10min内
SELECT * FROM tablename WHERE 日期字段 > DATEADD(MINUTE,-10,GETDATE())
SELECT * FROM tablename WHERE datediff(mi,时间字段,getdate())<=10

var newObject = ObjectId()
newObject.getTimestamp()
--ISODate("2017-11-25T07:21:10Z")
newObject.str
--5a1919e63df83ce79df8b38f

var mydate1 = new Date()     --格林尼治时间
mydate1
--ISODate("2018-03-04T14:58:51.233Z")
typeof mydate1
--object
var mydate2 = ISODate() //格林尼治时间
mydate2
--ISODate("2018-03-04T15:00:45.479Z")
typeof mydate2
--object
--这样创建的时间是日期类型，可以使用 JS 中的 Date 类型的方法。

--返回一个时间类型的字符串：

var mydate1str = mydate1.toString()
mydate1str
--Sun Mar 04 2018 14:58:51 GMT+0000 (UTC) 
typeof mydate1str
--string
--或者
Date()
--Sun Mar 04 2018 15:02:59 GMT+0000 (UTC)

use DATABASE_NAME --创建数据库
show dbs --查看所有数据库

db.dropDatabase() --删除数据库

db.createCollection(name, options)

show collections --查看数据表
db.tablename.drop()  --删除数据表

db.COLLECTION_NAME.insert(json) --插入数据
db.collection.insertOne({"a": 3}) --插入单条数据
db.collection.insertMany([{"b": 3}, {'c': 4}]) --插入多条数据

db.collection.update(
   <query>,
   <update>,
   {
     upsert: <boolean>,
     multi: <boolean>,
     writeConcern: <document>
   }
)
db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}}) --更新标题
db.col.save({
"_id" : ObjectId("56064f89ade2f21f36b03136"),
"title" : "MongoDB",
"description" : "MongoDB 是一个 Nosql 数据库",
"by" : "Runoob",
"url" : "http://www.runoob.com",
"tags" : [
"mongodb",
"NoSQL"
],
"likes" : 110
}) --替换数据
db.col.update({"_id":"56064f89ade2f21f36b03136"}, {$unset:{ "test2" : "OK"}}) --移除键值对

db.collection.remove(
   <query>,
   {
     justOne: <boolean>,
     writeConcern: <document>
   }
)
db.col.remove({'title':'MongoDB 教程'}) --删除指定title的所有数据
db.col.remove({}) --删除所有数据
db.inventory.deleteMany({}) --删除集合下全部文档
db.inventory.deleteMany({ status : "A" }) --删除 status 等于 A 的全部文档
db.inventory.deleteOne( { status: "D" } ) --删除 status 等于 D 的一个文档

db.collection.find(query, projection)
db.col.find().pretty() --以易读的方式来读取数据
db.col.find({key1:value1, key2:value2}).pretty() --and
db.col.find(
   {
$or: [
{key1: value1}, {key2:value2}
]
}
).pretty() --or
db.col.find({"likes": {$gt:50}, $or: [{"by": "菜鸟教程"},{"title": "MongoDB 教程"}]}).pretty() --混合
--若不指定 projection，则默认返回所有键，指定 projection 格式如下，有两种模式
db.collection.find(query, {title: 1, by: 1}) --inclusion模式 指定返回的键，不返回其他键
db.collection.find(query, {title: 0, by: 0}) --exclusion模式 指定不返回的键,返回其他键
--_id 键默认返回，需要主动指定 _id:0 才会隐藏
--两种模式不可混用（因为这样的话无法推断其他键是否应返回）
db.collection.find(query, {title: 1, by: 0}) --错误
--只能全1或全0，除了在inclusion模式时可以指定_id为0
db.collection.find(query, {_id:0, title: 1, by: 1}) --正确
--若不想指定查询条件参数 query 可以 用 {} 代替，但是需要指定 projection 参数：
querydb.collection.find({}, {title: 1})

db.col.find({"title" : {$type : 2}})
db.col.find({"title" : {$type : 'string'}})

--读取指定数量的数据,跳过指定数量的数据
db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
--相当于mysql 中limit (10,100)
db.COLLECTION_NAME.find().skip(10).limit(100)

--1 为升序，-1 为降序排列。
db.COLLECTION_NAME.find().sort( {KEY:1})

db.collection.createIndex(keys, options)
--1按升序创建索引，-1按降序创建索引
db.col.createIndex( {"title":1,"description":-1})
db.values.createIndex( {open: 1, close: 1}, {background: true})

--创建索引（旧版本写法）
db.users.ensureIndex( {gender:1,user_name:1})
--查询，它会从索引中提取数据，这是非常快速的数据查询
--由于我们的索引中不包括 _id 字段，_id在查询中会默认返回，我们可以在MongoDB的查询结果集中排除它。
db.users.find({gender:"M"},{user_name:1,_id:0})
--查询就不会被覆盖，从数据库查数据
db.users.find({gender:"M"},{user_name:1})

{
   "address": {
      "city": "Los Angeles",
      "state": "California",
      "pincode": "123"
   },
   "tags": [
      "music",
      "cricket",
      "blogs"
   ],
   "name": "Tom Benzamin"
}
--在我们为数组 tags 创建索引时，会为 music、cricket、blogs三个值建立单独的索引。
db.users.ensureIndex( {"tags":1})
db.users.find({tags:"cricket"})
--索引子文档字段
db.users.ensureIndex( {"address.city":1,"address.state":1,"address.pincode":1})
db.users.find({"address.city":"Los Angeles"})   
db.users.find({"address.state":"California","address.city":"Los Angeles"}) 
db.users.find({"address.city":"Los Angeles","address.state":"California","address.pincode":"123"})

-- by_user 字段对数据进行分组，并计算 by_user 字段相同值的总和
 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
select by_user as _id, count(*) as num_tutorial from mycol group by by_user

db.article.aggregate(
    { $project : {
        title : 1 ,
        author : 1 ,
    }}
 );
--结果中还有_id,tilte和author三个字段，默认情况下_id字段是被包含的，如果不包含_id可以:
db.article.aggregate(
    { $project : {
        _id : 0 ,
        title : 1 ,
        author : 1
    }});
--$match用于获取分数大于70小于或等于90记录，然后将符合条件的记录送到下一阶段$group管道操作符进行处理。
db.articles.aggregate( [
                        { $match : { score : { $gt : 70, $lte : 90 } } },
                        { $group: { _id: null, count: { $sum: 1 } } }
                       ] );
--经过$skip管道操作符处理后，前五个文档被"过滤"掉。
db.article.aggregate(
    { $skip : 5 });
--按日、按月、按年、按周、按小时、按分钟聚合操作如下
db.getCollection('m_msg_tb').aggregate(
[
    {$match:{m_id:10001,mark_time:{$gt:new Date(2017,8,0)}}},
    {$group: {
       _id: {$dayOfMonth:'$mark_time'},
        pv: {$sum: 1}
        }
    },
    {$sort: {"_id": 1}}
])

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

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

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

db.users.find({gender:"M"},{user_name:1,_id:0}).explain()
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()

--判断是否可结算并更新新的结算信息
db.books.findAndModify ( {
   query: {
            _id: 123456789,
            available: { $gt: 0 }
          },
   update: {
             $inc: { available: -1 },
             $push: { checkout: { by: "abc", date: new Date() } }
           }
} )

用来指定一个键并更新键值，若键不存在并创建。
{ $set : { field : value } }

用来删除一个键。
{ $unset : { field : 1} }

$inc可以对文档的某个值为数字型（只能为满足要求的数字）的键进行增减的操作。
{ $inc : { field : value } }

--把value追加到field里面去，field一定要是数组类型才行，如果field不存在，会新增一个数组类型加进去。
{ $push : { field : value } }

--同$push,只是一次可以追加多个值到一个数组字段内。
{ $pushAll : { field : value_array } }

--从数组field内删除一个等于value值。
{ $pull : { field : _value } }

--删除数组的第一个或最后一个元素
{ $pop : { field : 1 } }

--修改字段名称
{ $rename : { old_field_name : new_field_name } }

--位操作，integer类型
{$bit : { field : {and : 5}}}

t.find() { "_id" : ObjectId("4b97e62bf1d8c7152c9ccb74"), "title" : "ABC", "comments" : [ { "by" : "joe", "votes" : 3 }, { "by" : "jane", "votes" : 7 } ] }
 
t.update( {'comments.by':'joe'}, {$inc:{'comments.$.votes':1}}, false, true )
 
t.find() { "_id" : ObjectId("4b97e62bf1d8c7152c9ccb74"), "title" : "ABC", "comments" : [ { "by" : "joe", "votes" : 4 }, { "by" : "jane", "votes" : 7 } ] }

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

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

db.posts.find({$text:{$search:"runoob"}})
或
db.posts.runCommand("text",{search:"runoob"})

db.fs.files.find()

--指定文档个数1000,可不指定,大小10000kb
db.createCollection("cappedLogCollection",{capped:true,size:10000,max:1000})

db.cappedLogCollection.isCapped()

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

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

db.createCollection("counters")
db.counters.insert( {_id:"productid",sequence_value:0})
function getNextSequenceValue(sequenceName){
   var sequenceDocument = db.counters.findAndModify(
      {
         query:{_id: sequenceName },
         update: {$inc:{sequence_value:1}},
"new":true
});
return sequenceDocument.sequence_value;
}
db.products.insert( {
   "_id":getNextSequenceValue("productid"),
   "product_name":"Apple iPhone",
   "category":"mobiles"})

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