Mongodb 和 普通数据库 各种属性 和语句 的对应

SQL to MongoDB Mapping Chart

In addition to the charts that follow, you might want to consider the Frequently Asked Questions section for a selection of common questions about MongoDB.

Terminology and Concepts

The following table presents the various SQL terminology and concepts and the corresponding MongoDB terminology and concepts.

SQL Terms/Concepts MongoDB Terms/Concepts
database database
table collection
row document or BSON document
column field
index index
table joins embedded documents and linking

primary key

Specify any unique column or column combination as primary key.
primary key

In MongoDB, the primary key is automatically set to the_id field.
aggregation (e.g. group by)
aggregation pipeline

See the SQL to Aggregation Mapping Chart.

Executables

The following table presents some database executables and the corresponding MongoDB executables. This table is not meant to be exhaustive.

  MongoDB MySQL Oracle Informix DB2
Database Server mongod mysqld oracle IDS DB2 Server
Database Client mongo mysql sqlplus DB-Access DB2 Client

Examples

The following table presents the various SQL statements and the corresponding MongoDB statements. The examples in the table assume the following conditions:

  • The SQL examples assume a table named users.
  • The MongoDB examples assume a collection named users that contain documents of the following prototype: 
    {
  _id: ObjectId("509a8fb2f3f4948bd2f983a0"),
  user_id: "abc123",
  age: 55,
  status: ‘A‘
}

Create and Alter

The following table presents the various SQL statements related to table-level actions and the corresponding MongoDB statements.

SQL Schema Statements MongoDB Schema Statements 
CREATE TABLE users (
    id MEDIUMINT NOT NULL
        AUTO_INCREMENT,
    user_id Varchar(30),
    age Number,
    status char(1),
    PRIMARY KEY (id)
)

Implicitly created on first insert() operation. The primary key _id is automatically added if _id field is not specified.

db.users.insert( {
    user_id: "abc123",
    age: 55,
    status: "A"
 } )

However, you can also explicitly create a collection:

db.createCollection("users")

ALTER TABLE users
ADD join_date DATETIME

Collections do not describe or enforce the structure of its documents; i.e. there is no structural alteration at the collection level.

However, at the document level, update() operations can add fields to existing documents using the $set operator.

db.users.update(
    { },
    { $set: { join_date: new Date() } },
    { multi: true }
)

ALTER TABLE users
DROP COLUMN join_date

Collections do not describe or enforce the structure of its documents; i.e. there is no structural alteration at the collection level.

However, at the document level, update() operations can remove fields from documents using the $unset operator.

db.users.update(
    { },
    { $unset: { join_date: "" } },
    { multi: true }
)

CREATE INDEX idx_user_id_asc
ON users(user_id)

db.users.createIndex( { user_id: 1 } )

CREATE INDEX
       idx_user_id_asc_age_desc
ON users(user_id, age DESC)

db.users.createIndex( { user_id: 1, age: -1 } )

DROP TABLE users

db.users.drop()

For more information, see db.collection.insert(), db.createCollection(),db.collection.update(), $set, $unset, db.collection.createIndex(), indexes,db.collection.drop(), and Data Modeling Concepts.

Insert

The following table presents the various SQL statements related to inserting records into tables and the corresponding MongoDB statements.

SQL INSERT Statements MongoDB insert() Statements 
INSERT INTO users(user_id,
                  age,
                  status)
VALUES ("bcd001",
        45,
        "A")

db.users.insert(
   { user_id: "bcd001", age: 45, status: "A" }
)

For more information, see db.collection.insert().

Select

The following table presents the various SQL statements related to reading records from tables and the corresponding MongoDB statements.

SQL SELECT Statements MongoDB find() Statements 
SELECT *
FROM users

db.users.find()

SELECT id,
       user_id,
       status
FROM users

db.users.find(
    { },
    { user_id: 1, status: 1 }
)

SELECT user_id, status
FROM users

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

SELECT *
FROM users
WHERE status = "A"

db.users.find(
    { status: "A" }
)

SELECT user_id, status
FROM users
WHERE status = "A"

db.users.find(
    { status: "A" },
    { user_id: 1, status: 1, _id: 0 }
)

SELECT *
FROM users
WHERE status != "A"

db.users.find(
    { status: { $ne: "A" } }
)

SELECT *
FROM users
WHERE status = "A"
AND age = 50

db.users.find(
    { status: "A",
      age: 50 }
)

SELECT *
FROM users
WHERE status = "A"
OR age = 50

db.users.find(
    { $or: [ { status: "A" } ,
             { age: 50 } ] }
)

SELECT *
FROM users
WHERE age > 25

db.users.find(
    { age: { $gt: 25 } }
)

SELECT *
FROM users
WHERE age < 25

db.users.find(
   { age: { $lt: 25 } }
)

SELECT *
FROM users
WHERE age > 25
AND   age <= 50

db.users.find(
   { age: { $gt: 25, $lte: 50 } }
)

SELECT *
FROM users
WHERE user_id like "%bc%"

db.users.find( { user_id: /bc/ } )

SELECT *
FROM users
WHERE user_id like "bc%"

db.users.find( { user_id: /^bc/ } )

SELECT *
FROM users
WHERE status = "A"
ORDER BY user_id ASC

db.users.find( { status: "A" } ).sort( { user_id: 1 } )

SELECT *
FROM users
WHERE status = "A"
ORDER BY user_id DESC

db.users.find( { status: "A" } ).sort( { user_id: -1 } )

SELECT COUNT(*)
FROM users

db.users.count()

or

db.users.find().count()

SELECT COUNT(user_id)
FROM users

db.users.count( { user_id: { $exists: true } } )

or

db.users.find( { user_id: { $exists: true } } ).count()

SELECT COUNT(*)
FROM users
WHERE age > 30

db.users.count( { age: { $gt: 30 } } )

or

db.users.find( { age: { $gt: 30 } } ).count()

SELECT DISTINCT(status)
FROM users

db.users.distinct( "status" )

SELECT *
FROM users
LIMIT 1

db.users.findOne()

or

db.users.find().limit(1)

SELECT *
FROM users
LIMIT 5
SKIP 10

db.users.find().limit(5).skip(10)

EXPLAIN SELECT *
FROM users
WHERE status = "A"

db.users.find( { status: "A" } ).explain()

For more information, see db.collection.find(), db.collection.distinct(),db.collection.findOne(), $ne $and, $or, $gt, $lt, $exists, $lte, $regex, limit(),skip(), explain(), sort(), and count().

Update Records

The following table presents the various SQL statements related to updating existing records in tables and the corresponding MongoDB statements.

SQL Update Statements MongoDB update() Statements 
UPDATE users
SET status = "C"
WHERE age > 25

db.users.update(
   { age: { $gt: 25 } },
   { $set: { status: "C" } },
   { multi: true }
)

UPDATE users
SET age = age + 3
WHERE status = "A"

db.users.update(
   { status: "A" } ,
   { $inc: { age: 3 } },
   { multi: true }
)

For more information, see db.collection.update(), $set, $inc, and $gt.

Delete Records

The following table presents the various SQL statements related to deleting records from tables and the corresponding MongoDB statements.

SQL Delete Statements MongoDB remove() Statements 
DELETE FROM users
WHERE status = "D"

db.users.remove( { status: "D" } )

DELETE FROM users

db.users.remove({})

For more information, see db.collection.remove().

SQL to Aggregation Mapping Chart

The aggregation pipeline allows MongoDB to provide native aggregation capabilities that corresponds to many common data aggregation operations in SQL.

The following table provides an overview of common SQL aggregation terms, functions, and concepts and the corresponding MongoDB aggregation operators:

SQL Terms, Functions, and Concepts MongoDB Aggregation Operators
WHERE $match
GROUP BY $group
HAVING $match
SELECT $project
ORDER BY $sort
LIMIT $limit
SUM() $sum
COUNT() $sum
join No direct corresponding operator; however, the$unwind operator allows for somewhat similar functionality, but with fields embedded within the document.

Examples

The following table presents a quick reference of SQL aggregation statements and the corresponding MongoDB statements. The examples in the table assume the following conditions:

  • The SQL examples assume two tables, orders and order_lineitem that join by theorder_lineitem.order_id and the orders.id columns.
  • The MongoDB examples assume one collection orders that contain documents of the following prototype: 
    {
  cust_id: "abc123",
  ord_date: ISODate("2012-11-02T17:04:11.102Z"),
  status: ‘A‘,
  price: 50,
  items: [ { sku: "xxx", qty: 25, price: 1 },
           { sku: "yyy", qty: 25, price: 1 } ]
}
SQL Example MongoDB Example Description 
SELECT COUNT(*) AS count
FROM orders

db.orders.aggregate( [
   {
     $group: {
        _id: null,
        count: { $sum: 1 }
     }
   }
] )
Count all records fromorders 
SELECT SUM(price) AS total
FROM orders

db.orders.aggregate( [
   {
     $group: {
        _id: null,
        total: { $sum: "$price" }
     }
   }
] )
Sum theprice field from orders 
SELECT cust_id,
       SUM(price) AS total
FROM orders
GROUP BY cust_id

db.orders.aggregate( [
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   }
] )
For each uniquecust_id, sum theprice field. 
SELECT cust_id,
       SUM(price) AS total
FROM orders
GROUP BY cust_id
ORDER BY total

db.orders.aggregate( [
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   },
   { $sort: { total: 1 } }
] )
For each uniquecust_id, sum theprice field, results sorted by sum. 
SELECT cust_id,
       ord_date,
       SUM(price) AS total
FROM orders
GROUP BY cust_id,
         ord_date

db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           ord_date: {
               month: { $month: "$ord_date" },
               day: { $dayOfMonth: "$ord_date" },
               year: { $year: "$ord_date"}
           }
        },
        total: { $sum: "$price" }
     }
   }
] )
For each uniquecust_id,ord_dategrouping, sum the pricefield. Excludes the time portion of the date. 
SELECT cust_id,
       count(*)
FROM orders
GROUP BY cust_id
HAVING count(*) > 1

db.orders.aggregate( [
   {
     $group: {
        _id: "$cust_id",
        count: { $sum: 1 }
     }
   },
   { $match: { count: { $gt: 1 } } }
] )
For cust_idwith multiple records, return thecust_id and the corresponding record count. 
SELECT cust_id,
       ord_date,
       SUM(price) AS total
FROM orders
GROUP BY cust_id,
         ord_date
HAVING total > 250

db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           ord_date: {
               month: { $month: "$ord_date" },
               day: { $dayOfMonth: "$ord_date" },
               year: { $year: "$ord_date"}
           }
        },
        total: { $sum: "$price" }
     }
   },
   { $match: { total: { $gt: 250 } } }
] )
For each uniquecust_id,ord_dategrouping, sum the pricefield and return only where the sum is greater than 250. Excludes the time portion of the date. 
SELECT cust_id,
       SUM(price) as total
FROM orders
WHERE status = ‘A‘
GROUP BY cust_id

db.orders.aggregate( [
   { $match: { status: ‘A‘ } },
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   }
] )
For each uniquecust_id with status A, sum the pricefield. 
SELECT cust_id,
       SUM(price) as total
FROM orders
WHERE status = ‘A‘
GROUP BY cust_id
HAVING total > 250

db.orders.aggregate( [
   { $match: { status: ‘A‘ } },
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   },
   { $match: { total: { $gt: 250 } } }
] )
For each uniquecust_id with status A, sum the pricefield and return only where the sum is greater than 250. 
SELECT cust_id,
       SUM(li.qty) as qty
FROM orders o,
     order_lineitem li
WHERE li.order_id = o.id
GROUP BY cust_id

db.orders.aggregate( [
   { $unwind: "$items" },
   {
     $group: {
        _id: "$cust_id",
        qty: { $sum: "$items.qty" }
     }
   }
] )
For each uniquecust_id, sum the corresponding line item qtyfields associated with the orders. 
SELECT COUNT(*)
FROM (SELECT cust_id,
             ord_date
      FROM orders
      GROUP BY cust_id,
               ord_date)
      as DerivedTable

db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           ord_date: {
               month: { $month: "$ord_date" },
               day: { $dayOfMonth: "$ord_date" },
               year: { $year: "$ord_date"}
           }
        }
     }
   },
   {
     $group: {
        _id: null,
        count: { $sum: 1 }
     }
   }
] )
时间： 2024-10-27 12:10:31

Mongodb 和 普通数据库 各种属性 和语句 的对应的相关文章

MySQL、MongoDB、Redis 数据库之间的区别与使用（本章迭代更新）

MySQL.MongoDB.Redis 数据库之间的区别与使用 MySQL.MongoDB.Redis 数据库之间的区别与使用(本章迭代更新) update:2019年2月20日 15:21:19(本章迭代更新) 一.数据库之间的区别 MySQL MySQL概述 关系型数据库.无论数据还是索引都存放在硬盘中.到要使用的时候才交换到内存中.能够处理远超过内存总量的数据. 在不同的引擎上有不同 的存储方式. 查询语句是使用传统的 SQL 语句,拥有较为成熟的体系,成熟度很高. 开源数据库的份额在不断

第五十一课 NoSQL基础概念及MongoDB应用、数据库分配概念

NoSQL基础概念及MongoDB MongoDB基础应用 MongoDB索引及复制集 数据库分片的概念及Mongodb  sharding的实现 一.NoSQL基础概念 NoSQL(Not Only SQL),是一种技术流派,非关系型数据库:适合用在大数据领域,各种nosql有各自的查询语句,这也是nosql的缺点之一. 大数据(BigDate)也称海量数据是一个模糊的概念,像Google.百度收集大量数据,分析现在.预测未来:这些数据通过某些特定的特征和算法得出某些预测的结果,这些数据为大数

解决数据库默认属性无效的问题

问题背景: 本项目属于SSH项目,持久层关系数据库框架是Hibernate.前台通过序列化表单,将全部参数和参数值传到后台. 预期效果: 将数据库表里某些Number类型的字段设置初始值为0.0,如果前台表单没有填充这些字段,待执行添加操作后,这些Number类的字段的值为默认值0.0 实际效果: 执行添加操作后,Number类型的字段的值为空,并非0.0 解决问题: 数据库默认属性无效的问题 解决方式: 在映射文件*.hbm.xml的<class name=.....dynamic-inser

安装MongoDB非关系型数据库

安装MongoDB非关系型数据库 MongoDB基础 技能目标 理解MongoDB数据库的基本概念 学会安装MongoDB数据库 MongoDB概述 MongoDB是一款开源的文档数据库,并且是业内领先的NoSQL数据库,用C++编写而成 MongoDB简介 MongoDB是一款跨平台.面向文档的数据库.可以实现高性能,高可用性,并且能能够轻松拓展.在高负载的情况下,添加更多节点,可以保证服务器性能 MongoDB是一个介于关系型数据库和非关系数据库之间的产品,是非关系型数据库当中功能最丰富,最

MongoDB非关系型数据库开发手册

一:NoSql数据库 什么是NoSQL? NoSQL,指的是非关系型的数据库.NoSQL有时也称作Not Only SQL的缩写,是对不同于传统的关系型数据库的数据库管理系统的统称. NoSQL用于超大规模数据的存储.(例如谷歌或Facebook每天为他们的用户收集万亿比特的数据).这些类型的数据存储不需要固定的模式,无需多余操作就可以横向扩展. 为什么使用NoSQL ? 今天我们可以通过第三方平台(如:Google,Facebook等)可以很容易的访问和抓取数据.用户的个人信息,社交网络,地理

MySQL数据库（3）_MySQL数据库表记录操作语句

附: MYSQL5.7版本sql_mode=only_full_group_by问题 1.查询当前sql_mode: select @@sql_mode 2.查询出来的值为: set @@sql_mode ='ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION'; 3.修改s

使用MongoDB作为后台数据库的尝试

MongoDB作为一个阶层型数据库,在很短的时间里面是不可能被大面积推广使用的, 本文作为一个实验性的课题,探讨一下MongoDB作为网站数据库的可能性. 1.MongoDB作为代替关系型数据库的可能性. 2.MongoDB作为代替文件服务器的可能性. 通过探讨来加强对于MongoDB的认识 环境准备 技术选型 1.由于是验证性质的课题,这里没有使用MVC5/6.如果有人对MVC6有兴趣,可以另开一个课题讨论.这里使用的是传统的WebForm. 2.使用MongoDB最新版本作为数据库 3.Mo

MongoDB：更改数据库位置（Windows）

MongoDB在Windows中默认的数据库目录是c:\data.如果在没有该目录的情况下,直接运行mongod.exe,就会报如下错误: 在某些情况下,我们并不想把mongoDB的数据库放在c盘,这时候有两种方法可以切换数据库目录. 1. 命令方式 首先创建数据库目录,例如d:\data.然后运行命令 mongod –dbpath d:\data 2. 配置文件方式 在任意位置创建一个配置文件,例如c:\mongodb\conf的目录下创建一个名为master.cfg的文件,内容为dbpath

Mybatis分页-利用Mybatis Generator插件生成基于数据库方言的分页语句，统计记录总数 (转)

众所周知,Mybatis本身没有提供基于数据库方言的分页功能,而是基于JDBC的游标分页,很容易出现性能问题.网上有很多分页的解决方案,不外乎是基于Mybatis本机的插件机制,通过拦截Sql做分页.但是在像Oracle这样的数据库上,拦截器生成的Sql语句没有变量绑定,而且每次语句的都要去拦截,感觉有点浪费性能. Mybatis Generator是Mybatis的代码生成工具,可以生成大部分的查询语句. 本文提供的分页解决方案是新增Mybatis Generator插件,在用Mybatis