1、内外链接
内链接: 只链接匹配的行
左外链接: 包含左边表的所有行(无论右边的表中是否存在与它们匹配的行)，以及右边表中所有匹配的行
右外链接: 包含右边表的所有行(无论左边的表中是否存在与它们匹配的行)，以及左边表中所有匹配的行
全外链接: 包含左、右两个表的所有行，无论另一边的表中是否存在与它们匹配的行。
交叉链接: 生成笛卡尔积－它不使用任何匹配或者选取条件，而是直接将一个数据源中的每一个行与另外一个数据源的每一个行都一一匹配
drop table users;
drop table address;
create table users(
id int primary key auto_increment,
`name` varchar(30)
);
create table address(
id int primary key auto_increment,
uid int,
city varchar(30)
# foreign key(uid) references users(id)
);
insert into users (`name`) values("张三");
insert into users (`name`) values("李四");
insert into users (`name`) values("王五");
insert into address (`uid`,`city`) values(1,"上海");
insert into address (`uid`,`city`) values(2,"北京");
insert into address (`uid`,`city`) values(5,"武汉");
select `name`,city from users inner join address on users.id=address.uid;#内链接
select `name`,city from users left join address on users.id=address.uid;#左外链接
select `name`,city from users right join address on users.id=address.uid;#右外链接
select `name`,city from users full join address;#全链接
select `name`,city from users cross join address;#交叉链接，相似于笛卡儿积
1.内链接(inner join)——左右两边都匹配才链接
select `name`,city from users inner join address on users.id=address.uid;
html
2.左外链接(left join)——左边的表所有都保存下来，右边能够为空
select `name`,city from users left join address on users.id=address.uid;
mysql
3.右外链接(right join)——右边的表所有都保存下来，左边能够为空
select `name`,city from users right join address on users.id=address.uid;
web
4.全链接与交叉链接——两个都是与笛卡儿积相似，都两两相连
2、数据库事务的四大特性(ACID)
1.原子性(Atomicity)
原子性是指事务是一个不可分割的工做单位，事务中的操做要么都发生，要么都不发生。sql
2.一致性(Consistency)
若是事务执行以前数据库是一个完整的状态，那么事务结束后，不管事务是否执行成功，数据库仍然是一个完整的状态。
数据库的完整状态：当一个数据库中的全部的数据都符合数据库中所定义的全部约束，此时能够称数据库是一个完整的状态。
拿转帐来讲，假设用户A和用户B二者的钱加起来一共是5000，那么无论A和B之间如何转帐，转几回帐，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。数据库
3.隔离型(Isolation)
多个用户并发访问数据库时，一个用户的事务不能被其余用户的事务所干扰，多个并发事务之间数据要相互隔离。并发
4.持久性(Durability)
指一个事务一旦被提交，他对数据库的影响是永久性的。svg
3、事务级别
1.不一样事务级别可能带来的问题
脏读
脏数据所指的就是未提交的数据。也就是说，一个事务正在对一条记录作修改，在这个事务完成并提交以前，这条数据是处于待定状态的(可能提交也可能回滚)，这时，第二个事务来读取这条没有提交的数据，并据此作进一步的处理，就会产生未提交的数据依赖关系。这种现象被称为脏读。
salary=1000
T1
T2
read(salary)——1000
write(salary+2000)——3000
read(salary)——3000
rollback
不可重复读
一个事务前后读取同一条记录，而事务在两次读取之间该数据被其它事务所修改，则两次读取的数据不一样，咱们称之为不可重复读。
salary=1000
T1
T2
read(salary)——1000
read(salary)——1000
write(salary+2000)——3000
commit
read(salary)——3000
幻读
一个事务按相同的查询条件从新读取之前检索过的数据，却发现其余事务插入了知足其查询条件的新数据，这种现象就称为幻读。
T1
T2
select * from users where age between 10 and 30;
insert into users(name,age) values(“Bob”,15);
select * from users where age between 10 and 30;
脏读与不可重复读的区别
脏读是读取了未提交的数据。一个事务正在对一条记录作修改，在这个事务完成并提交以前，这条数据是处于待定状态的(可能提交也可能回滚)，这时，第二个事务来读取这条没有提交的数据，并据此作进一步的处理，就会产生未提交的数据依赖关系。这种现象被称为脏读。
不可重复读是在两次读取之间有其它事务对数据作了操做。
不可重复读与幻读的区别
不可重复读的重点是修改，一样的条件, 你读取过的数据, 再次读取出来发现值不同了。
幻读的重点在于新增或者删除 (数据条数变化)。一样的条件, 第1次和第2次读出来的记录数不同。
2.事务的隔离级别
√: 可能出现 ×: 不会出现ui
脏读
不可重复读
幻读
Read uncommitted(读未提交)
√
√
√
Read committed(读提交)
×
√
√
Repeatable read(重复读)
×
×
√
Serializable(序列化)
×
×
×
4、三大范式
第一范式(1NF)：数据表中的每一列(每一个字段)必须是不可拆分的最小单元，也就是确保每一列的原子性；
第二范式在第一范式的基础上更进一层，第二范式须要确保数据库表中每一列都和主键相关，而不能只与主键的某一部分相关(主要针对联合主键而言)。也就是说在一个数据库表中，一个表中只能保存一种数据，不能够把多种数据保存在同一张数据库表中。
第三范式须要确保数据不能存在传递关系，即每一个属性都跟主键有直接关系而不是间接关系。
简而言之：
第1范式：每一个表中都有1列，而且该列是不可拆分的最小单元
第2范式：1张表只描述一件事情。如包含用户-订单-商品信息表，应该拆分为3个表。
第3范式：用外键作表的关联。好比：.net
Student表(学号，姓名，年龄，性别，所在院校，院校地址，院校电话)
就存在上述关系：学号–> 所在院校 --> (院校地址，院校电话)
这样的表结构，咱们应该拆开来：(学号，姓名，年龄，性别，所在院校)–(所在院校，院校地址，院校电话)
参考连接：https://www.cnblogs.com/1906859953Lucas/p/8299959.html
5、五大约束
1.primary KEY:设置主键约束；
2.UNIQUE：设置惟一性约束，不能有重复值；
3.DEFAULT 默认值约束，height DOUBLE(3,2)DEFAULT 1.2 # height不输入是默认为1,2
4.NOT NULL：设置非空约束，该字段不能为空；
5.FOREIGN key :设置外键约束。code
6、常考语法
假设orders表中有以下数据：
{
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 } ]
}
1.统计orders表中记录数
db.orders.aggregate( [
{
$group: {
_id: null,
count: { $sum: 1 }
}
}
] )
相似mysql：SELECT COUNT(*) AS count FROM orders
2.计算orders表中全部记录的price之和
db.orders.aggregate( [
{
$group: {
_id: null,
total: { $sum: "$price" }
}
}
] )
相似mysql：SELECT SUM(price) AS total FROM orders
3.计算cust_id相同的全部记录的price之和
db.orders.aggregate( [
{
$group: {
_id: "$cust_id",
total: { $sum: "$price" }
}
}
] )
相似mysql：SELECT cust_id,SUM(price) AS total FROM orders GROUP BY cust_id
4.对(cust_id,ord_date)进行分组，并计算每组里面的price之和
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" }
}
}
] )
相似mysql：SELECT cust_id,ord_date,SUM(price) AS total FROM orders GROUP BY cust_id,ord_date
5.当cust_id相同的记录数大于1时，查询出该cust_id及其对应的记录数
db.orders.aggregate( [
{
$group: {
_id: "$cust_id",
count: { $sum: 1 }
}
},
{ $match: { count: { $gt: 1 } } }
] )
相似mysql：SELECT cust_id,count(*) FROM orders GROUP BY cust_id HAVING count(*) > 1
6.对(cust_id,ord_date)进行分组，并计算每组里面的price之和,返回price之和大于250时的cust_id,ord_date以及price之和
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 } } }
] )
相似mysql：SELECT cust_id,ord_date,SUM(price) AS total FROM orders GROUP BY cust_id,ord_date HAVING total > 250
7.计算status=‘A’,且cust_id相同的记录的price之和
db.orders.aggregate( [
{ $match: { status: 'A' } },
{
$group: {
_id: "$cust_id",
total: { $sum: "$price" }
}
}
] )
相似mysql：SELECT cust_id,SUM(price) as total FROM orders WHERE status = 'A' GROUP BY cust_id
8.计算status=‘A’,且cust_id相同的记录的price之和,而且只返回price之和大于250的记录
db.orders.aggregate( [
{ $match: { status: 'A' } },
{
$group: {
_id: "$cust_id",
total: { $sum: "$price" }
}
},
{ $match: { total: { $gt: 250 } } }
] )
相似mysql：SELECT cust_id,SUM(price) as total FROM orders WHERE status = 'A' GROUP BY cust_id HAVING total > 250
9.对于每一个惟一的cust_id，将与orders相关联的相应订单项order_lineitem的qty字段进行总计
db.orders.aggregate( [
{ $unwind: "$items" },
{
$group: {
_id: "$cust_id",
qty: { $sum: "$items.qty" }
}
}
] )
相似mysql：SELECT cust_id,SUM(li.qty) as qty FROM orders o,order_lineitem li WHERE li.order_id = o.id GROUP BY cust_id
10.统计(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"}
}
}
}
},
{
$group: {
_id: null,
count: { $sum: 1 }
}
}
] )
相似mysql：SELECT COUNT(*) FROM (SELECT cust_id, ord_date FROM orders GROUP BY cust_id, ord_date) as DerivedTable
185
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
