「深度学习福利」大神带你进阶工程师,立即查看>>>
什么是主从复制
持久化保证了即使 redis 服务重启也会丢失数据,因为 redis 服务重启后会将硬盘上持久化的数据恢复到内存中,但是当 redis 服务器的硬盘损坏了可能会导致数据丢失,如果通过 redis 的主从复制机制就可以避免这种单点故障,如下图：

说明： 主 redis 中的数据有两个副本（replication）即从 redis1 和从 redis2,即使一台 redis 服务器宕机其它两台 redis 服务也可以继续提供服务。 主 redis 中的数据和从 redis 上的数据保持实时同步,当主 redis 写入数据时通过主从复制机制会复制到两个从 redis 服务上。 只有一个主 redis,可以有多个从 redis。 主从复制不会阻塞 master,在同步数据时,master 可以继续处理 client 请求。 一个 redis 可以即是主又是从,如下图：


主从配置
1、主 redis 配置
无需特殊配置。
2、从redis配置
修改从 redis 服务器上的 redis.conf 文件,添加 slaveof 主 redisip 主 redis 端口。

上边的配置说明当前该从 redis 服务器所对应的主 redis 是192.168.101.3,端口是6379。

主从复制过程
1、完整复制过程
在 redis2.8 版本之前主从复制过程如下图：

复制过程说明： slave 服务启动,slave 会建立和 master 的连接,发送 sync 命令。 master 启动一个后台进程将数据库快照保存到 RDB 文件中 注意：此时如果生成 RDB 文件过程中存在写数据操作会导致 RDB 文件和当前主 redis 数据不一致,所以此时 master 主进程会开始收集写命令并缓存起来。 master 就发送 RDB 文件给 slave slave 将文件保存到磁盘上,然后加载到内存恢复 master 把缓存的命令转发给 slave 注意：后续 master 收到的写命令都会通过开始建立的连接发送给 slave。
当 master 和 slave 的连接断开时 slave 可以自动重新建立连接。如果 master 同时收到多个 slave 发来的同步连接命令,只会启动一个进程来写数据库镜像,然后发送给所有 slave。
完整复制的问题： 在 redis2.8 之前从 redis 每次同步都会从主 redis 中复制全部的数据,如果从 redis 是新创建的从主 redis 中复制全部的数据这是没有问题的,但是,如果当从 redis 停止运行,再启动时可能只有少部分数据和主 redis 不同步,此时启动 redis 仍然会从主 redis 复制全部数据,这样的性能肯定没有只复制那一小部分不同步的数据高。
2、部分复制

部分复制说明： 从机连接主机后,会主动发起 PSYNC 命令,从机会提供 master 的 runid(机器标识,随机生成的一个串) 和 offset（数据偏移量,如果offset主从不一致则说明数据不同步）,主机验证 runid 和 offset 是否有效,runid 相当于主机身份验证码,用来验证从机上一次连接的主机,如果 runid 验证未通过则,则进行全同步,如果验证通过则说明曾经同步过,根据 offset 同步部分数据。

「深度学习福利」大神带你进阶工程师,立即查看>>>
系统
# uname -a # 查看内核/操作系统/CPU信息
# lsb_release -a # 查看操作系统版本 (适用于所有的linux,包括Redhat、SuSE、Debian等发行版,但是在debian下要安装lsb)
# cat /proc/cpuinfo # 查看CPU信息
# hostname # 查看计算机名
# lspci -tv # 列出所有PCI设备
# lsusb -tv # 列出所有USB设备
# lsmod # 列出加载的内核模块
# env # 查看环境变量
资源
# free -m # 查看内存使用量和交换区使用量
# df -h # 查看各分区使用情况
# du -sh <目录名> # 查看指定目录的大小
# grep MemTotal /proc/meminfo # 查看内存总量
# grep MemFree /proc/meminfo # 查看空闲内存量
# uptime # 查看系统运行时间、用户数、负载
# cat /proc/loadavg # 查看系统负载
磁盘和分区
# mount | column -t # 查看挂接的分区状态
# fdisk -l # 查看所有分区
# swapon -s # 查看所有交换分区
# hdparm -i /dev/hda # 查看磁盘参数(仅适用于IDE设备)
# dmesg | grep IDE # 查看启动时IDE设备检测状况
网络
# ifconfig # 查看所有网络接口的属性
# iptables -L # 查看防火墙设置
# route -n # 查看路由表
# netstat -lntp # 查看所有监听端口
# netstat -antp # 查看所有已经建立的连接
# netstat -s # 查看网络统计信息
进程
# ps -ef # 查看所有进程
# top # 实时显示进程状态
用户
# w # 查看活动用户
# id <用户名> # 查看指定用户信息
# last # 查看用户登录日志
# cut -d: -f1 /etc/passwd # 查看系统所有用户
# cut -d: -f1 /etc/group # 查看系统所有组
# crontab -l # 查看当前用户的计划任务
服务
# chkconfig --list # 列出所有系统服务
# chkconfig --list | grep on # 列出所有启动的系统服务
程序
# rpm -qa # 查看所有安装的软件包

查看CPU信息（型号）
# cat /proc/cpuinfo | grep name | cut -f2 -d: | uniq -c
8 Intel(R) Xeon(R) CPU E5410 @ 2.33GHz
(看到有8个逻辑CPU, 也知道了CPU型号)
# cat /proc/cpuinfo | grep physical | uniq -c
4 physical id : 0
4 physical id : 1
(说明实际上是两颗4核的CPU)
# getconf LONG_BIT
32
(说明当前CPU运行在32bit模式下, 但不代表CPU不支持64bit)
# cat /proc/cpuinfo | grep flags | grep ' lm ' | wc -l
8
(结果大于0, 说明支持64bit计算. lm指long mode, 支持lm则是64bit)
再完整看cpu详细信息, 不过大部分我们都不关心而已.
# dmidecode | grep 'Processor Information'
其他
查看内存信息
# cat /proc/meminfo
# uname -a
Linux euis1 2.6.9-55.ELsmp #1 SMP Fri Apr 20 17:03:35 EDT 2007 i686 i686 i386 GNU/Linux
(查看当前操作系统内核信息)
# cat /etc/issue | grep Linux
Red Hat Enterprise Linux AS release 4 (Nahant Update 5)
(查看当前操作系统发行版信息)
查看机器型号
# dmidecode | grep "Product Name"
查看网卡信息
# dmesg | grep -i eth

「深度学习福利」大神带你进阶工程师,立即查看>>>
对查询进行优化,要尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立索引。
对查询进行优化,要尽量避免全表扫描,首先应考虑在进行条件判断的字段上创建了索引。
应尽量避免在where子句中对字段进行null值判断,使用！= 或 <>操作符等,否则将导致引擎放弃使用索引而进行全表扫描。
也不能在where子句中使用or来连接条件（应该用union all来使用两个语句）,如果一个字段有索引另外一个字段没有索引也会导致引擎放弃使用索引而进行全表扫描。
not in应该慎用 , 用not exists代替not in
（mysql中）模糊查询避免使用“%”
避免在where子句中进行表达式计算操作
在使用索引字段作为条件是,如果该索引是复合索引那么必须使用到该索引中第一个字段作为条件时才能保证系统使用了索引（最左原则） ,否则该索引将不会被使用,并且应该尽可能的让字段顺序和索引顺序一致。所谓复合索引就是创建一个索引的时候作用在多个字段上。
updata语句,如果只更改一两个字段,不要update全部字段,否则频繁调用会引起明显的性能消耗,同时带来大量日志。
对于多张大数据量（这里几百条算大了）的表连接,可以考虑使用程序去实现,不要做连接查询,就是尽量避开多表查询。
索引并不是越多越好,索引固然可以提高相应的select的效率,但同时也降低了insert及update的效率,因为insert或update时有可能会重建索引,索引怎么样建索引需要慎重考虑,视具体情况而定。
尽量使用数字型字段,若只会数值信息的字段尽量不要设置为字符型,这回降低插叙和连接的性能,并会增加存储开销,这是因为引擎在处理查询和连接是会逐个比较字符串中每一个字符,而对于数据型而言只需要比较一次就够了。
任何地方都不要使用select*from,用具体的字段代替“*”,不要返回用不到的任何字段。
学会使用慢查询来进行数据库的优化。

「深度学习福利」大神带你进阶工程师,立即查看>>>
下载地址：https://dev.mysql.com/downloads/mysql/
安装步骤
1.下载zip解压到目录下
2.配置环境变量
新建系统变量：MYSQL_HOME,值：D:\DevelopmentTool\Mysql-5.7.26-winx64
修改path变量：%MYSQL_HOME%\bin;（在末端添加）
3.创建配置文件
在程序目录下创建my.ini配置文件（此处为：D:\DevelopmentTool\Mysql-5.7.26-winx64）,文件内容如下： [mysqld] #绑定IPv4 bind-address = 0.0.0.0 # 设置mysql的安装目录,即你解压缩安装包的位置 basedir = D:/DevelopmentTool/Mysql-5.7.26-winx64 # 设置mysql数据库的数据的存放目录 datadir = D:/DevelopmentTool/Mysql-5.7.26-winx64/data # 设置端口号 port = 3306 # 允许最大连接数 max_connections = 200 # 设置字符集为utf8 loose-default-character-set = utf8 # 开启查询缓存 explicit_defaults_for_timestamp = true # windows下区分表名大小写(0:不区分,2区分(5.7版本)) lower_case_table_names=2 sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES [client] #设置客户端字符集 port=3306 default-character-set = utf8 [WinMySQLadmin] Server = D:/DevelopmentTool/Mysql-5.7.26-winx64/bin/mysqld.exe
4.注册windows系统服务 打开cmd（附件-命令提示符,右键超级管理员打开）,否则可能会提示（Install/Remove of the Service Denied） 运行安装命令 mysqld install MySQL --defaults-file="%MYSQL_HOME%\my.ini" 备注：如果想要移除该服务,使用命令：mysqld -remove
5.启动服务
注意：此时是无法正常启动mysql服务的,因为5.7.18版本是不附带data文件夹的,需要通过命令来创建data文件夹和默认的数据库（如果存在,删除data目录下所有文件）,然后执行创建命令：mysqld --initialize-insecure --user=mysql
启动服务方式1,执行命令：net start mysql 启动服务方式2,运行-services.msc,找到mysql服务,右键启动
6.修改root密码
刚完成安装时,密码是空的,我们可以通过命令行修改root账号的密码为root,保持一致。 打开cmd：mysql -uroot -p（提示 Enter password,直接回车,默认密码为空） use mysql; update user set authentication_string=password('root') WHERE user='root'; flush privileges; exit
7.常用命令
在命令行中,配置好环境变量后,通过cmd可以直接进入mysql命令行模式,同时列举几种常用命令 # 进入mysql数据库,密码可以先不写,打完-p后再输入,防止被别人看到 mysql -u账号 -p密码 -u 用户名 -p 密码 -h 服务器名称 -p 端口号 -D 打开指定数据库 --prompt=name 设置命令提示符 --delimiter=name 指定分隔符 -V,--version 输出版本信息并且退出 exit,quit,\q 退出 # 创建数据库 CREATE {DATABASE|SCHEMAS} [IF NOT EXISTS] db_name DEFAULT CHARACTER SET = 'UTF8|GBK|...'; CREATE DATABASE IF NOT EXISTS myWebSite; # 修改数据库编码方式 ALTER {DATABSE|SCHEMAS} db_name [DEFAULT] CHARACTER SET [=] charset_name; ALTER DATABSE myWebSiteDEFAULT CHARACTER SET = utf8; # 数据库列表 SHOW DATABASE; SHOW SCHEMAS; # 查看指定数据库定义 SHOW CREATE {DATABASE|CEHMAS} db_name; SHOW CREATE DATABASE myWebSite; # 查看上条数据库警告 SHOW WARNINGS; # 打开指定数据库和查看当前打开的数据库（如果忘记了） USE db_name; SELECT DATABASE()|SCHEMAS(); # 删除指定数据库 DROP {DATABASE|CEHMAS} [IF EXISTS] db_name; DROP DATABASE IF EXISTS myWebSite; # 查看数据表结构 DESC db_name; DESCRIBE db_name; SHOW COLUMNS FROM db_name; # UNSIGNED 无符号,移除负数范围,即无法填充负数范围的数值 CREATE TABLE table_name(num1 INT UNSIGNED); # ZEROFILL 自动补充0,创建数据表时,会根据其位数自动在前面补0,如int,默认十位数范围,填充1数字,会变成0000000001 CREATE TABLE table_name(num1 INT ZEROFILL);
8.配置mysql输出日志到指定位置
在sql命令行中,输入以下命令即可 \T D:\SQLlog\syslog.txt
9.数据类型（需要注意的）
字符串-枚举类型 ENUM ENUM(temp1,temp2,temp3) 注意：设置的字符串中含有空格将自动忽略 栗子：CREATE TABLE IF NOT EXISTS test(sex ENUM('男','女','保密')); 测试：INSERT test VALUES('男'); 错误：存入的值与枚举中地值不一致时会报错 测试：INSERT test VALUES('男1'); 特殊1：存入的值可以为序号,序号值从1开始,即男为1,女为2,保密为3 测试1：INSERT test VALUES(1); 特殊2：如果设置的字段可以为NUll,则也可以键入 测试2：INSERT test VALUES(NULL);
字符串-集合类型 SET SET(temp1,temp2,temp3) 注意：设置的字符串中含有空格将自动忽略 栗子：CREATE TABLE IF NOT EXISTS test(favour SET('A','B','C','D')); 测试：INSERT test VALUES('A,C,D');INSERT test VALUES('D,B,A'); 特殊1：存入的值是以2进制来保存,可以使用2进制来控制值,ABCD分别以1、2、4、8来表示,这里键入3,则表示保存AB,15则表示保存所有 测试1：INSERT test VALUES(3);INSERT test VALUES(15);
注：另外一篇文章来继续后面的内容。

「深度学习福利」大神带你进阶工程师,立即查看>>>
先简单解释一下笛卡尔积。
现在,我们有两个集合A和B。
A = {0,1} B = {2,3,4}
集合 A×B 和 B×A的结果集就可以分别表示为以下这种形式：
A×B = {（0,2）,（1,2）,（0,3）,（1,3）,（0,4）,（1,4）}；
B×A = {（2,0）,（2,1）,（3,0）,（3,1）,（4,0）,（4,1）}；
以上A×B和B×A的结果就可以叫做两个集合相乘的‘笛卡尔积’。
从以上的数据分析我们可以得出以下两点结论：
1,两个集合相乘,不满足交换率,既 A×B ≠ B×A;
2,A集合和B集合相乘,包含了集合A中元素和集合B中元素相结合的所有的可能性。既两个集合相乘得到的新集合的元素个数是 A集合的元素个数 × B集合的元素个数;
MySQL的多表查询(笛卡尔积原理) 先确定数据要用到哪些表。 将多个表先通过笛卡尔积变成一个表。 然后去除不符合逻辑的数据（根据两个表的关系去掉）。 最后当做是一个虚拟表一样来加上条件即可。
数据库表连接数据行匹配时所遵循的算法就是以上提到的笛卡尔积,表与表之间的连接可以看成是在做乘法运算。
比如现在数据库中有两张表,student表和 student_subject表,如下所示：
　　
我们执行以下的sql语句,只是纯粹的进行表连接。 SELECT * from student JOIN student_subject; SELECT * from student_subject JOIN student;
看一下执行结果：
　　
　　表1.0　　　　　　　　　　　　　　　　　　　　　　　　　 　　表1.1
从执行结果上来看,结果符合我们以上提出的两点结论（红线标注部分）；
以第一条sql语句为例我们来看一下他的执行流程,
1,from语句把student表 和 student_subject表从数据库文件加载到内存中。
2,join语句相当于对两张表做了乘法运算,把student表中的每一行记录按照顺序和student_subject表中记录依次匹配。
3,匹配完成后,我们得到了一张有 （student中记录数 × student_subject表中记录数）条的临时表。 在内存中形成的临时表如表1.0所示。我们又把内存中表1.0所示的表称为‘笛卡尔积表’。

　　针对以上的理论,我们提出一个问题,难道表连接的时候都要先形成一张笛卡尔积表吗,如果两张表的数据量都比较大的话,那样就会占用很大的内存空间这显然是不合理的。所以, 我们在进行表连接查询的时候一般都会使用JOIN xxx ON xxx的语法,ON语句的执行是在JOIN语句之前的,也就是说两张表数据行之间进行匹配的时候,会先判断数据行是否符合ON语句后面的条件,再决定是否JOIN 。
　　因此,有一个显而易见的SQL优化的方案是,当两张表的数据量比较大,又需要连接查询时,应该使用 FROM table1 JOIN table2 ON xxx的语法,避免使用 FROM table1,table2 WHERE xxx 的语法,因为后者会在内存中先生成一张数据量比较大的笛卡尔积表,增加了内存的开销。
下面引出Mysql的左右连接和内连接的笛卡尔积...
　一个同事跟我讨论左连接查询,是不是笛卡尔积。我第一反应,左连接肯定不是笛卡尔积啊,左连接是以左表为准,左表有m条记录,则结果集是m条记录(哈哈,如果是你,你是不是也是这样的反映),同事听了,说内连接会是笛卡尔积。在数据库里试验了一下,发现,事实比想象中要复杂。
首先说下结论：链接查询,如果on条件是非唯一字段,会出现笛卡尔积(局部笛卡尔积)；如果on条件是表的唯一字段,则不会出现笛卡尔积。
　　下面是具体的试验：( 以真三国无双v3.9d蜀国阵容为例... )
　　文中会有两张表,user表和job表,表数据如下,其中user为5条记录,job为4条记录
USER: job:

1.交叉连接
如果A表有m(5)条记录,m1条符合on条件,B表有n(4)条记录,有n1条符合on条件,无条件交叉连接的结果为: m*n=5*4=20 SELECT * FROM `user` CROSS JOIN job;
这种等同于(交叉查询等于不加on的内连接) SELECT * FROM `user` , job;
sql执行结果：总共20条记录
　 　结论：交叉连接,会产生笛卡尔积。
2.内连接(可以当做左连接的特殊情况,只保留符合主表中on条件的记录)
(1)内连接唯一字段
如果A表有m(5)条记录,m1(4)条符合on条件,B表有n(4)条记录,有n1(3)条符合on条件,内连接唯一字段结果为:Max(m1,n1)=4
1,2,2,6,7 和 1,2,7,8对比,以user表为主表,因为主表中有4条符合条件的记录(1,2,2,7),而job表有3条符合条件的记录(1,2,7),取两者中的最大的,所以为4条 SELECT * FROM `user` u JOIN job j ON u.JOB_ID=j.ID;
sql执行结果为:4条记录
　 　结论：假如,内连接查询,on条件是A表或者B表的唯一字段,则结果集是两表的交集,不是笛卡尔积。

(2)内连接非唯一字段
如果A表有m(5)条记录,m1(2)条符合on条件,B表有n(4)条记录,有n1(3)条符合on条件,则结果集是Max(m1,n1)=3条
1,2,2,6,7 和 1,1,7,8对比,以user表为主表,因为主表中有2条符合条件的记录(1,7),而job表有3条符合条件的记录(1,1,7),取两者中的最大的,所以为 3 条 SELECT * FROM `user` u JOIN job j ON u.valid=j.valid;
　　 结论：假如,on条件是表中非唯一字段,则结果集是两表匹配到的结果集的笛卡尔积(局部笛卡尔积) 。
3.外连接
(1)左连接
a.左连接唯一字段
假如A表有m(5)条记录,B表有n(4)条记录,则结果集是m=5
1,2,2,6,7 和 1,2,7,8对比,以user表为主表,因为主表中有4条符合条件的记录(1,2,2,7),而job表有3条符合条件的记录(1,2,7),取两者中的最大的,所以取 4 条,然后再加上user表中没有在job表中找到对应关系的记录(即对应的job表都为null,5-4= 1 ),所以最终结果为 4+1=5 条 SELECT * FROM USER u LEFT JOIN job j ON u.JOB_ID=j.id;
SQL查询结果:5条记录
结论：on条件是唯一字段,则结果集是左表记录的数量。
b.左连接非唯一字段
1,2,2,6,7 和 1,1,7,8对比,以user表为主表,因为主表中有2条符合条件的记录(1,7),而job表有3条符合条件的记录(1,1,7),取两者中的最大的,所以取 3 条,然后在加上user表在job表中没有匹配的记录(即对应的job表都为null,为5-2= 3 ),所以最终结果为 3+3=6 条 SELECT * FROM `user` u LEFT JOIN job j ON u.VALID=j.VALID;
　 　结论：左连接非唯一字段,是局部笛卡尔积。

c.当on 条件为假时的内连接： SELECT * FROM `user` u LEFT JOIN job j ON 0;
sql查询结果:5条
结论：当on条件为假的时候,即user在job表中一条符合记录的都没有,那么即为:user表中的所有记录条数,所以为5条,job表中的值都为null
(2)右连接
　　同左连接,这里就不赘述了
全外连接
　　mysql不支持
总结:左右连接是否产生笛卡尔积,和on的条件是否为唯一索引没有关系,只和左表、右表两者各自匹配on条件的记录条数有关系( 左连接和右连接可以这么做:1:由INNER JOIN查询全匹配记录;2:查询左表或者右表没有符合on条件的记录;3.全匹配记录+没有匹配上的记录就是左连接或者右连接查询的结果集 )
1.全匹配:
无论哪种查询,首先计算出on匹配记录(FROM user INNER JOIN job ON ...或者使用 FROM user,job where...),匹配记录的查询结果为:若A表有m条记录,符合on查询条件的为m1条,B表有n条记录,符合on条件的为n1条,那么匹配记录为MAX(m1,n1);
2.左连接:
结果集为: MAX(m1,n1)+(m-m1);
如果m1 > n1,则不会产生笛卡尔积,因为无论不匹配的记录(m-m1),还是匹配的记录MAX(m1,n1),都是从左表中取记录,所以不会出现重复的记录;反之,如果m1 < n1,则一定会产生笛卡尔积,因为MAX(m1,n1)是从右表中取的,而根据笛卡尔积的原理,右表中的每条记录都会和左表中的所有记录匹配一次,所以符合on条件的n1条记录也一定会和左表中的所有记录都匹配一次,而左表中符合记录只有m1条,所以造成笛卡尔积的条数为(n1-m1)条
即用内连接的记录(MAX(m1,n1)),加上左表没有满足on条件的记录(m-m1 ),所以为:MAX(m1,n1)+(m-m1);
3.有连接
结果集为:MAX(m1,n1)+(n-n1);
如果m1 < n1,则不会产生笛卡尔积,因为无论不匹配的记录(n-n1),还是匹配的记录MAX(m1,n1),都是从右表中取记录,所以不会出现重复的记录;反之,如果m1 > n1,则一定会产生笛卡尔积,因为MAX(m1,n1)是从左表中取的,所以造成笛卡尔积的记录条数为(m1-n1)条
即用内连接的记录(MAX(m1,n1)),加上右表没有满足on条件的记录(n-n1 ),所以为:MAX(m1,n1)+(n-n1) ;
下面再来谈下:
Mysql：ON 与 WHERE 的区别
很多同学在学习 Mysql 表关联的时候弄不清 ON 与 WHERE 的区别,不知道条件应该写在 ON 里面还是 WHERE 里面,作者在工作的时候也入过坑,总觉得条件写在哪里查询结果都是一样的,最后出错坏了事,差点惹了大祸。所以今天简单易懂的总结一下他们的区别,大家共同学习。
准备工作
我们先准备两个表,并造一些数据：
表t1: CREATE TABLE `t1` ( `id` BIGINT(20) NOT NULL DEFAULT '0' COMMENT '主键id', `name` CHAR(100) NOT NULL DEFAULT '' COMMENT '姓名', `age` INT(11) NOT NULL DEFAULT '0' ) ENGINE=INNODB DEFAULT CHARSET=utf8; INSERT INTO `t1`(`id`,`name`,`age`) VALUES (1,'C罗',33),(2,'梅西',31),(3,'内马尔',29);
表t2: CREATE TABLE `t2` ( `id` BIGINT(20) NOT NULL DEFAULT '0' COMMENT '主键id', `goals` INT(11) NOT NULL DEFAULT '0' COMMENT '进球数', `matches` INT(11) NOT NULL DEFAULT '0' COMMENT '比赛编号' ) ENGINE=INNODB DEFAULT CHARSET=utf8; INSERT INTO `t2`(`id`,`goals`,`matches`) VALUES (1,3,1),(1,5,2),(2,0,1),(2,8,2);
查询结果如图:
表t1记录:
表t2记录:
探究
口诀：先执行 ON ,后执行 WHERE ； ON 是建立关联关系, WHERE 是对关联关系的筛选 。
记住这句话就可以准确地判断查询结果了,我们通过两个 sql 来进行分析：
SQL1 : SELECT t1.id,t2.id,t1.name,t1.age,t2.`matches` FROM t1 LEFT JOIN t2 ON t1.id = t2.id WHERE matches = 2; -- 条件放在 WHERE
前提是 LEFT JOIN ,所以左边的数据在创建关联关系时会保留,根据口诀,先执行 ON 建立关联关系,形成子表,最后在子表中通过 WHERE 筛选,过程如下：
左表符合记录的t1.id = t2.id的记录有2条,右表符合记录的有4条,所以MAX(m1,n1)为4条,其中左表没有符合on条件的记录为(3-2=1)条,所以LEFT JOIN的结果总共有5条,最后一条左表没有匹配上右表记录,所以右表的属性都为null,如下:
但是最终结果从5条记录中再通过where进行筛选,即matches为2,所以结果只有2条( 注意先LEFT JOIN,然后再是where,所以此时5条记录中不符合where条件的记录会被排除,即最终的结果不再是左表所有的记录 ):

SQL2: SELECT t1.id,t2.id,t1.name,t1.age,t2.`matches` FROM t1 LEFT JOIN t2 ON t1.id = t2.id AND matches = 2; -- 条件放在 ON
SQL2没有 WHERE ,那么 ON 建立的关联关系就是最终结果(因为没有where条件进行最终筛选,所有最终结果为内联记录加上左表中没有符合on条件的记录)：
符合ON条件的记录,改为内联INNER JOIN ,查询基础数据: MAX(m1,n1) SELECT t1.id,t2.id,t1.name,t1.age,t2.`matches` FROM t1 INNER JOIN t2 ON t1.id = t2.id AND matches = 2;
所以 MAX(m1,n1)为2条, 结果为:
再由基础数据加上左表没有匹配上的记录数(只有id为3的没有匹配上,即 (n-n1) = 1 )只有1条,所以最终结果为:
最终结果为: MAX(m1,n1)+(m-m1) = 2 + (id为3的记录) = 3条
通过这两个 sql 可以很好的区分 WHERE 和 ON 的区别了,希望大家使用的时候多注意这一点,避免犯错！
逻辑上一个query的执行顺序（不是实际）
1. FROM
2. ON
3. JOIN
4. WHERE
5. GROUP BY
6. WITH CUBE or WITH ROLLUP
7. HAVING
8. SELECT
9. DISTINCT
10. ORDER BY
11. TOP
说是“逻辑上” 顺序,因为实际执行时还要看索引,数据分布等,看最终优化器如何处理,最真实的顺序肯定是执行计划展示的顺序。
QL语句中join连表时on和where后都可以跟条件,那么对查询结果集,执行顺序,效率是如何呢？
通过查询资料发现：
区别：
on是对中间结果进行筛选,where是对最终结果筛选。
执行顺序：
先进行on的过滤, 而后才进行join。
效率：
如果是inner join, 放on和放where产生的结果一样, 但没说哪个效率速度更高? 如果有outer join (left or right), 就有区别了, 因为on生效在先, 已经提前过滤了一部分数据, 而where生效在后.
最后来了解下T-SQL对查询逻辑处理。
T-SQL逻辑查询的各个阶段( 编号代表顺序 )：
(5)SELECT DISTINCT TOP()
(1)FROM JOIN ON
(2)WHERE
(3)GROUP BY
(4)HAVING
(6)ORDER BY
T-SQL在查询各个阶级分别干了什么：
（1）FROM 阶段
FROM阶段标识出查询的来源表,并处理表运算符。在涉及到联接运算的查询中（各种join）,主要有以下几个步骤：
　　 a.求笛卡尔积 。 不论是什么类型的联接运算,首先都是执行交叉连接 （cross join）,求笛卡儿积,生成虚拟表VT1-J1。
b.ON筛选器 。这个阶段对上个步骤生成的VT1-J1进行筛选,根据ON子句中出现的谓词进行筛选,让谓词取值为true的行通过了考验,插入到VT1-J2。
c.添加外部行 。如果指定了outer join,还需要将VT1-J2中没有找到匹配的行,作为外部行添加到VT1-J2中,生成VT1-J3。
经过以上步骤,FROM阶段就完成了。概括地讲,FROM阶段就是进行预处理的,根据提供的运算符对语句中提到的各个表进行处理（除了join,还有apply,pivot,unpivot）
（2）WHERE阶段
WHERE阶段是根据中条件对VT1中的行进行筛选,让条件成立的行才会插入到VT2中。
（3）GROUP BY阶段
GROUP阶段按照指定的列名列表,将VT2中的行进行分组,生成VT3。最后每个分组只有一行。
（4）HAVING阶段
该阶段根据HAVING子句中出现的谓词对VT3的分组进行筛选,并将符合条件的组插入到VT4中。
（5）SELECT阶段
　　这个阶段是投影的过程,处理SELECT子句提到的元素,产生VT5。这个步骤一般按下列顺序进行
a.计算SELECT列表中的表达式,生成VT5-1。
b.若有DISTINCT,则删除VT5-1中的重复行,生成VT5-2
c.若有TOP,则根据ORDER BY子句定义的逻辑顺序,从VT5-2中选择签名指定数量或者百分比的行,生成VT5-3
（6）ORDER BY阶段
根据ORDER BY子句中指定的列明列表,对VT5-3中的行,进行排序,生成游标VC6.
如果是inner join, 放on和放where产生的结果一样, 执行计划也是一样, 但推荐使用on 。但如果有outer join (left or right), 就有区别了, 因为on生效在先, 已经提前过滤了一部分数据, 而where生效在后,而且where对于outer join有不生效的情况
使用left join时on后面的条件只对右表有效 on是在生成临时表的时候使用的条件,不管on的条件是否起到作用,都会返回左表 (table_name1) 的行。 where则是在生成临时表之后使用的条件,此时已经不管是否使用了left join了,只要条件不为真的行,全部过滤掉。

「深度学习福利」大神带你进阶工程师,立即查看>>>
在8版本以后的MySql默认的加密方式都改为了caching_sha2_password
因此进入mysql的命令行更改加密方式即可
ALTER USER 'root'@'localhost' IDENTIFIED BY 'password' PASSWORD EXPIRE NEVER; #更改加密方式

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '新密码'; #更新用户密码

FLUSH PRIVILEGES; #刷新权限

「深度学习福利」大神带你进阶工程师,立即查看>>>
5月21日,阿里云PolarDB发布重大更新,提供传统数据库一键迁移上云能力,可以帮助企业将线下的MySQL、PostgreSQL和Oracle等数据库轻松上云,最快数小时内迁移完成。据估算,云上成本不到传统数据库的1/6。目前,已有约40万个数据库迁移到阿里云上。
阿里云方面表示,该产品实现了两大技术突破：通过自研超低延迟文件系统PolarFS大幅降低数据跨网络的延迟,并且开发了一种全新的共识协议ParallelRaft,提升系统吞吐量。在此之前,PolarFS的研究成果已发表在数据库顶级会议 VLDB 2018 《PolarFS: An Ultra-low Latency and Failure Resilient Distributed File System for Shared Storage Cloud Database》。

企业在使用传统商业数据库时,经常会面临授权费用贵、硬件成本高、架构与运维复杂、迁移难度大等问题,此次云原生数据库PolarDB的重大更新针对此类痛点,实现一键快速迁移,并提供云上的完整生态服务。
此外,产品还具备三大亮点,满足企业在数字时代海量的数据存储需求：1、单实例规格最大达88核710GB；2、业内最快单节点读写速度100万QPS；3、实现三份数据存储实时同步0延迟。除性能领先外,云上数据库成本也低于传统数据库,不到后者的1/6。
PolarDB是阿里云在2018年正式商业化的云原生数据库,采用存储计算分离、软硬一体化设计,具备快速弹性能力、超大规格、超高可靠性以及两倍于AWS Aurora的性能。目前已是阿里云上增长最快的数据库产品。
随着移动互联网、物联网的发展,数据量剧增。企业上云也成大势所趋,企业上云意愿达84%,云也对数据库提出了更高的扩展性和可用性要求。
因昂贵、扩展性差、技术复杂、迭代慢,传统商业数据库饱受诟病。与传统数据库相反,云原生数据库天然拥有云计算的弹性能力,兼具开源数据库的易用、开放特点,及传统数据库的管理和处理性能优势,是云时代下企业数据库的最佳选择。
在全球范围内,一场替换传统数据库的行动正在进行。早在2013年,阿里巴巴就将最后一台Oracle数据库从其淘宝核心系统中下线。亚马逊也公开表示,将在2020年彻底放弃Oracle数据库。
阿里云智能数据库事业部负责人李飞飞表示,云原生数据库在成本、灵活度、安全、技术进化层面都优于传统数据库,传统数据库会像马车一样被淘汰。
阿里云拥有国内最丰富的云数据库产品,目前已有约40万个数据库迁移到阿里云上,涵盖金融、电信、制造、物流等领域的龙头企业。在Gartner发布的2018年数据库魔力象限中,阿里云是国内首个进入挑战者象限的中国公司。
阿里云数据库的技术研究也在国际上崭露头角。PolarDB相关论文入选今年的国际顶级数据库会议SIGMOD,这是阿里云数据库连续第二年入选该学术会议。
作者：阿里云头条
原文链接 ​
本文为云栖社区原创内容,未经允许不得转载。

「深度学习福利」大神带你进阶工程师,立即查看>>>
问题现象:
报警文件中一直在报下面的错误:
Thu Jul 26 23:04:42 2012
Errors in file /u01/app/oracle/diag/rdbms/orcl/orcl/trace/orcl_j000_31365.trc:
ORA-12012: 自动执行作业 23 出错
ORA-12005: 不能安排过去时间的自动刷新
Thu Jul 26 23:06:42 2012
Errors in file /u01/app/oracle/diag/rdbms/orcl/orcl/trace/orcl_j000_31383.trc:
ORA-12012: 自动执行作业 23 出错
ORA-12005: 不能安排过去时间的自动刷新
Thu Jul 26 23:10:43 2012
Errors in file /u01/app/oracle/diag/rdbms/orcl/orcl/trace/orcl_j000_31417.trc:
ORA-12012: 自动执行作业 23 出错
ORA-12005: 不能安排过去时间的自动刷新
Thu Jul 26 23:18:43 2012
Errors in file /u01/app/oracle/diag/rdbms/orcl/orcl/trace/orcl_j000_31478.trc:
ORA-12012: 自动执行作业 23 出错
ORA-12005: 不能安排过去时间的自动刷新
Thu Jul 26 23:34:44 2012
Errors in file /u01/app/oracle/diag/rdbms/orcl/orcl/trace/orcl_j000_31614.trc:
ORA-12012: 自动执行作业 23 出错
ORA-12005: 不能安排过去时间的自动刷新
问题解决:
该问题应该是job执行后,计算job的下一个执行时间时,发现比当前的时间还早,就报这个错误:
检查23号job
select job,last_date,next_date,interval from dba_jobs;
23 2012-7-28 0:06:47 00:06:47 2012-7-28 23:04:37 23:04:37 (trunc(sysdate)+25/26)
主要为这个间隔时间为 (trunc(sysdate)+25/26)
select (trunc(sysdate)+25/26) from dual;
这个时间为当天的 23:04:37 ,所以无法执行
修改为'trunc(sysdate)+25/24'即可.
具体修改过程为:
Execute DBMS_JOB.INTERVAL (23, 'trunc(sysdate)+25/24');

「深度学习福利」大神带你进阶工程师,立即查看>>> Option Explicit ValidationMode = True InteractiveMode = im_Batch Dim mdl ' the current model ' get the current active model Set mdl = ActiveModel If (mdl Is Nothing) Then MsgBox "There is no current Model " ElseIf Not mdl.IsKindOf(PdPDM.cls_Model) Then MsgBox "The current model is not an Physical Data model. " Else ProcessFolder mdl End If ' This routine copy name into comment for each table, each column and each view ' of the current folder Private sub ProcessFolder(folder) Dim Tab 'running table for each Tab in folder.tables if not tab.isShortcut then tab.comment = tab.name Dim col ' running column for each col in tab.columns col.comment= col.name next end if next Dim view 'running view for each view in folder.Views if not view.isShortcut then view.comment = view.name end if next ' go into the sub-packages Dim f ' running folder For Each f In folder.Packages if not f.IsShortcut then ProcessFolder f end if Next end sub

「深度学习福利」大神带你进阶工程师,立即查看>>>
mysql [Err] 1118 - Row size too large (> 8126).
问题
mysql5.7 在执行创建表或者增加字段时,发现row size长度过长,导致出现以下错误。 [Err] 1118 - Row size too large (> 8126). Changing some columns to TEXT or BLOB may help. In current row format, BLOB prefix of 0 bytes is stored inline.
解决方案
row size 其实就是所有字段的长度的总和。 在不进行拆表的前提下解决（我们不讨论是否设计的合理性） ： 知识贴： https://dev.mysql.com/doc/refman/8.0/en/column-count-limit.html You may want to take a look at this article which explains a lot about MySQL row sizes. It's important to note that even if you use TEXT or BLOB fields, your row size could still be over 8K (limit for InnoDB) because it stores the first 768 bytes for each field inline in the page. The simplest way to fix this is to use the Barracuda file format with InnoDB. This basically gets rid of the problem altogether by only storing the 20 byte pointer to the text data instead of storing the first 768 bytes.
方法一：改变一些字段varchar为TEXT or BLOB。 无效,不能解决问题。
最终解决方案
https://stackoverflow.com/questions/22637733/mysql-error-code-1118-row-size-too-large-8126-changing-some-columns-to-te
查询系统参数： show variables like '%innodb_strict_mode%'; show variables like '%innodb_log_file_size%';
修改前： innodb_strict_mode ON innodb_log_file_size 536870912
修改mysql的配置文件, vi /etc/my.cnf innodb_log_file_size=1024M innodb_strict_mode=0
innodb_strict_mode=0 这个一定不能漏,否则不能生效。 重启后： innodb_strict_mode OFF innodb_log_file_size 1073741824
it work 。 卡了很久,最终靠这个方案解决了。

「深度学习福利」大神带你进阶工程师,立即查看>>>
Base Enviroment:CentOS release 6.5 +10.1.40-MariaDB MariaDB Server
安装完后,经过Navicat客户端工具,java web项目,linux操作系统myql客户端,三个维度（客户端）的实测。
实测结果是：此工程只能做到,命令行发起的对数据库的操作。
1.安装mysql-sniffer：
#yum install glib2-devel libpcap-devel libnet-devel
# cd /usr/local/src/
​#git clone https://github.com/Qihoo360/mysql-sniffer #此步较慢,耐心等待……
#cd mysql-sniffer
#mkdir proj
#cd proj
#cmake ../
#make
#cd bin/
2.参数查看
./mysql-sniffer -h Usage ./bin/mysql-sniffer [-d] -i eth0 -p 3306,3307,3308 -l /var/log/mysql-sniffer/ -e stderr [-d] -i eth0 -r 3000-4000 -d daemon mode. -s how often to split the log file(minute, eg. 1440). if less than 0, split log everyday -i interface. Default to eth0 -p port, default to 3306. Multiple ports should be splited by ','. eg. 3306,3307 this option has no effect when -f is set. -r port range, Don't use -r and -p at the same time -l query log DIRECTORY. Make sure that the directory is accessible. Default to stdout. -e error log FILENAME or 'stderr'. if set to /dev/null, runtime error will not be recorded -f filename. use pcap file instead capturing the network interface -w white list. dont capture the port. Multiple ports should be splited by ','. -t truncation length. truncate long query if it's longer than specified length. Less than 0 means no truncation -n keeping tcp stream count, if not set, default is 65536. if active tcp count is larger than the specified count, mysql-sniffer will remove the oldest one
3.执行命令,将mysql3306端口流量打到某网卡上（如 eth0 ）
实时查看>>>>>
# ./bin/mysql-sniffer -i eth0 -p 3306
打到某日志文件>>
# ./bin/mysql-sniffer -i eth0 -p 3306 -l /tmp/mysql-sniffer/
查看网卡
4.查看效果：
mysql服务器启动mysql-sniffer开启实时监控
【方式一：windows电脑使用mysql客户端navicat访问mysql服务器的审计情况】

执行sql语句。
审计控制台并没有回显具体的执行语句,再次更改sql语句,控制台不会在有任何信息显示。
【方式二：java web项目访问数据库,控制台同样没有任何涉及信息】
【方式三：命令行终端】
可以看到完整的审计信息,从登陆数据库到登录后执行的具体sql（查询表,更新表等）审计控制台可以做到完全回显

【审计控制台终端情况如下：】

【源码地址:】
https://github.com/Qihoo360/mysql-sniffer/blob/master/README_CN.md

「深度学习福利」大神带你进阶工程师,立即查看>>>
即使你认为自己已对 MySQL 的 LEFT JOIN 理解深刻,但我敢打赌,这篇文章肯定能让你学会点东西！ ON 子句与 WHERE 子句的不同 一种更好地理解带有 WHERE ... IS NULL 子句的复杂匹配条件的简单方法 Matching-Conditions 与 Where-conditions 的不同
关于 “A LEFT JOIN B ON 条件表达式” 的一点提醒
ON 条件（ “A LEFT JOIN B ON 条件表达式” 中的 ON ）用来决定如何从 B 表中检索数据行。
如果 B 表中没有任何一行数据匹配 ON 的条件,将会额外生成一行所有列为 NULL 的数据
在匹配阶段 WHERE 子句的条件都不会被使用。仅在匹配阶段完成以后, WHERE 子句条件才会被使用。它将从匹配阶段产生的数据中检索过滤。
让我们看一个 LFET JOIN 示例： mysql> CREATE TABLE `product` ( `id` int(10) unsigned NOT NULL auto_increment, `amount` int(10) unsigned default NULL, PRIMARY KEY (`id`) ) ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=latin1 mysql> CREATE TABLE `product_details` ( `id` int(10) unsigned NOT NULL, `weight` int(10) unsigned default NULL, `exist` int(10) unsigned default NULL, PRIMARY KEY (`id`) ) ENGINE=MyISAM DEFAULT CHARSET=latin1 mysql> INSERT INTO product (id,amount) VALUES (1,100),(2,200),(3,300),(4,400); Query OK, 4 rows affected (0.00 sec) Records: 4 Duplicates: 0 Warnings: 0 mysql> INSERT INTO product_details (id,weight,exist) VALUES (2,22,0),(4,44,1),(5,55,0),(6,66,1); Query OK, 4 rows affected (0.00 sec) Records: 4 Duplicates: 0 Warnings: 0 mysql> SELECT * FROM product; +----+--------+ | id | amount | +----+--------+ | 1 | 100 | | 2 | 200 | | 3 | 300 | | 4 | 400 | +----+--------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM product_details; +----+--------+-------+ | id | weight | exist | +----+--------+-------+ | 2 | 22 | 0 | | 4 | 44 | 1 | | 5 | 55 | 0 | | 6 | 66 | 1 | +----+--------+-------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM product LEFT JOIN product_details ON (product.id = product_details.id); +----+--------+------+--------+-------+ | id | amount | id | weight | exist | +----+--------+------+--------+-------+ | 1 | 100 | NULL | NULL | NULL | | 2 | 200 | 2 | 22 | 0 | | 3 | 300 | NULL | NULL | NULL | | 4 | 400 | 4 | 44 | 1 | +----+--------+------+--------+-------+ 4 rows in set (0.00 sec)
ON 子句和 WHERE 子句有什么不同？
一个问题 ：下面两个查询的结果集有什么不同么？ SELECT * FROM product LEFT JOIN product_details ON (product.id = product_details.id) AND product_details.id=2; SELECT * FROM product LEFT JOIN product_details ON (product.id = product_details.id) WHERE product_details.id=2;
用例子来理解最好不过了： mysql> SELECT * FROM product LEFT JOIN product_details ON (product.id = product_details.id) AND product_details.id=2; +----+--------+------+--------+-------+ | id | amount | id | weight | exist | +----+--------+------+--------+-------+ | 1 | 100 | NULL | NULL | NULL | | 2 | 200 | 2 | 22 | 0 | | 3 | 300 | NULL | NULL | NULL | | 4 | 400 | NULL | NULL | NULL | +----+--------+------+--------+-------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM product LEFT JOIN product_details ON (product.id = product_details.id) WHERE product_details.id=2; +----+--------+----+--------+-------+ | id | amount | id | weight | exist | +----+--------+----+--------+-------+ | 2 | 200 | 2 | 22 | 0 | +----+--------+----+--------+-------+ 1 row in set (0.01 sec)
第一条查询使用 ON 条件决定了从 LEFT JOIN的 product_details表中检索符合的所有数据行。
第二条查询做了简单的LEFT JOIN,然后使用 WHERE 子句从 LEFT JOIN的数据中过滤掉不符合条件的数据行。
再来看一些示例： mysql> mysql> SELECT * FROM product LEFT JOIN product_details ON product.id = product_details.id AND product.amount=100; +----+--------+------+--------+-------+ | id | amount | id | weight | exist | +----+--------+------+--------+-------+ | 1 | 100 | NULL | NULL | NULL | | 2 | 200 | NULL | NULL | NULL | | 3 | 300 | NULL | NULL | NULL | | 4 | 400 | NULL | NULL | NULL | +----+--------+------+--------+-------+ 4 rows in set (0.00 sec)
所有来自product表的数据行都被检索到了,但没有在product_details表中匹配到记录（product.id = product_details.id AND product.amount=100 条件并没有匹配到任何数据） mysql> SELECT * FROM product LEFT JOIN product_details ON (product.id = product_details.id) AND product.amount=200; +----+--------+------+--------+-------+ | id | amount | id | weight | exist | +----+--------+------+--------+-------+ | 1 | 100 | NULL | NULL | NULL | | 2 | 200 | 2 | 22 | 0 | | 3 | 300 | NULL | NULL | NULL | | 4 | 400 | NULL | NULL | NULL | +----+--------+------+--------+-------+ 4 rows in set (0.01 sec)
同样,所有来自product表的数据行都被检索到了,有一条数据匹配到了。
使用 WHERE ... IS NULL 子句的 LEFT JOIN
当你使用 WHERE ... IS NULL 子句时会发生什么呢？
如前所述,WHERE 条件查询发生在 匹配阶段之后,这意味着 WHERE ... IS NULL 子句将从匹配阶段后的数据中过滤掉不满足匹配条件的数据行。
纸面上看起来很清楚,但是当你在 ON 子句中使用多个条件时就会感到困惑了。
我总结了一种简单的方式来理解上述情况： 将 IS NULL 作为否定匹配条件 使用 !(A and B) == !A OR !B 逻辑判断
看看下面的示例： mysql> SELECT a.* FROM product a LEFT JOIN product_details b ON a.id=b.id AND b.weight!=44 AND b.exist=0 WHERE b.id IS NULL; +----+--------+ | id | amount | +----+--------+ | 1 | 100 | | 3 | 300 | | 4 | 400 | +----+--------+ 3 rows in set (0.00 sec)
让我们检查一下 ON 匹配子句： (a.id=b.id) AND (b.weight!=44) AND (b.exist=0)
我们可以把 IS NULL 子句 看作是否定匹配条件。
这意味着我们将检索到以下行： !( exist(b.id that equals to a.id) AND b.weight !=44 AND b.exist=0 ) !exist(b.id that equals to a.id) || !(b.weight !=44) || !(b.exist=0) !exist(b.id that equals to a.id) || b.weight =44 || b.exist=1
就像在C语言中的逻辑 AND 和 逻辑 OR表达式一样,其操作数是从左到右求值的。如果第一个参数做够判断操作结果,那么第二个参数便不会被计算求值（短路效果）
看看别的示例： mysql> SELECT a.* FROM product a LEFT JOIN product_details b ON a.id=b.id AND b.weight!=44 AND b.exist=1 WHERE b.id IS NULL; +----+--------+ | id | amount | +----+--------+ | 1 | 100 | | 2 | 200 | | 3 | 300 | | 4 | 400 | +----+--------+ 4 rows in set (0.00 sec)
Matching-Conditions 与 Where-conditions 之战
如果你吧基本的查询条件放在 ON 子句中,把剩下的否定条件放在 WHERE 子句中,那么你会获得相同的结果。
例如,你可以不这样写： SELECT a.* FROM product a LEFT JOIN product_details b ON a.id=b.id AND b.weight!=44 AND b.exist=0 WHERE b.id IS NULL;
你可以这样写： SELECT a.* FROM product a LEFT JOIN product_details b ON a.id=b.id WHERE b.id is null OR b.weight=44 OR b.exist=1;
mysql> SELECT a.* FROM product a LEFT JOIN product_details b ON a.id=b.id WHERE b.id is null OR b.weight=44 OR b.exist=1; +----+--------+ | id | amount | +----+--------+ | 1 | 100 | | 3 | 300 | | 4 | 400 | +----+--------+ 3 rows in set (0.00 sec)
你可以不这样写： SELECT a.* FROM product a LEFT JOIN product_details b ON a.id=b.id AND b.weight!=44 AND b.exist!=0 WHERE b.id IS NULL;
可以这样写： SELECT a.* FROM product a LEFT JOIN product_details b ON a.id=b.id WHERE b.id is null OR b.weight=44 OR b.exist=0;
mysql> SELECT a.* FROM product a LEFT JOIN product_details b ON a.id=b.id WHERE b.id is null OR b.weight=44 OR b.exist=0; +----+--------+ | id | amount | +----+--------+ | 1 | 100 | | 2 | 200 | | 3 | 300 | | 4 | 400 | +----+--------+ 4 rows in set (0.00 sec)
这些查询真的效果一样？
如果你只需要第一个表中的数据的话,这些查询会返回相同的结果集。有一种情况就是,如果你从 LEFT JOIN的表中检索数据时,查询的结果就不同了。
如前所属,WHERE 子句是在匹配阶段之后用来过滤的。
例如： mysql> SELECT * FROM product a LEFT JOIN product_details b ON a.id=b.id AND b.weight!=44 AND b.exist=1 WHERE b.id is null; +----+--------+------+--------+-------+ | id | amount | id | weight | exist | +----+--------+------+--------+-------+ | 1 | 100 | NULL | NULL | NULL | | 2 | 200 | NULL | NULL | NULL | | 3 | 300 | NULL | NULL | NULL | | 4 | 400 | NULL | NULL | NULL | +----+--------+------+--------+-------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM product a LEFT JOIN product_details b ON a.id=b.id WHERE b.id IS NULL OR b.weight=44 OR b.exist=0; +----+--------+------+--------+-------+ | id | amount | id | weight | exist | +----+--------+------+--------+-------+ | 1 | 100 | NULL | NULL | NULL | | 2 | 200 | 2 | 22 | 0 | | 3 | 300 | NULL | NULL | NULL | | 4 | 400 | 4 | 44 | 1 | +----+--------+------+--------+-------+ 4 rows in set (0.00 sec)
总附注：
如果你使用 LEFT JOIN 来寻找在一些表中不存在的记录,你需要做下面的测试：WHERE 部分的 col_name IS NULL (其中 col_name 列被定义为 NOT NULL),MYSQL 在查询到一条匹配 LEFT JOIN 条件后将停止搜索更多行（在一个特定的组合键下）。

「深度学习福利」大神带你进阶工程师,立即查看>>>
窗口-->首选项：
点击“编辑”之后,字体大小设为11的大小即比较合适。

「深度学习福利」大神带你进阶工程师,立即查看>>>
报错信息如下： java.sql.SQLException: Value '0000-00-00 00:00:00' can not be represented as java.sql.Timestamp at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:963) ~[mysql-connector-java-5.1.39.jar:5.1.39] at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:896) ~[mysql-connector-java-5.1.39.jar:5.1.39] at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:885) ~[mysql-connector-java-5.1.39.jar:5.1.39] at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:860) ~[mysql-connector-java-5.1.39.jar:5.1.39] at com.mysql.jdbc.ResultSetRow.getTimestampFast(ResultSetRow.java:937) ~[mysql-connector-java-5.1.39.jar:5.1.39] at com.mysql.jdbc.ByteArrayRow.getTimestampFast(ByteArrayRow.java:130) ~[mysql-connector-java-5.1.39.jar:5.1.39] at com.mysql.jdbc.ResultSetImpl.getTimestampInternal(ResultSetImpl.java:5946) ~[mysql-connector-java-5.1.39.jar:5.1.39] at com.mysql.jdbc.ResultSetImpl.getTimestamp(ResultSetImpl.java:5616) ~[mysql-connector-java-5.1.39.jar:5.1.39] at com.mysql.jdbc.ResultSetImpl.getTimestamp(ResultSetImpl.java:5645) ~[mysql-connector-java-5.1.39.jar:5.1.39] at com.zaxxer.hikari.pool.HikariProxyResultSet.getTimestamp(HikariProxyResultSet.java) ~[HikariCP-2.7.8.jar:na] at org.hibernate.type.descriptor.sql.TimestampTypeDescriptor$2.doExtract(TimestampTypeDescriptor.java:84) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.type.descriptor.sql.BasicExtractor.extract(BasicExtractor.java:47) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.type.AbstractStandardBasicType.nullSafeGet(AbstractStandardBasicType.java:261) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.type.AbstractStandardBasicType.nullSafeGet(AbstractStandardBasicType.java:257) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.type.AbstractStandardBasicType.nullSafeGet(AbstractStandardBasicType.java:253) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.loader.custom.ScalarResultColumnProcessor.extract(ScalarResultColumnProcessor.java:54) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.loader.custom.ResultRowProcessor.buildResultRow(ResultRowProcessor.java:83) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.loader.custom.ResultRowProcessor.buildResultRow(ResultRowProcessor.java:60) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.loader.custom.CustomLoader.getResultColumnOrRow(CustomLoader.java:409) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.loader.Loader.getRowFromResultSet(Loader.java:761) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.loader.Loader.processResultSet(Loader.java:991) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.loader.Loader.doQuery(Loader.java:949) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.loader.Loader.doQueryAndInitializeNonLazyCollections(Loader.java:341) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.loader.Loader.doList(Loader.java:2692) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.loader.Loader.doList(Loader.java:2675) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.loader.Loader.listIgnoreQueryCache(Loader.java:2507) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.loader.Loader.list(Loader.java:2502) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.loader.custom.CustomLoader.list(CustomLoader.java:335) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.internal.SessionImpl.listCustomQuery(SessionImpl.java:2161) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.internal.AbstractSharedSessionContract.list(AbstractSharedSessionContract.java:1016) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.query.internal.NativeQueryImpl.doList(NativeQueryImpl.java:152) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.query.internal.AbstractProducedQuery.list(AbstractProducedQuery.java:1414) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at org.hibernate.query.Query.getResultList(Query.java:146) ~[hibernate-core-5.2.16.Final.jar:5.2.16.Final] at com.jingxuan.dao.AllDaoImpl.getCommodity(AllDaoImpl.java:111) ~[classes/:na] at com.jingxuan.dao.AllDaoImpl$$FastClassBySpringCGLIB$$bb7fcecc.invoke() ~[classes/:na] at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204) ~[spring-core-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:747) ~[spring-aop-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163) ~[spring-aop-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.dao.support.PersistenceExceptionTranslationInterceptor.invoke(PersistenceExceptionTranslationInterceptor.java:139) ~[spring-tx-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:185) ~[spring-aop-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:689) ~[spring-aop-5.0.5.RELEASE.jar:5.0.5.RELEASE] at com.jingxuan.dao.AllDaoImpl$$EnhancerBySpringCGLIB$$c8de7df4.getCommodity() ~[classes/:na] at com.jingxuan.service.impl.AllServiceImpl.getAllCommodity(AllServiceImpl.java:56) ~[classes/:na] at com.jingxuan.controller.AllController.getAllCommodity(AllController.java:41) ~[classes/:na] at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_191] at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_191] at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_191] at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_191] at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:209) ~[spring-web-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:136) ~[spring-web-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:102) ~[spring-webmvc-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:877) ~[spring-webmvc-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:783) ~[spring-webmvc-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:87) ~[spring-webmvc-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:991) ~[spring-webmvc-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:925) ~[spring-webmvc-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:974) ~[spring-webmvc-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:866) ~[spring-webmvc-5.0.5.RELEASE.jar:5.0.5.RELEASE] at javax.servlet.http.HttpServlet.service(HttpServlet.java:635) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:851) ~[spring-webmvc-5.0.5.RELEASE.jar:5.0.5.RELEASE] at javax.servlet.http.HttpServlet.service(HttpServlet.java:742) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:231) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:52) ~[tomcat-embed-websocket-8.5.29.jar:8.5.29] at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.springframework.web.filter.RequestContextFilter.doFilterInternal(RequestContextFilter.java:99) ~[spring-web-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107) ~[spring-web-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.springframework.web.filter.HttpPutFormContentFilter.doFilterInternal(HttpPutFormContentFilter.java:109) ~[spring-web-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107) ~[spring-web-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.springframework.web.filter.HiddenHttpMethodFilter.doFilterInternal(HiddenHttpMethodFilter.java:81) ~[spring-web-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107) ~[spring-web-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:200) ~[spring-web-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107) ~[spring-web-5.0.5.RELEASE.jar:5.0.5.RELEASE] at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:198) ~[tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:96) [tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:496) [tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:140) [tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:81) [tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:87) [tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:342) [tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:803) [tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:66) [tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:790) [tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1459) [tomcat-embed-core-8.5.29.jar:8.5.29] at org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49) [tomcat-embed-core-8.5.29.jar:8.5.29] at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) [na:1.8.0_191] at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) [na:1.8.0_191] at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61) [tomcat-embed-core-8.5.29.jar:8.5.29] at java.lang.Thread.run(Thread.java:748) [na:1.8.0_191]
原因
因为“0000-00-00 00:00:00”在mysql中是作为一个特殊值存在的但 java.sql.Date 将其视为 不合法的值 格式不正确,这才是报错的原因
解决办法 spring: datasource: driver-class-name: com.mysql.jdbc.Driver username: XXXXX password: XXXXX url: jdbc:mysql://localhost:3306/XXXXX?characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
在url后面加上 zeroDateTimeBehavior=convertToNull

「深度学习福利」大神带你进阶工程师,立即查看>>>
1. 查询所有字段
select * from 表名；
2. 查询自定字段
select 字段名 from 表名；
3. 查询指定数据
select * from 表名 where 条件；
4. 带关键字IN的查询
select * from 表名 where 条件 [not] in(元素1,元素2)；
5. 带关键词BETWEEN...AND...
select * from 表名 where 条件 [not] between 取值1 and 取值2；
6. 带like的字符匹配查询
like属于常用的比较运算符,实现模糊查询。它有通配符"%"和"_"。
select * from 表名 where 条件 like "%取值%";
在工作中的我们也常用 concat()函数来拼接字段和通配符
select * from 表名 where 条件 like concat('%',取值,'%');
7. 用关键字IS NULL查询空值
select * from 表名 where 条件 is [not] null;
8. 带AND的多条件查询
select * from 表名 where 条件1 and 条件2；
这里的条件可以是上面的任何一种,相当于逻辑运算的&&
9. 带关键词OR的多条件查询
select * from 表名 where 条件1 or 条件2；
相当于逻辑运算的||
10. 用关键词DISTINCT去除结果中的重复行
seelct distinct 字段名 from 表名;
11. 用关键词ORDER BY对查询结果进行排序
select * from 表名 order by 字段 [ASC|DESC];
12. 用关键词GROUP BY分组查询
select * from 表名 group by 字段；
可以多字段分组,但是会对后面的字段分组,再对前面的字段细微分组
13. 用关键词LIMIT限制查询结果的数量 看前面n条数据
select * from 表名 limit n; 看从m开始的n条数据(下标从0开始)
select * from 表名 limit m,n;
14. 聚合函数 count() 统计个数 sum() 某个字段的总数（null值除外） avg() 某个字段的平均值 max() 某个字段最大值 min() 某个字段最小值
15. 链接查询 内连接查询
内连接查询其实就是我们平常的多表查询 外连接查询
外连接包含左外连接（left join）和右外连接(right join)。
左外连接：将坐标的所有数据分别与右表中的每条数据进行连接组合,返回结果除内连接数据外还有左表不符合条件的数据,并在右表的相应列添加null值。 ps:内连接和外连接最大的区别就是内链接查询将会把两张表条件为null或者另一张表不存在的不显示,而外连接是会将左表或者右表都显示。
16. 子查询
子查询就是select查询的是另一个查询的附属。 带关键字IN的子查询 带比较运算符的子查询 带关键字EXISTS的子查询
关键字EXISTS时,内层查询语句不返回查询记录。而是返回一个真假值。
例如：select * from tb_row where exists (select * from tb_book where id=27);
这里是查询tb_book表中存在id值为27是否存在,存在则查询tb_row的所有行。 带关键字ANY的子查询
关键字ANY表示满足其中任意一个查询条件。
例如：select * from tb_book where row < ANY(select row from tb_row);
表示查询tb_book表中row比tb_row中任何row都小的行数据。 带关键字ALL的子查询
关键字ALL表示满足所有的条件。使用关键字ALL时,只满足 内层查询语句返回的所有结果才能执行外层查询语句。 例如：select * from tb_book where row>=ALL(select row from tb_row);
表示查询tb_book表中row字段的值大于tb_row表中的row字段的最大值的记录。
17. 合并查询结果 union union all ps:union和union all的差别就是union会去除相同的记录,而union all会知识简单的把结果合并到一起。
18. 定义表和字段的别名 为表取别名
可以使用 直接在真表名和别名之间加一个空格。 为字段取别名
可以使用空格或者 as 关键字。
19. 使用正则表达式查询 字段名 regexp '匹配方式'
模式字符 含义 应用举例