'I\'m \"OK\"!'

I'm "OK"!

>>> print('I\'m ok.')
I'm ok.
>>> print('I\'m learning\nPython.')
I'm learning
Python.
>>> print('\\\n\\')
\
\

>>> print('\\\t\\')
\       \
>>> print(r'\\\t\\')
\\\t\\

>>> print('''line1
... line2
... line3''')
line1
line2
line3

┌────────────────────────────────────────────────────────┐
│Command Prompt - python                           _ □ x │
├────────────────────────────────────────────────────────┤
│>>> print('''line1                                      │
│... line2                                               │
│... line3''')                                           │
│line1                                                   │
│line2                                                   │
│line3                                                   │
│                                                        │
│>>> _    

print('''line1
line2
line3''')

# -*- coding: utf-8 -*-

print(r'''hello,\n
world''')

>>> True
True
>>> False
False
>>> 3 > 2
True
>>> 3 > 5
False

>>> True and True
True
>>> True and False
False
>>> False and False
False
>>> 5 > 3 and 3 > 1
True

>>> True or True
True
>>> True or False
True
>>> False or False
False
>>> 5 > 3 or 1 > 3
True

>>> not True
False
>>> not False
True
>>> not 1 > 2
True

if age >= 18:
    print('adult')
else:
    print('teenager')

a = 1

t_007 = 'T007'

Answer = True

# -*- coding: utf-8 -*-

a = 123 # a是整数
print(a)
a = 'ABC' # a变为字符串
print(a)

int a = 123; // a是整数类型变量
a = "ABC"; // 错误：不能把字符串赋给整型变量

x = 10
x = x + 2

a = 'ABC'

# -*- coding: utf-8 -*-

a = 'ABC'
b = a
a = 'XYZ'
print(b)

PI = 3.14159265359

>>> 10 / 3
3.3333333333333335

>>> 9 / 3
3.0

>>> 10 // 3
3

>>> 10 % 3
1

# print absolute value of an integer:
a = 100
if a >= 0:
    print(a)
else:
    print(-a)

git init

git init [project-name]

git clone [url]

git config --list

git config -e [--global] 

git config [--global] user.name "[name]"

git config [--global] user.email "[email address]"

git add [file1] [file2] ...

git add .

git rm [file1] [file2] ...

git rm --cached [file]

git commit -m [message]

git commit [file1] [file2] ... -m [message]

git commit --amend [file1] [file2] ...

git branch

git branch -r

git branch -a

git branch [branch-name]

git checkout -b [branch]

git checkout [branch-name]

git merge [branch]

git branch -d [branch-name]

git push origin --delete [branch-name]
或者 
git branch -dr [remote/branch]

git status

git log

git log --pretty=oneline

git diff

git diff --shortstat "@{0 day ago}"

git tag

git tag -a v0.5.0 -m 'version 0.5.0'

git show v0.5.0

git push origin [tagname]

eg:
git push origin v1.0  #将本地v1.0的tag推送到远端服务器

git push origin --tags

git tag -d [tagName]

git push origin :refs/tags/[tagName]

git fetch [remote]

git remote -v

git pull [remote] [branch]

git push [remote] [branch]

git push [remote] --force

git push [remote] --all

export GIT_SSL_NO_VERIFY=true 

echo 'export GIT_SSL_NO_VERIFY=true' >> ~/.bashrc 

git config --global http.sslVerify false

git checkout [file]

git checkout [commit] [file]

git checkout .

git reset [file]

git reset --hard

git reset --hard [commitId]

rm -rf .git
git init
git add . 
git commit -a 'git init  first commit'
git remote add origin <github_repo_url>
git push -f -u origin master

cd existing_folder
git init
git remote add origin git@git.sg-ai.com:ywguo/Test.git
git add .
git commit -m "Initial commit"
git push -u origin master

git config --global user.name [username]
git config --global user.email [email]

echo "[credential]" >> .git/config
echo "    helper = store" >> .git/config

ubuntu@VM-7-212-ubuntu:~/kernel-code/kernel-netfilter-sample-code$ vim .git/config

##修改成如下

[core]
    repositoryformatversion = 0
    filemode = true
    bare = false
    logallrefupdates = true
[remote "origin"]
    url = https://github.com/Miss-you/kernel-netfilter-sample-code.git
    fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
    remote = origin
    merge = refs/heads/master
##主要是后面这两行，如果不想保存，则删除即可
[credential]
    helper = store

##保存

# set socks proxy
git config --global http.proxy socks5://127.0.0.1:1080
git config --global https.proxy socks5://127.0.0.1:1080

# set http proxy
git config --global http.proxy http://127.0.0.1:8001
git config --global https.proxy https://127.0.0.1:1080


# unset
git config --global --unset http.proxy
git config --global --unset https.proxy

git commit -m [description]

git merge [branch]
git push [remote] [branch]
git branch -d [branch-name]
git push origin --delete [branch-name]

git commit -m ["description"]

git push [remote] [branch]

1. 检查命令行是否出现 `error` 字样的内容，如果出现请及时修改
2. 浏览器上按 `F12` 或者 `右键 -> 检查(N)` 查看`console` 输出是否有明显的 `404 500` 错误，如果有请及时解决

$ yum install openldap* migrationtools -y

$ slappasswd
New password:
Re-enter new password:
{SSHA}b28RwTpbqZ5/kxro785tKExdK4uyOX7T  ///此密码自行妥善保存

$ cd /etc/openldap/slapd.d/cn=config

$ vim olcDatabase={2}hdb.ldif

替换dc=my-domain,dc=com
olcSuffix: dc=sg-ai,dc=com
olcRootDN: cn=Manager,dc=sg-ai,dc=com
在文档底部加上：
olcRootPW: {SSHA}b28RwTpbqZ5/kxro785tKExdK4uyOX7T
olcTLSCertificateFile: /etc/pki/tls/certs/sg-ai.pem
olcTLSCertificateKeyFile: /etc/pki/tls/certs/sg-aikey.pem 

$ vim olcDatabase={1}monitor.ldif

$ slaptest -u

 5737a49a ldif_read_file: checksum error on "/etc/openldap/slapd.d/cn=config/olcDatabase={1}monitor.ldif"
 5737a49a ldif_read_file: checksum error on "/etc/openldap/slapd.d/cn=config/olcDatabase={2}hdb.ldif"
config file testing succeeded

$ systemctl start slapd

$ systemctl enable slapd

cp /usr/share/openldap-servers/DB_CONFIG.example /var/lib/ldap/DB_CONFIG
chown -R ldap:ldap /var/lib/ldap/

$ ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/openldap/schema/cosine.ldif
SASL/EXTERNAL authentication started
$ ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/openldap/schema/nis.ldif
$ ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/openldap/schema/inetorgperson.ldif

openssl req -new -x509 -nodes -out /etc/pki/tls/certs/sg-ai.pem -keyout /etc/pki/tls/certs/sg-aikey.pem -days 365

Generating a 2048 bit RSA private key
...........................................+++
.............................................................................................................+++
writing new private key to '/etc/pki/tls/certs/linuxhelpkey.pem'
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
Country Name (2 letter code) [XX]:
State or Province Name (full name) []:
Locality Name (eg, city) [Default City]:
Organization Name (eg, company) [Default Company Ltd]:sgkj
Organizational Unit Name (eg, section) []:sg
Common Name (eg, your name or your server's hostname) []:master.sg-ai.com
Email Address []: 

ls -l /etc/pki/tls/certs/*.pem

$ cd /usr/share/migrationtools/
$ vim migrate_common.ph

vim /root/base.ldif

dn: dc=sg-ai,dc=com
objectClass: top
objectClass: dcObject
objectclass: organization
o: sg-ai com
dc: sg-ai

dn: cn=Manager,dc=sg-ai,dc=com
objectClass: organizationalRole
cn: Manager
description: Directory Manager

dn: ou=People,dc=sg-ai,dc=com
objectClass: organizationalUnit
ou: People

dn: ou=Group,dc=sg-ai,dc=com
objectClass: organizationalUnit
ou: Group

$ useradd test003
$ useradd test004
$ passwd test003
$ passwd test003

$ tail /etc/passwd >>  /root/passwd
$ vim /root/passwd
test003:x:1001:1001::/home/test003:/bin/bash
test004:x:1002:1002::/home/test004:/bin/bash

$ tail /etc/group >>/root/group
$ vim /root/group
test003:x:1001:
test004:x:1002:

$ ./migrate_passwd.pl /root/passwd /root/users.ldif
$ ./migrate_group.pl /root/group /root/groups.ldif

$ ldapadd -x -W -D "cn=Manager,dc=sg-ai,dc=com" -f /root/base.ldif
$ ldapadd -x -W -D "cn=Manager,dc=sg-ai,dc=com" -f /root/users.ldif
$ ldapadd -x -W -D "cn=Manager,dc=sg-ai,dc=com" -f /root/groups.ldif

$ ldapsearch -x cn=test003 -b dc=example,dc=com
$ ldapsearch -x -b 'dc=sg-ai,dc=com' '(objectclass=*)'

yum install openldap-clients nss-pam-ldapd authconfig -y

$ authconfig-tui

User Information ???????Authentication
[ ] Cache Information ??[ ] Use MD5 Passwords
[*] Use LDAP ????????????[*] Use Shadow Passwords
[ ] Use NIS ???????????????[*] Use LDAP Authentication
[ ] Use IPAv2 ???????????[ ] Use Kerberos
[ ] Use Winbind ????????[ ] Use Fingerprint reader
[ ] Use Winbind Authentication
[*] Local authorization is sufficient

 
- 选中Use LDAP  和 Use LDAP Authentication即可
用Tab键切换到Next，回车。


[*] Use TLS
Server: ldap://master
Base DN: dc=sg-ai,dc=com

getent passwd test003

curl -O https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-3.0.6.tgz    # 下载
tar -zxvf mongodb-linux-x86_64-3.0.6.tgz                                   # 解压

mv  mongodb-linux-x86_64-3.0.6/ /usr/local/mongodb                         # 将解压包拷贝到指定目录

export PATH=/usr/local/mongodb/bin:$PATH

docker pull mongodb:3.4
docker run --name mongodb-dev -p 27017:27017 -v /srv/monggo/mongodb:/data/db -e MONGO_INITDB_ROOT_USERNAME=admin -e MONGO_INITDB_ROOT_PASSWORD=password -d mongo:3.4

docker exec -it mongodb-dev bash
    mongo
        use admin 
        db.auth('admin','password')
    exit
exit

# 切换到admin database
use admin

# auth
db.auth("admin", "sg-ai")

# show database name
show dbs
show tables
show collections
db.tablename.find()
db.tablename.find([query] , [fields])
db.tablename.find({},{})
db.tablename.find({},{"pid": 1, "id": 1})
db.mytable1.find({"userName": "superman"},{})
db.mytable1.remove({"userName": "superman"},{})
db.mytable2.find()

# createUser and backup
db.createUser({ "user" : "alex", "pwd" : "superman", "roles" : [  { role: "readWrite", db: "finance" } ] })
# mongodump --authenticationDatabase=databasename -u alex -p superman -d tablename -o /data/db/backup

git clone -b master --depth 1 https://github.com/mrvautin/adminMongo.git
cd adminMongo && npm install
npm start

mongodump --authenticationDatabase=database -u username -p password -d auth-database -o /data/db/backup

mongorestore --drop -u admin -p superman --authenticationDatabase=admin -d mydatabase /data/db/backup/mydata

memcached：

    memcached is a high-performance, distributed memory object caching system, generic in nature, but intended for use in speeding up dynamic web applications by alleviating database load.


    缓存服务器：
        缓存：cache，无持久存储功能；
        bypass缓存
        k/v cache，仅支持存储流式化数据；
        
    LiveJournal旗下的Danga Interactive研发，
    
        特性：
            k/v cache：仅可序列化数据；存储项：k/v；
            智能性一半依赖于客户端（调用memcached的API开发程序），一半依赖于服务端；
            分布式缓存：互不通信的分布式集群；
                分布式系统请求路由方法：取模法，一致性哈希算法；
            算法复杂度：O(1)
            清理过期缓存项：
                缓存耗尽：LRU 
                缓存项过期：惰性清理机制
            
    安装配置：
        由CentOS 7 base仓库直接提供：
            监听的端口：
                11211/tcp, 11211/udp 
                
        主程序：/usr/bin/memcached
        配置文件：/etc/sysconfig/memcached
        Unit File：memcached.service 
        
        协议格式：memcached协议
            文本格式
            二进制格式
            
        命令：
            统计类：stats, stats items, stats slabs, stats sizes
            存储类：set, add, replace, append, prepend
                命令格式：<command name> <key> <flags> <exptime> <bytes>  
                <cas unique>
            检索类：get, delete, incr/decr
            清空：flush_all
            
            示例：
                telnet> add KEY <flags> <expiretime> <bytes> \r
                telnet> VALUE
                
        memcached程序的常用选项：
            -m <num>：Use <num> MB memory max to use for object storage; the default is 64 megabytes.
            -c <num>：Use <num> max simultaneous connections; the default is 1024.
            -u <username>：以指定的用户身份来运行进程；
            -l <ip_addr>：监听的IP地址，默认为本机所有地址；
            -l <ip_addr>：监听的IP地址，默认为本机所有地址；
            -p <num>：监听的TCP端口， the default is port 11211.
            -U <num>：Listen on UDP port <num>, the default is port 11211, 0 is off.
            -M：内存耗尽时，不执行LRU清理缓存，而是拒绝存入新的缓存项，直到有多余的空间可用时为止；
            -f <factor>：增长因子；默认是1.25；
            -t <threads>：启动的用于响应用户请求的线程数；
            
        memcached默认没有认证机制，可借用于SASL进行认证；
            SASL：Simple Authentication Secure Layer
            
        API:
            php-pecl-memcache
            php-pecl-memcached
            python-memcached
            libmemcached
            libmemcached-devel
            
        命令行工具：
            memcached-tool  SERVER:PORT  COMMAND

使用`printf()`

某些人用过了才知道[^注释]
[^注释]:Somebody that I used to know.

|姓名|性别|毕业学校|工资|
|:---|:---:|:---:|---:|
|杨洋|男|重庆交通大学|3200|
|峰哥|男|贵州大学|5000|
|坑货|女|北京大学|2000|

$$\mathbf{V}_1 \times \mathbf{V}_2 =  \begin{vmatrix} \mathbf{i} & \mathbf{j} & \mathbf{k} \\\frac{\partial X}{\partial u} &  \frac{\partial Y}{\partial u} & 0 \\\frac{\partial X}{\partial v} &  \frac{\partial Y}{\partial v} & 0 \\\end{vmatrix}$$

- [ ] 吃饭
- [ ] 逛街
- [ ] 看电影
- [ ] 约泡

**无序的列表**
* tfboys
* 杨洋
* 我爱你

**有序的列表**
1. 苹果
6. 香蕉
10. 我都不喜欢

>这是一个块引用！

docker run -v /mnt/mariadb:/var/lib/mysql --name mariadb -e MYSQL_ROOT_PASSWORD=alex -p 3306:3306 -d mariadb:5.5.60

MariaDB or MySQL：
    
    层次模型 --> 网状模型 --> (Codd) 关系模型
    
    DBMS --> RDBMS
    
    CRUD：Insert, Select, Update, Delete
    
    RDBMS：
        范式：第一范式、第二范式、第三范式；
        
        表：row, column；
        
        关系运算：
            选择
            投影
            连接
            
        数据库：表、索引、视图（虚表）、SQL、存储过程、存储函数、触发器、事件调度器；
            DDL：CREATE，ALTER，DROP
            DML：INSERT/UPDATE/DELETE/SELECT
        
        约束：
            主键约束：惟一、非空；一张表只能有一个；PRIMARY KEY;
            惟一键约束：惟一，可以存在多个；UNIQUE KEY;
            外键约束：参考性约束；FOREIGN KEY; 
            检查性约束：check；
            
        三层模型：
            物理层 --> SA
            逻辑层 --> DBA
            视图层 --> Coder
            
        实现：
            Oracle, DB2, Sybase, Infomix, SQL Server；
            MySQL, MariaDB, PostgreSQL, SQLite；
            
    MySQL：
        2000, 开源，GPL；
        2001, InnoDB, 支持事务，支持行级锁；MySQL 4.0
        2005, MySQL 5.0，游标、存储过程、触发器、视图和事务；
        
        MariaDB：5.5.x --> 10.x
        
        特性：
            插件式存储引擎
            单进程多线程
                        
        安装MySQL：
            OS Vendor：rpm 
            MySQL：
                source code：cmake
                binary package：
                    i686, x86_64; 
                    glibc VERSION
                prepackage：rpm, deb
                    os, arch, 
                    
            服务端程序：
                mysqld, mysqld_safe, mysqld_multi
            客户端程序：
                mysql, mysqldump, mysqlbinlog, mysqldmin, ...
            非客户端类程序：
                myisamchk, myisampack, ...
                
            ini风格的配置文件，为多个程序同时提供配置；
        
        配置文件：
            读取多处的多个配置文件，而且会以指定的次序的进行； 
            
            # my_print_defaults
            
                Default options are read from the following files in the given order:
                /etc/mysql/my.cnf  /etc/my.cnf ~/.my.cnf 
                
                不同的配置文件中出现同一参数且拥有不同值时，后读取将为最终生效值； 
                
                修改默认读取的配置文件（mysqld_safe命令）：
                     --defaults-file=file_name
                    
                于读取的默认配置文件之外再加载一个文件：    
                    --defaults-extra-file=path
                                    
            配置文件格式：ini风格的配置文件，能够为mysql的各种应用程序提供配置信息：
                [mysqld]
                [mysqld_safe]
                [mysqld_multi]
                [server]
                [mysql]
                [mysqldump]
                [client]
                ...
                
                    PARAMETER = VALUE 
                    
                    PARAMETER：
                        innodb_file_per_table
                        innodb-file-per-table 
                        
            程序文件：
                服务端程序：mysqld_safe, mysqld_multi
                客户端程序：mysql, mysqldump, mysqladmin
                工具程序：myisampack, ...
                
            mysql --> mysql protocol --> mysqld 
                mysql：交互式CLI工具；命令化运行；
                
                mysql [options] db_name
                    
                    常用选项：
                        --host=host_name, -h host_name：服务端地址；
                        --user=user_name, -u user_name：用户名；
                        --password[=password], -p[password]：用户密码； 
                        --port=port_num, -P port_num：服务端端口； 
                        --protocol={TCP|SOCKET|PIPE|MEMORY}：
                            本地通信：基于本地回环地址进行请求，将基于本地通信协议；
                                Linux：SOCKET
                                Windows：PIPE，MEMORY
                            非本地通信：使用非本地回环地址进行的请求； TCP协议；
                        --socket=path, -S path
                        --database=db_name, -D db_name：
                        --compress, -C：数据压缩传输
                        --execute=statement, -e statement：非交互模式执行SQL语句；
                        --vertical, -E：查询结果纵向显示；
                        
                    命令：
                        客户端命令：于客户端执行；
                        服务端命令：SQL语句，需要一次性完整地发往服务端；语句必须有结束符；
                        
                        ?         (\?) Synonym for `help'.
                        clear     (\c) Clear the current input statement.
                        connect   (\r) Reconnect to the server. Optional arguments are db and host.
                        delimiter (\d) Set statement delimiter.
                        edit      (\e) Edit command with $EDITOR.
                        ego       (\G) Send command to mysql server, display result vertically.
                        exit      (\q) Exit mysql. Same as quit.
                        go        (\g) Send command to mysql server.
                        help      (\h) Display this help.
                        nopager   (\n) Disable pager, print to stdout.
                        notee     (\t) Don't write into outfile.
                        pager     (\P) Set PAGER [to_pager]. Print the query results via PAGER.
                        print     (\p) Print current command.
                        prompt    (\R) Change your mysql prompt.
                        quit      (\q) Quit mysql.
                        rehash    (\#) Rebuild completion hash.
                        source    (\.) Execute an SQL script file. Takes a file name as an argument.
                        status    (\s) Get status information from the server.
                        system    (\!) Execute a system shell command.
                        tee       (\T) Set outfile [to_outfile]. Append everything into given outfile.
                        use       (\u) Use another database. Takes database name as argument.
                        charset   (\C) Switch to another charset. Might be needed for processing binlog with multi-byte charsets.
                        warnings  (\W) Show warnings after every statement.
                        nowarning (\w) Don't show warnings after every statement.   
                        
                    mysql命令的使用帮助：
                        # man mysql
                        # mysql  --help  --verbose
                        
                sql脚本运行：
                    mysql [options] [DATABASE] < /PATH/FROM/SOME_SQL_SCRIPT

                    
            mysqld服务器程序：工作特性的定义方式
                命令行选项
                配置文件参数
                
                服务器参数/变量：设定MySQL的运行特性；
                    mysql> SHOW [GLOBAL | SESSION] VARIABLES [like_or_where]；
                状态（统计）参数/变量：保存MySQL运行过程中的统计数据或状态数据；
                    mysql> SHOW [GLOBAL | SESSION] STATUS [like_or_where];
                    
                显示单个变量设定值的方法：
                    mysql> SELECT @@[global.|session.]system_var_name
                    
                        %：匹配任意长度的任意字符；
                        _：匹配任意单个字符；
                    
                变量/参数级别：
                    全局：为所有会话设定默认； 
                    会话：跟单个会话相关；会话建立会从全局继承；
                    
                服务器变量的调整方式：
                    运行时修改：
                        global：仅对修改后新建立的会话有效；
                        session：仅对当前会话有效，且立即生效；
                    通过配置文件修改：
                        重启后生效；
                    
                运行时修改服务器变量值操作方法：
                    mysql> HELP SET
                    
                    SET [GLOBAL | SESSION] system_var_name = expr
                    SET [@@global. | @@session. | @@]system_var_name = expr
                    
            安装完成后的安全初始化：
                mysql_secure_installation
                
            运行前常修改的参数：
                innodb_file_per_table=ON
                skip_name_resolve=ON
                sql_safe_updates=ON
                ...

    SQL接口：
        
        SQL：ANSI SQL 
            SQL-86, SQL-89, SQL-92, SQL-99, SQL-03, ...
            
        MySQL的数据类型：
            字符型
            数值型
            日期时间型
            内建类型
            
            字符型：
                CHAR(#)， BINARY(#)：定长型；CHAR不区分字符大小写，而BINARY区分；
                VARCHAR(#)， VARBINARY(#)：变长型
                TEXT：TINYTEXT，TEXT，MEDIUMTEXT，LONGTEXT
                BLOB：TINYBLOB，BLOB，MEDIUMBLOB， LONGBLOB
                    Binary Large OBject
            数值型：
                浮点型：近似
                    FLOAT
                    DOUBLE
                    REAL
                    BIT
                整型：精确
                    INTEGER：TINYINT，SMALLINT，MEDIUMINT，INT，BIGINT
                    DECIMAL
            日期时间型：
                日期：DATE
                时间：TIME
                日期j时间：DATETIME
                时间戳：TIMESTAMP
                年份：YEAR(2), YEAR(4)
            内建：
                ENUM：枚举
                    ENUM('Sun','Mon','Tue','Wed')
                SET：集合
                    
            类型修饰符：
                字符型：NOT NULL，NULL，DEFALUT ‘STRING’，CHARACET SET ‘CHARSET’，COLLATION ‘collocation'
                整型：NOT NULL， NULL， DEFALUT value, AUTO_INCREMENT, UNSIGNED
                日期时间型：NOT NULL， NULL， DEFAULT 
                
                help 'Data Types'
            
        SQL MODE：定义mysqld对约束等违反时的响应行为等设定；
            常用的MODE：
                TRADITIONAL
                STRICT_TRANS_TABLES
                STRICT_ALL_TABLES
                
            修改方式：
                mysql> SET GLOBAL sql_mode='MODE';
                mysql> SET @@global.sql_mode='MODE';
                
        SQL：DDL，DML
            DDL：Data Defination Language
                mysql> HELP Data Definition
                
                CREATE, ALTER, DROP
                    DATABASE, TABLE
                    INDEX, VIEW, USER
                    FUNCTION, FUNCTION UDF, PROCEDURE, TABLESPACE, TRIGGER, SERVER 
                    
            DML: Data Manipulation Language
                mysql> HELP Data Manipulation
                
                INSERT/REPLACE, DELETE, SELECT, UPDATE
                
            数据库：
                CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name CHARACTER SET [=] charset_name  COLLATE [=] collation_name
                
                ALTER {DATABASE | SCHEMA} [db_name] CHARACTER SET [=] charset_name  COLLATE [=] collation_name
                
                DROP {DATABASE | SCHEMA} [IF EXISTS] db_name
                
            表：
                CREATE 
                    (1) CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
                        (create_definition,...)
                        [table_options]
                        [partition_options]
                        
                        CREATE TABLE [IF NOT EXISTS] tble_name (col_name  data_typ|INDEX|CONSTRAINT);
                        
                    table_options：
                        ENGINE [=] engine_name
                            
                            查看支持的所有存储引擎：
                                mysql> SHOW ENGINES;
                            
                            查看指定表的存储引擎：
                                mysql> SHOW TABLE STATUS LIKE clause;
                            
                        ROW_FORMAT [=] {DEFAULT|DYNAMIC|FIXED|COMPRESSED|REDUNDANT|COMPACT}
                        
                    (2) CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
                        [(create_definition,...)]
                        [table_options]
                        [partition_options]
                        select_statement
                        
                        直接创建表，并将查询语句的结果插入到新创建的表中；
            
                    (3) CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
                        { LIKE old_tbl_name | (LIKE old_tbl_name) }
                        
                        复制某存在的表的结构来创建新的空表；
                    
                DROP:
                    DROP [TEMPORARY] TABLE [IF EXISTS] tbl_name [, tbl_name]; 
                    
                ALTER：
                    ALTER  TABLE tbl_name
                        [alter_specification [, alter_specification] ...]
                        
                        可修改内容：
                            (1) table_options
                            (2) 添加定义：ADD
                                字段、字段集合、索引、约束
                            (3) 修改字段：
                                CHANGE [COLUMN] old_col_name new_col_name column_definition [FIRST|AFTER col_name]
                                MODIFY [COLUMN] col_name column_definition [FIRST | AFTER col_name]
                            (4) 删除操作：DROP
                                字段、索引、约束
                                
                        表重命名：
                            RENAME [TO|AS] new_tbl_name
                            
                查看表结构定义：
                    DESC tbl_name；
                    
                查看表定义：
                    SHOW CREATE TABLE tbl_name
                    
                查看表属性信息：
                    SHOW TABLE STATUS [{FROM | IN} db_name] [LIKE 'pattern' | WHERE expr]
                    
            索引：数据结构
                创建：
                    CREATE [UNIQUE|FULLTEXT|SPATIAL] INDEX index_name [index_type] ON tbl_name (index_col_name,...)
                    
                查看：
                    SHOW {INDEX | INDEXES | KEYS} {FROM | IN} tbl_name [{FROM | IN} db_name] [WHERE expr]
                    
                删除：
                    DROP  INDEX index_name ON tbl_name
                    
                索引类型：
                    聚集索引、非聚集索引：索引是否与数据存在一起；
                    主键索引、辅助索引
                    稠密索引、稀疏索引：是否索引了每一个数据项；
                    BTREE（B+）、HASH、R Tree、FULLTEXT
                        BTREE：左前缀；
                            
                EXPLAIN：分析查询语句的执行路径；
                
            视图：VIEW
                虚表：存储下来的SELECT语句；
                
                创建：
                    CREATE  VIEW view_name [(column_list)] AS select_statement
                    
                修改：
                    ALTER  VIEW view_name [(column_list)] AS select_statement
                    
                删除：
                    DROP VIEW [IF EXISTS] view_name [, view_name] ...
                    
        DML：
            INSERT/REPLACE，DELETE，UPDATE，SELECT
            
            INSERT：
                单行插入
                批量插入
                
                INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]
                [INTO] tbl_name [(col_name,...)]
                {VALUES | VALUE} ({expr | DEFAULT},...),(...),...
                [ ON DUPLICATE KEY UPDATE
                col_name=expr
                    [, col_name=expr] ... ]
                    
                    

                Or:

                INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]
                [INTO] tbl_name
                SET col_name={expr | DEFAULT}, ...
                [ ON DUPLICATE KEY UPDATE
                col_name=expr
                    [, col_name=expr] ... ]

                Or:

                INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE]
                [INTO] tbl_name [(col_name,...)]
                SELECT ...
                [ ON DUPLICATE KEY UPDATE
                col_name=expr
                    [, col_name=expr] ... ]
                
            DELETE：
                
                DELETE  FROM tbl_name [WHERE where_condition] [ORDER BY ...] [LIMIT row_count]      
                
                注意：一定要有限制条件，否则将清空整个表；
                    限制条件：
                        [WHERE where_condition]
                         [ORDER BY ...] [LIMIT row_count]
                         
            UPDATE：
                
                UPDATE table_reference SET col_name1={expr1|DEFAULT} [, col_name2={expr2|DEFAULT}] ...
                    [WHERE where_condition]
                    [ORDER BY ...]
                    [LIMIT row_count]               
                        
                注意：一定要有限制条件，否则将修改整个表中指定字段的数据；
                    限制条件：
                        [WHERE where_condition]
                         [ORDER BY ...] [LIMIT row_count]
                         
            
                注意：sql_safe_updates变量可阻止不带条件更新操作；
                
        SELECT：
            
            Query Cache：缓存查询的执行结果；
                key：查询语句的hash值； 
                value：查询语句的执行结果；
                
                SQL语句的编写方式：
                    SELECT name FROM tbl2;
                    select name from tbl2;
            
            查询执行路径：
                请求-->查询缓存：命中后返回；
                请求-->查询缓存-->解析器-->预处理器-->优化器-->查询执行引擎-->存储引擎-->缓存-->响应
                                
                
            SELECT语句的执行流程：
                FROM  --> WHERE --> Group By --> Having --> Order BY --> SELECT --> Limit 
                
            单表查询：
                
                SELECT
                    [ALL | DISTINCT | DISTINCTROW ]
                    [SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS]
                    select_expr [, select_expr ...]
                    [FROM table_references
                    [WHERE where_condition]
                    [GROUP BY {col_name | expr | position}
                    [ASC | DESC], ... [WITH ROLLUP]]
                    [HAVING where_condition]
                    [ORDER BY {col_name | expr | position}
                    [ASC | DESC], ...]
                    [LIMIT {[offset,] row_count | row_count OFFSET offset}] 
                    
                用法：
                    SELECT col1, col2, ... FROM tble_name；
                    SELECT col1, col2, ... FROM tble_name WHERE clause；
                    SELECT col1, col2, ... FROM tble_name  [WHERE clause] GROUP BY col_name [HAVING clause]； 
                        分组的目的在于聚合计算：avg, max, min, count, sum,
                    
                DISTINCT：数据去重；
                SQL_CACHE：显式指定缓存查询语句的结果；
                SQL_NO_CACHE：显式指定不缓存查询语句的结果；
                
                query_cache_type服务器变量有三个值：
                    ON：启用； 
                        SQL_NO_CACHE：不缓存；默认符合缓存条件都缓存；
                    OFF：关闭；
                    DEMAND：按需缓存；
                        SQL_CACHE：缓存；默认不缓存；
                        
                字段可以使用别名 ：
                    col1 AS alias1, col2 AS alias2, ...
                    
                WHERE子句：指明过滤条件以实现“选择”功能；
                    过滤条件：布尔型表达式；
                    
                    [WHERE where_condition]
                        算术操作符：+, -, *, /, %
                        比较操作符：=, <>, !=, <=>, >, >=, <, <=
                        
                            IS NULL， IS NOT NULL
                            区间：BETWEEN min AND max 
                            IN：列表；
                            LIKE：模糊比较，%和_；
                            RLIKE或REGEXP
                            
                        逻辑操作符：
                            AND， OR， NOT， XOR
                            
                GROUP BY：根据指定的字段把查询的结果进行“分组”以用于“聚合”运算；
                    avg(), max(), min(), sum(), count()
                    
                    HAVING：对分组聚合后的结果进行条件过滤；
                    
                ORDER BY：根据指定的字段把查询的结果进行排序；
                    升序：ASC
                    降序：DESC 
                    
                LIMIT：对输出结果进行数量限制
                    [LIMIT {[offset,] row_count | row_count OFFSET offset}]
                    
                
            多表查询：
                连接操作：
                    交叉连接：笛卡尔乘积；
                    内连接：
                        等值连接：让表之间的字段以等值的方式建立连接；
                        不等值连接：
                        自然连接
                        自连接
                    外连接：
                        左外连接：
                            FROM tb1 LEFT JOIN tb2 ON tb1.col = tb2.col 
                        右外连接：
                            FROM tb1 RIGHT JOIN tb2 ON tb1.col = tb2.col 
                            
            子查询：在查询中嵌套查询；
                
                用于WHERE子句中的子查询；
                    (1) 用于比较表达式中的子查询：子查询仅能返回单个值； 
                    (2) 用于IN中的子查询：子查询可以返回一个列表值； 
                    (3) 用于EXISTS中的子查询：
                用于FROM子句中的子查询；
                    SELECT tb_alias.col1, ... FROM (SELECT clause) AS tb_alias WHERE clause; 
                    
            联合查询：将多个查询语句的执行结果相合并；
                UNION 
                    SELECT clause UNION SELECT cluase；


            练习：导入hellodb.sql生成数据库
                (1) 在students表中，查询年龄大于25岁，且为男性的同学的名字和年龄；
                (2) 以ClassID为分组依据，显示每组的平均年龄；
                (3) 显示第2题中平均年龄大于30的分组及平均年龄；
                (4) 显示以L开头的名字的同学的信息；
                (5) 显示TeacherID非空的同学的相关信息；
                (6) 以年龄排序后，显示年龄最大的前10位同学的信息；
                (7) 查询年龄大于等于20岁，小于等于25岁的同学的信息；用三种方法；

                    
            
            练习：导入hellodb.sql，以下操作在students表上执行
                1、以ClassID分组，显示每班的同学的人数；
                2、以Gender分组，显示其年龄之和；
                3、以ClassID分组，显示其平均年龄大于25的班级；
                4、以Gender分组，显示各组中年龄大于25的学员的年龄之和；


            练习：导入hellodb.sql，完成以下题目：
                1、显示前5位同学的姓名、课程及成绩；
                2、显示其成绩高于80的同学的名称及课程；
                3、求前8位同学每位同学自己两门课的平均成绩，并按降序排列；
                4、显示每门课程课程名称及学习了这门课的同学的个数；


            思考：
                1、如何显示其年龄大于平均年龄的同学的名字？
                2、如何显示其学习的课程为第1、2，4或第7门课的同学的名字？
                3、如何显示其成员数最少为3个的班级的同学中年龄大于同班同学平均年龄的同学？
                4、统计各班级中年龄大于全校同学平均年龄的同学。    
            

    存储引擎：
        表类型：表级别概念，不建议在同一个库中的表上使用不同的ENGINE；
        
        CREATE TABLE ... ENGINE[=]STORAGE_ENGINE_NAME ...
        SHOW TABLE STATUS 
        
        常见的存储引擎：
            MyISAM, Aria, InnoDB, MRG_MYISAM, CSV, BLACKHOLE, MEMORY, PERFORMANCE_SCHEMA, ARCHIVE, FEDERATED
            
        InnoDB：InnoBase
            Percona-XtraDB, Supports transactions, row-level locking, and foreign keys
                
            数据存储于“表空间(table space)"中：
                (1) 所有InnoDB表的数据和索引存储于同一个表空间中；
                    表空间文件：datadir定义的目录中
                        文件：ibdata1, ibdata2, ...
                (2) innodb_file_per_table=ON，意味着每表使用单独的表空间文件；
                    数据文件（数据和索引，存储于数据库目录）: tbl_name.ibd 
                    
                表结构的定义：在数据库目录，tbl_name.frm 
                
            事务型存储引擎，适合对事务要求较高的场景中；但较适用于处理大量短期事务；
            基于MVCC（Mutli Version Concurrency Control）支持高并发；支持四个隔离级别，默认级别为REPEATABLE-READ；间隙锁以防止幻读；
            使用聚集索引（主键索引）；
            支持”自适应Hash索引“；
            锁粒度：行级锁；间隙锁；
            
            总结：
                数据存储：表空间；
                并发：MVCC，间隙锁，行级锁；
                索引：聚集索引、辅助索引；
                性能：预读操作、内存数据缓冲、内存索引缓存、自适应Hash索引、插入操作缓存区；
                备份：支持热备；
                    
        MyISAM：
            
            支持全文索引（FULLTEXT index）、压缩、空间函数（GIS）；
            不支持事务
            锁粒度：表级锁
            崩溃无法保证表安全恢复
            
            适用场景：只读或读多写少的场景、较小的表（以保证崩溃后恢复的时间较短）；
            
            文件：每个表有三个文件，存储于数据库目录中
                tbl_name.frm：表格式定义；
                tbl_name.MYD：数据文件； 
                tbl_name.MYI：索引文件；
                
            特性：
                加锁和并发：表级锁；
                修复：手动或自动修复、但可能会丢失数据；
                索引：非聚集索引；
                延迟索引更新；
                表压缩；
                
        行格式：
             {DEFAULT|DYNAMIC|FIXED|COMPRESSED|REDUNDANT|COMPACT}
             
        其它的存储引擎：
            CSV：将CSV文件（以逗号分隔字段的文本文件）作为MySQL表文件； 
            MRG_MYISAM：将多个MyISAM表合并成的虚拟表；
            BLACKHOLE：类似于/dev/null，不真正存储数据；
            MEMORY：内存存储引擎，支持hash索引，表级锁，常用于临时表；
            FEDERATED: 用于访问其它远程MySQL服务器上表的存储引擎接口；
            
        MariaDB额外支持很多种存储引擎：
            OQGraph、SphinxSE、TokuDB、Cassandra、CONNECT、SQUENCE、...
            
        搜索引擎：
            lucene, sphinx 
                lucene：Solr, Elasticsearch 
                
        
    并发控制：
        锁：Lock 
        
        锁类型 ：
            读锁：共享锁，可被多个读操作共享；
            写锁：排它锁，独占锁；
            
        锁粒度：
            表锁：在表级别施加锁，并发性较低；
            行锁：在行级另施加锁，并发性较高；
            
        锁策略：在锁粒度及数据安全性之间寻求一种平衡机制；
        
            存储引擎：级别以及何时施加或释放锁由存储引擎自行决定；
            MySQL Server：表级别，可自行决定，也允许显式请求； 
                    
        锁类别：
            显式锁：用户手动请求的锁；
            隐式锁：存储引擎自行根据需要施加的锁；
            
        显式锁的使用：
            (1) LOCK TABLES 
            
                LOCK TABLES  tbl_name  read|write, tbl_name read|write, ...
                
                UNLOCK TABLES
                
            (2) FLUSH TABLES
                FLUSH TABLES tbl_name,... [WITH READ LOCK];
                
                UNLOCK TABLES;
                
            (3) SELECT cluase
                [FOR UPDATE | LOCK IN SHARE MODE]


                
回顾：
    连接查询：内连接、外连接；
    存储引擎：InnoDB, MyISAM
        InnoDB：
            表空间文件：
                (1) 所有表空间使用同一个文件； 
                (2) 每表使用单独的表空间； 
            事务日志：
                事务日志组：2+ files
                事务日志组镜像：1
        MyISAM：
            表级锁
            tbl.frm, tbl.MYD, tbl.MYI 
            全文索引、空间索引
    锁：
        LOCK TABLES 
        FLUSH TABLES WITH READ LOCK
        UNLOCK TABLES
        
MySQL（2）
    
        
                            
    事务：
        事务：一组原子性的SQL查询、或者是一个或多个SQL语句组成的独立工作单元；
        
            事务日志：
                innodb_log_files_in_group
                innodb_log_group_home_dir
                innodb_log_file_size    
                innodb_mirrored_log_groups
        
        ACID测试：
            A：AUTOMICITY，原子性；整个事务中的所有操作要么全部成功执行，要么全部失败后回滚；
            C：CONSISTENCY，一致性；数据库总是应该从一个一致性状态转为另一个一致性状态； 
            I：ISOLATION，隔离性；一个事务所做出的操作在提交之前，是否能为其它事务可见；出于保证并发操作之目的，隔离有多种级别； 
            D：DURABILITY，持久性；事务一旦提交，其所做出的修改会永久保存；
            
        自动提交：单语句事务
            mysql> SELECT @@autocommit;
            +------------------------+
            | @@autocommit |
            +------------------------+
            |            1               |
            +------------------------+
            
            mysql> SET @@session.autocommit=0；
            
        手动控制事务：
            启动：START TRANSACTION 
            提交：COMMIT
            回滚：ROLLBACK
            
            事务支持savepoints：
                SAVEPOINT identifier
                ROLLBACK [WORK] TO [SAVEPOINT] identifier
                RELEASE SAVEPOINT identifier                
            
        事务隔离级别：
            READ-UNCOMMITTED：读未提交 --> 脏读；
            READ-COMMITTED：读提交--> 不可重复读；
            REPEATABLE-READ：可重复读 --> 幻读；
            SERIALIZABLE：串行化；
            
            mysql> SELECT @@session.tx_isolation;
            +----------------------------------+
            | @@session.tx_isolation |
            +----------------------------------+
            | REPEATABLE-READ         |
            +----------------------------------+
            
        查看InnoDB存储引擎的状态信息：
            SHOW ENGINE innodb STATUS; 
            
        


        

    MySQL用户和权限管理 
        用户账号：user@host
            user：账户名称；
            host：此账户可通过哪些客户端主机请求创建连接线程； 
                %：任意长度牟任意字符；
                _：任意单个字符；
        
    MySQL权限类别：
        库级别：
        表级别：
        字段级别：
        管理类：
        程序类：
        
        管理类：
            CREATE USER
            RELOAD
            LOCK TABLES
            REPLICATION CLIENT， REPLICATION SLAVE
            SHUTDOWN
            FILE
            SHOW DATABASES
            PROCESS 
            SUPER
            
        程序类：
            FUNCTION，PROCEDURE，TRIGGER
            
            操作：CREATE，ALTER，DROP，EXECUTE
            
        库和表级别：
            CREATE，ALTER，DROP
            INDEX
            CREATE VIEW
            SHOW VIEW
            GRANT
            OPTION：能够把自己获得的权限生成一个副本转赠给其它用户；
            
        数据操作：
            表：
                INSERT/DELETE/UPDATE/SELECT 
                
            字段：
                SELECT(col1,col2,...)
                UPDATE(col1,col2,...)
                INSERT(col1,col2,...)
                
        所有权限：ALL， ALL PRIVILEGES
        
        元数据数据库（数据字典）：mysql
            授权：
                db, host, user
                tables_priv, column_priv, procs_priv, proxies_priv
                
        
    MySQL用户管理：
        'user'@'host';
            host:
                IP
                主机名             
                NETWORK
                    %, _
                    
        skip_name_resolve={ON|OFF}
        
        创建用户：
            CREATE USER  'user'@'host' [IDENTIFIED BY [PASSWORD] 'password'] [,'user'@'host' [IDENTIFIED BY [PASSWORD] 'password']...]
            
        重命名：RENAME USER
            RENAME USER old_user TO new_user[, old_user TO new_user] ...
            
        删除用户：
            DROP USER 'user'@'host' [, 'user'@'host'] ...
            
        修改用户密码：
            (1) SET PASSWORD [FOR 'user'@'host'] = PASSWORD('cleartext password');
            (2) UPDATE mysql.user SET Password=PASSWORD('cleartext password')  WHERE User='USERNAME' AND Host='HOST';
            (3) mysqladmin -uUSERNAME -hHOST -p  password 'NEW_PASS'
            
            生效：FLUSH PRIVILEGES
            
        忘记管理员密码的解决办法：
            (1) 启动mysqld进程时，使用--skip-grant-tables和--skip-networking选项；
                CentOS 7：mariadb.service
                CentOS 6：/etc/init.d/mysqld
            (2) 通过UPDATE命令修改管理员密码； 
            (3) 以正常 方式启动mysqld进程；
            
        授权：GRANT
            GRANT  priv_type [(column_list)] [, priv_type [(column_list)]] ...
                ON [object_type] priv_level
                TO user_specification [, user_specification] ...
                [REQUIRE {NONE | ssl_option [[AND] ssl_option] ...}]
                [WITH with_option ...]
            
                object_type:
                    TABLE
                    | FUNCTION
                    | PROCEDURE
                    
                priv_level:
                    *
                    | *.*
                    | db_name.*
                    | db_name.tbl_name
                    | tbl_name
                    | db_name.routine_name
                    
                    
                ssl_option:
                    SSL
                    | X509
                    | CIPHER 'cipher'
                    | ISSUER 'issuer'
                    | SUBJECT 'subject'             
                
                with_option:
                    GRANT OPTION
                    | MAX_QUERIES_PER_HOUR count
                    | MAX_UPDATES_PER_HOUR count
                    | MAX_CONNECTIONS_PER_HOUR count
                    | MAX_USER_CONNECTIONS count    
                    
        查看授权：SHOW GRANTS
            SHOW GRANTS [FOR 'user'@'host']
                    
        取消授权：REVOKE
            REVOKE  priv_type [(column_list)][, priv_type [(column_list)]] ...
                ON [object_type] priv_level
                FROM  'user'@'host' [,  'user'@'host'] ...
                
            REVOKE ALL PRIVILEGES, GRANT OPTION
                FROM user [, user] ...
    
    练习：授权一个仅能够通过ssl连接的用户账号，而后完成连接测试；
    
    
    
    查询缓存：
        
        缓存：k/v 
            key：查询语句的hash值
            value：查询语句的执行结果
            
        如何判断缓存是否命中：
            通过查询语句的哈希值判断：哈希值考虑的因素包括
                查询本身、要查询数据库、客户端使用的协议版本、...
                
        哪些查询可能不会被缓存？
            查询语句中包含UDF
            存储函数
            用户自定义变量
            临时表
            mysql系统表或者是包含列级别权限的查询
            有着不确定结果值的函数(now())；
            
        查询缓存相关的服务器变量：
            query_cache_limit：能够缓存的最大查询结果；（单语句结果集大小上限）
                有着较大结果集的语句，显式使用SQL_NO_CACHE，以避免先缓存再移出； 
            query_cache_min_res_unit：内存块的最小分配单位；缓存过小的查询结果集会浪费内存空间；
                较小的值会减少空间浪费，但会导致更频繁地内存分配及回收操作； 
                较大值的会带来空间浪费；
            query_cache_size：查询缓存空间的总共可用的大小；单位是字节，必须是1024的整数倍；
            query_cache_strip_comments
            query_cache_type：缓存功能启用与否；
                ON：启用；
                OFF：禁用；
                DEMAND：按需缓存，仅缓存SELECT语句中带SQL_CACHE的查询结果；
            query_cache_wlock_invalidate：如果某表被其它连接锁定，是否仍然可以从查询缓存中返回查询结果；默认为OFF，表示可以；ON则表示不可以；
        
        状态变量：
            mysql> SHOW GLOBAL STATUS LIKE 'Qcache%';
            +-------------------------+----------+
            | Variable_name           | Value    |
            +-------------------------+----------+
            | Qcache_free_blocks      | 1        |
            | Qcache_free_memory      | 16759688 |
            | Qcache_hits             | 0        |
            | Qcache_inserts          | 0        |
            | Qcache_lowmem_prunes    | 0        |
            | Qcache_not_cached       | 0        |
            | Qcache_queries_in_cache | 0        |
            | Qcache_total_blocks     | 1        |
            +-------------------------+----------+      
            
            命中率：
                Qcache_hits/Com_select 


回顾：事务、权限和用户
    事务：ACID测试、事务隔离级别
    用户：user@host
    权限：
        管理类、程序类、数据类；
        GRANT，REVOKE
                
                
MySQL(4) 

    MySQL的索引：
    
        索引：提取索引的创建在的表上字段中的数据，构建出一个独特的数据结构；
        
        索引的作用：加速查询操作；
            表中数据子集：把表中某个或某些字段的数据提取出来另存为一个特定数据结构组织的数据；
                某个字段或某些字段：WHERE子句中用到的字段；
                
        索引类型：B+ TREE，HASH
            B+ TREE：顺序存储，每一个叶子结点到根结点的距离相同；左前缀索引，适合于范围类型的数据查询；
            
                适用于B+ TREE索引的查询类型：全键值、键值范围或键前缀；
                    全值匹配：精确匹配某个值；
                        WHERE CLOUMN = 'value';
                    匹配最左前缀：只精确起头的部分；
                        WEHRE COLUMN LIKE 'PREFIX%';                        
                    匹配范围值：
                    精确匹配某一列，范围匹配另一列；
                    只用访问索引的查询：覆盖索引；
                        index(Name)
                        SELECT Name FROM students WHERE Name LIKE 'L%';
                                            
                不适用B+ TREE索引：
                    如查条件不是从最左侧列开始，索引无效；
                        index(age,name), WHERE name='Jerry';, WHERE age>30;
                    不能跳过索引中的某列；
                        index(name,age,gender)
                            WHERE second_name='black' and age > 30;
                    如果查询中的某个列是为范围查询，那么其右侧的列都无法再使用索引优化查询；
                
            Hash索引：基于哈希表实现，特别适用于值的精确匹配查询；
            
                适用场景：
                    只支持等值比较查询，例如=, IN(), <=>
                    
                不用场景：
                    所有非精确值查询；MySQL仅对memory存储引擎支持显式的hash索引；
                    
        索引优点：
            降低需要扫描的数据量，减少了IO次数；
            可以帮助避免排序操作，避免使用临时表； 
            帮助将随机IO转为顺序IO；
            
        高性能索引策略：
            (1) 在WHERE中独立使用列，尽量避免其参与运算；
                WHERE age > 30 ; 
            (2) 左前缀索引：索引构建于字段的最左侧的多少个字符，要通过索引选择性来评估
                索引选择性：不重复的索引值和数据表的记录总数的比值；
            (3) 多列索引：
                AND连接的多个查询条件更适合使用多列索引，而非多个单键索引；
            (4) 选择合适的索引列次序：选择性最高的放左侧；
            
    EXPLAIN来分析索引有效性：
    
        EXPLAIN [explain_type] SELECT select_options
            
            explain_type:
                EXTENDED
                | PARTITIONS    
        
        输出结果：
                    id: 1
            select_type: SIMPLE
                table: students
                type: const
            possible_keys: PRIMARY
                key: PRIMARY
            key_len: 4
                ref: const
                rows: 1
                Extra: 
                
                id：当前查询语句中，第个SELECT语句的编号；
                    
                    复杂的查询的类型主要三种：
                        简单子查询
                        用于FROM中的子查询
                        联合查询
                        
                    注意：联合查询的分析结果会出现一个额外的匿名临时表；
                    
                select_type：查询类型：
                    简单查询：SIMPLE
                    复杂查询：
                        简单子查询：SUBQUERY
                        用于FROM中的子查询：DERIVED
                        联合查询中的第一个查询：PRIMARY
                        联合查询中的第一个查询之后的其它查询：UNION
                        联合查询生成的临时表：UNION RESULT
                        
                table：查询针对的表；
                
                type：关联类型，或称为访问类型，即MySQL如何去查询表中的行
                    ALL：全表扫描；
                    index：根据索引的顺序进行的全表扫描；但同时如果Extra列出现了"Using index”表示使用了覆盖索引；
                    range：有范围限制地根据索引实现范围扫描；扫描位置始于索引中的某一项，结束于另一项；
                    ref：根据索引返回的表中匹配到某单个值的所有行（匹配给定值的行不止一个）；
                    eq_ref：根据索引返回的表中匹配到某单个值的单一行，仅返回一个行，但需要与某个额外的参考值比较，而不是常数；
                    const，system：与某个常数比较，且只返回一行；
                    
                possiable_keys：查询中可能会用到的索引；
                    
                key：查询中使用的索引；
                
                key_len：查询中用到的索引长度；
                
                ref：在利用key字段所显示的索引完成查询操作时所引用的列或常量值； 
                
                rows：MySQL估计出的为找到所有的目标项而需要读取的行数；
                
                Extra：额外信息
                    Using index：使用了覆盖索引进行的查询；
                    Using where：拿到数据后还要再次进行过滤； 
                    Using temporary：使用了临时表以完成查询；
                    Using filesort：对结果使用了一个外部索引排序；
                    


    日志：
        查询日志：general_log
        慢查询日志：log_slow_queries
        错误日志：log_error， log_warnings
        二进制日志：binlog
        中继日志：relay_log
        事务日志：innodb_log
        
        1、查询日志
            记录查询语句，日志存储位置：
                文件：file
                表：table (mysql.general_log)
                
            general_log={ON|OFF}
            general_log_file=HOSTNAME.log 
            log_output={FILE|TABLE|NONE}
            
        2、慢查询日志
            慢查询：运行时间超出指定时长的查询；
                long_query_time
            存储位置：
                文件：FILE
                表：TABLE，mysql.slog_log
                
            log_slow_queries={ON|OFF}
            slow_query_log={ON|OFF}
            slow_query_log_file=
            log_output={FILE|TABLE|NONE}
            log_slow_filter=admin,filesort,filesort_on_disk,full_join,full_scan,query_cache,query_cache_miss,tmp_table,tmp_table_on_disk
            log_slow_rate_limit
            log_slow_verbosity
            
        3、错误日志
            记录信息：
                (1) mysqld启动和关闭过程 输出的信息； 
                (2) mysqld运行中产生的错误信息； 
                (3) event scheduler运行时产生的信息；
                (4) 主从复制架构中，从服务器复制线程启动时产生的日志；
                
            log_error=
            log_warnings={ON|OFF}
            
        4、二进制日志
            用于记录引起数据改变或存在引起数据改变的潜在可能性的语句（STATEMENT）或改变后的结果（ROW），也可能是二者混合；
            功用：“重放”
            
            binlog_format={STATEMENT|ROW|MIXED}
                STATEMENT：语句；
                ROW：行；
                MIXED：混编；
                
            查看二进制日志文件列表：
                 SHOW MASTER|BINARY LOGS;
                 
            查看当前正在使用的二进制日志文件：
                SHOW MASTER STATUS；
                
            查看二进制 日志文件中的事件：
                SHOW BINLOG EVENTS   [IN 'log_name'] [FROM pos] [LIMIT [offset,] row_count]
                
            服务器变量：
                log_bin=/PATH/TO/BIN_LOG_FILE
                sql_log_bin={ON|OFF}
                max_binlog_size=1073741824
                sync_binlog={1|0}
                
            mysqlbinlog：
                    YYYY-MM-DD hh:mm:ss
                
                 --start-datetime=
                 --stop-datetime=
                 
                 -j, --start-position=#
                  --stop-position=#
                  
                  --user, --host, --password
                
            二进制日志事件格式：
                # at 553
                #160831  9:56:08 server id 1  end_log_pos 624   Query   thread_id=2     exec_time=0     error_code=0
                SET TIMESTAMP=1472608568/*!*/;
                BEGIN
                /*!*/;
                
                事件发生的日期时间：#160831  9:56:08
                事件发生的服务器id：server id 1
                事件的结束位置：end_log_pos 624
                事件的类型：Query
                事件发生时所在服务器执行此事件的线程的ID： thread_id=2 
                语句的时间戳与将其写入二进制日志文件中的时间差：exec_time=0
                错误代码：error_code=0
                事件内容：SET TIMESTAMP=1472608568/*!*/;
                
        中继日志：
            从服务器上记录下来从主服务器的二进制日志文件同步过来的事件；
            
            
        事务日志：
            事务型存储引擎innodb用于保证事务特性的日志文件：
                
                redo log 
                undo log 
                
                
    备份和恢复（数据）：
        
        备份：存储的数据副本；
            原始数据：持续改变；
        恢复：把副本应用到线上系统；
            仅能恢复至备份操作时刻的数据状态；
            
        时间点恢复：
            binary logs; 
        
        为什么备份？
            灾难恢复：硬件故障（冗余）、软件故障（bug）、自然灾害、黑客攻击、误操作、...
            测试；
            
        备份时应该注意事项：
            能容忍最多丢失多少数据；
            恢复数据需要在多长时间内完成；
            需要恢复哪些数据；
            
             做恢复演练：
                测试备份的可用性；
                增强恢复操作效率；
                ...
            
        备份类型：
            备份的数据的集范围：
                完全备份和部分备份
                    完全备份：整个数据集；
                    部分备份：数据集的一部分，比如部分表；
                    
            完全备份、增量备份、差异备份：
                完全备份
                增量备份：仅备份自上一次完全备份或 增量备份以来变量的那部数据；
                差异备份：仅备份自上一次完全备份以来变量的那部数据；
                
            物理备份、逻辑备份：
                物理备份：复制数据文件进行备份；
                逻辑备份：从数据库导出数据另存在一个或多个文件中；
                
            根据数据服务是否在线：
                热备：读写操作均可进行的状态下所做的备份；
                温备：可读但不可写状态下进行的备份；
                冷备：读写操作均不可进行的状态下所做的备份；
        
        备份需要考虑因素：
            锁定资源多长时间？
            备份过程的时长？
            备份时的服务器负载？
            恢复过程的时长？
        
        备份策略：
            完全+差异
            完全+增量 
            
            备份手段：物理、逻辑
            
        备份什么？
            数据
            二进制日志、InnoDB的事务日志；
            代码（存储过程、存储函数、触发器、事件调度器）
            服务器的配置文件

            
        备份工具：
            mysqldump：mysql服务自带的备份工具；逻辑备份工具；
                完全、部分备份；
                InnoDB：热备；
                MyISAM：温备；
            cp/tar
                lvm2：快照（请求一个全局锁），之后立即释放锁，达到几乎热备的效果；物理备份；
                注意：不能仅备份数据文件；要同时备份事务日志；
                    前提：要求数据文件和事务日志位于同一个逻辑卷；
            xtrabackup：
                由Percona提供，开源工具，支持对InnoDB做热备，物理备份工具；
                    完全备份、部分备份；
                    完全备份、增量备份；
                    完全备份、差异备份；
            mysqlhotcopy
            select：
                备份：SELECT cluase INTO OUTFILE 'FILENAME';
                恢复：CREATE TABLE 
                导入：LOAD DATA 

回顾：索引、日志、备份
    索引：B+ TREE，有序数据；范围查询，左前缀；
        EXPLAIN SELECT clause;
        
    日志：二进制日志、慢查询日志、查询日志、错误日志、事务日志、中继日志；
    
    备份：
        完全/部分，热备/温备/冷备，完全/差异/增量，物理/逻辑
        
MySQL（05）
                
    备份策略：
        完全+差异+binlog
        完全+增量+binlog
        
        备份，多久一次？
            数据变化量；
            可用的备份存储空间；
            
                                
        mysqldump：
            逻辑备份、完全备份、部分备份；
            二次封装工具：
                mydumper
                phpMyAdmin
                
            Usage: 
                mysqldump [OPTIONS] database [tables]
                OR     mysqldump [OPTIONS] --databases [OPTIONS] DB1 [DB2 DB3...]
                OR     mysqldump [OPTIONS] --all-databases [OPTIONS]
                
            MyISAM存储引擎：支持温备，备份时要锁定表；
                -x, --lock-all-tables：锁定所有库的所有表，读锁；
                -l, --lock-tables：锁定指定库所有表；
                
            InnoDB存储引擎：支持温备和热备；
                --single-transaction：创建一个事务，基于此快照执行备份；
                
            其它选项：
                -R, --routines：存储过程和存储函数；
                --triggers 
                -E, --events      
                 
                 --master-data[=#]
                    1：记录为CHANGE MASTER TO语句，此语句不被注释；
                    2：记录为CHANGE MASTER TO语句，此语句被注释；
                
                --flush-logs：锁定表完成后，即进行日志刷新操作；
                
        作业：备份脚本
            

    基于lvm2的备份：
        
        前提：数据目录位于逻辑卷，包含了数据文件和事务日志；
        
        (1) 请求锁定所有表；
            mysql> FLUSH TABLES WITH READ LOCK;
            
        (2) 记录二进制文件事件位置；
            mysql> FLUSH LOGS;
            mysql> SHOW MASTER STATUS;
            
            mysql  -e  'SHOW MASTER STATUS;' >> /PATH/TO/SOME_POS_FILE
            
        (3) 创建快照卷
            lvcreate  -L # -s -p r - SNAM-NAME /dev/VG-NAME/LV-NAME 
            
        (4) 释放锁
            mysql> UNLOCK TABLES
            
        (5) 挂载快照卷，并执行备份，备份完成后删除快照卷；
        
        (6) 周期性备份二进制日志； 

    percona：
        InnoDB --> XtraDB (mariadb)
        Innobackup --> Xtrabackup
        
    Xtrabackup：
        MyISAM：温备，不支持增量备份；
        InnoDB：热备，增量；
        
        物理备份，速率快、可靠；备份完成后自动校验备份结果集是否可用；还原速度快； 
        
        Usage: [innobackupex [--defaults-file=#] --backup | innobackupex [--defaults-file=#] --prepare] [OPTIONS]
        
            The  innobackupex tool is a Perl script that acts as a wrapper for the xtrabackup C program.
            
        完全备份：
            
        
        完全+binlog(总结)：
            备份：innobackupex  --user  --password=  --host=  /PATH/TO/BACKUP_DIR 
            准备：innobackupex --apply-log  /PATH/TO/BACKUP_DIR 
            恢复：innobackupex --copy-back 
                注意：--copy-back需要在mysqld主机本地进行，mysqld服务不能启动；
                    innodb_log_file_size可能要重新设定；
                    
        总结：完全+增量+binlog 
            备份：完全+增量+增量+...
                       完全+差异
            准备：
                innobackupex --apply-log --redo-only BASEDIR 
                innobackupex --apply-log --redo-only BASEDIR  --incremental-dir=INCREMENTAL-DIR
                
            恢复：
                innobackupex --copy-back BASEDIR
                
        备份单库：
            --databases 
                
        注意：未尽的内容，请参考官方文档；
        
    总结：
        mysqldump+binlog
        lvm2+cp/tar+binlog
        xtrabackup(innodb)+binlog 
        
    博客作业：mysqldump和xtrabackup的使用；

回顾：mysqldump, xtrabackup        
    mysqldump：
        --lock-all-tables
        --lock-tables
        --single-transaction
        --databases, --all-databases
        --routines, --trigger
    xtrabackup：innobackupex
        --user, --host, --password, --port, --socket
        --apply-log 
        --redo-only
        --copy-back
        
                

MySQL Replication：
    
    Master/Slave
        Master: write/read
        Slaves: read
        
    为什么？
        冗余：promte（提升为主），异地灾备
            人工
            工具程序：MHA
        负载均衡：转移一部分“读”请求；
        支援安全的备份操作；
        测试；
        ...
        
    主/从架构：
        异步复制：
        半同步复制：
        一主多从；
        一从一主；
        级联复制；
        循环复制；
        双主复制；
        
        一从多主：
            每个主服务器提供不同的数据库；
                
                
    配置：
        时间同步；
        复制的开始位置：
            从0开始；
            从备份中恢复到从节点后启动的复制；
        主从服务器mysqld程序版本不一致？
            
        主服务器：
            配置文件my.cnf
            server_id=#
            log_bin=log-bin
            
            启动服务：
            mysql> GRANT REPLICATION SLAVE,REPLICATION CLIENT ON *.* TO 'USERNAME'@'HOST' IDENTIFIED BY 'YOUR_PASSWORD';
            mysql> FLUSH PRIVILEGES;
            
        从服务器：
            配置文件my.cnf
            server_id=#
            relay_log=relay-log 
            
            启动服务：
            mysql> CHANGE MASTER TO MASTER_HOST='HOST',MASTER_USER='USERNAME',MASTER_PASSWORD='YOUR_PASSWORD',MASTER_LOG_FILE='BINLOG',MASTER_LOG_POS=#;
            mysql> START SLAVE [IO_THREAD|SQL_THREAD];
            
            mysql> SHOW SLAVE STATUS;
            
        课外作业：基于SSL的复制的实现； 
        

    主主复制：
        互为主从：两个节点各自都要开启binlog和relay log；
            1、数据不一致；
            2、自动增长id；
                定义一个节点使用奇数id
                    auto_increment_offset=1
                    auto_increment_increment=2
                另一个节点使用偶数id
                    auto_increment_offset=2
                    auto_increment_increment=2
                    
        配置：
            1、server_id必须要使用不同值； 
            2、均启用binlog和relay log；
            3、存在自动增长id的表，为了使得id不相冲突，需要定义其自动增长方式；
            
            服务启动后执行如下两步：
            4、都授权有复制权限的用户账号；
            5、各把对方指定为主节点；
            
    复制时应该注意的问题：
        1、从服务设定为“只读”；
            在从服务器启动read_only，但仅对非SUPER权限的用户有效；
            
            阻止所有用户：
                mysql> FLUSH TABLES WITH READ LOCK;
                
        2、尽量确保复制时的事务安全
            在master节点启用参数：
                sync_binlog = ON 
                
                如果用到的是InnoDB存储引擎：
                    innodb_flush_logs_at_trx_commit=ON
                    innodb_support_xa=ON
                    
        3、从服务器意外中止时尽量避免自动启动复制线程
                
        
        4、从节点：设置参数
            sync_master_info=ON
            
            sync_relay_log_info=ON
            
    半同步复制
        支持多种插件：/usr/lib64/mysql/plugins/
        
        需要安装方可使用：
            mysql> INSTALL PLUGIN plugin_name SONAME 'shared_library_name'; 
            
        半同步复制：
            semisync_master.so
            semisync_slave.so
            
        主节点：
            INSTALL PLUGIN rpl_semi_sync_master SONAME 'semisync_master.so';
            
                MariaDB [mydb]> SHOW GLOBAL VARIABLES LIKE 'rpl_semi%';
                +------------------------------------+-------+
                | Variable_name                      | Value |
                +------------------------------------+-------+
                | rpl_semi_sync_master_enabled       | OFF   |
                | rpl_semi_sync_master_timeout       | 10000 |
                | rpl_semi_sync_master_trace_level   | 32    |
                | rpl_semi_sync_master_wait_no_slave | ON    |
                +------------------------------------+-------+          

            MariaDB [mydb]> SET GLOBAL rpl_semi_sync_master_enabled=ON; 
                
        从节点：
            INSTALL PLUGIN rpl_semi_sync_slave SONAME 'semisync_slave.so';
            
                MariaDB [mydb]> SHOW GLOBAL VARIABLES LIKE 'rpl_semi%';                        
                +---------------------------------+-------+
                | Variable_name                   | Value |
                +---------------------------------+-------+
                | rpl_semi_sync_slave_enabled     | OFF   |
                | rpl_semi_sync_slave_trace_level | 32    |
                +---------------------------------+-------+         
            
            MariaDB [mydb]> STOP SLAVE IO_THREAD;
            MariaDB [mydb]> SHOW GLOBAL VARIABLES LIKE 'rpl_semi%';
            MariaDB [mydb]> START SLAVE IO_THREAD;
            
        判断方法：
            主节点：
                MariaDB [mydb]> SELECT @@global.rpl_semi_sync_master_clients；
                
    复制过滤器：
        
        仅复制有限一个或几个数据库相关的数据，而非所有；由复制过滤器进行；
        
        有两种实现思路：
        
        (1) 主服务器
            主服务器仅向二进制日志中记录有关特定数据库相关的写操作；
            问题：其它库的point-recovery将无从实现； 
            
                binlog_do_db=
                binlog_ignore_db=
        
        (2) 从服务器
            从服务器的SQL THREAD仅重放关注的数据库或表相关的事件，并将其应用于本地；
            问题：网络IO和磁盘IO；
            
                Replicate_Do_DB=
                Replicate_Ignore_DB=
                Replicate_Do_Table=
                Replicate_Ignore_Table=
                Replicate_Wild_Do_Table=
                Replicate_Wild_Ignore_Table=    
                
    作业：基于SSL复制的实现
        前提：启用SSL功能；
        
    复制的监控和维护：
        (1) 清理日志：PURGE 
            PURGE { BINARY | MASTER } LOGS { TO 'log_name' | BEFORE datetime_expr };
            
        (2) 复制监控
            MASTER:
                SHOW MASTER STATUS;
                SHOW BINLOG EVENTS;
                SHOW BINARY LOGS;
                
            SLAVE:
                SHOW SLAVE STATUS;
                
                判断从服务器是否落后于主服务器：
                    Seconds_Behind_Master: 0
                    
        (3) 如何确定主从节点数据是否一致？
            通过表的CHECKSUM检查；
            使用percona-tools中pt-table-checksum；
            
        (4) 主人数据不一致时的修复方法？
            重新复制；
            
    主从复制的读写分离：
        mysql-proxy --> atlas
        amoeba
        
        AliSQL：
        
    mysqlrouter：
        语句透明路由服务；
        MySQL Router 是轻量级 MySQL 中间件，提供应用与任意 MySQL 服务器后端的透明路由。MySQL Router 可以广泛应用在各种用案例中，比如通过高效路由数据库流量提供高可用性和可伸缩的 MySQL 服务器后端。Oracle 官方出品。

    作业：简单复制、双主复制及半同步复制；
    

    
    
    
    
    
    
    
    master/slave：
        切分：
            垂直切分：切库，把一个库中的多个表分组后放置于不同的物理服务器上；
            水平切分：切表，分散其行至多个不同的table partitions中；
                range, list, hash
                
        sharding(切片)：
            数据库切分的框架：
                cobar
                gizzard
                Hibernat Shards
                HiveDB
                ...
                
        qps: queries per second 
        tps: transactions per second
        
        MHA:
            manager: 10.1.0.6
            
            master: 10.1.0.67
            slave1: 10.1.0.68
            slave2: 10.1.0.69
        
    
    博客作业：
        MHA，以及zabbix完成manager启动；