MySQL 复习笔记

太过爱你忘了你带给我的痛 2024-02-19 13:05 100阅读 0赞

-- ==================建库删库===========================================
    
    -- 显示所有数据库
    SHOW DATABASES;
    
    -- MySQL 创建数据库
    CREATE DATABASE RUNOOB;
    
    -- MySql 删除数据库
    -- drop database RUNOOB;
    
    -- MySQL 选择数据库
    USE RUNOOB;
    
    /*
    MySQL支持多种类型，大致可以分为三类：数值、日期/时间和字符串(字符)类型
    
    1.MySQL支持所有标准SQL数值数据类型。
    
    这些类型包括严格数值数据类型(INTEGER、SMALLINT、DECIMAL和NUMERIC)，
    以及近似数值数据类型(FLOAT、REAL和DOUBLE PRECISION)。
    关键字INT是INTEGER的同义词，关键字DEC是DECIMAL的同义词
    
    2.日期和时间类型
    
    表示时间值的日期和时间类型为DATETIME、DATE、TIMESTAMP、TIME和YEAR。
    每个时间类型有一个有效值范围和一个"零"值，当指定不合法的MySQL不能表示的值时使用"零"值
    
    3.字符串类型
    
    字符串类型指CHAR、VARCHAR、BINARY、VARBINARY、BLOB、TEXT、ENUM和SET
    */
    
    -- ======================建表删表==================================================================================
    
    -- MySQL 创建数据表
    CREATE TABLE IF NOT EXISTS `runoob_tb`(
      `runoob_id` INT UNSIGNED AUTO_INCREMENT, 
      -- AUTO_INCREMENT定义列为自增的属性，一般用于主键，数值会自动加1
      
      `runoob_title` VARCHAR(100) NOT NULL,
      `runoob_author` VARCHAR(40) NOT NULL,
      `submission_date` DATE,
      PRIMARY KEY(`runoob_id`)
      -- PRIMARY KEY关键字用于定义列为主键。 您可以使用多列来定义主键，列间以逗号分隔
      )ENGINE=INNODB DEFAULT CHARSET=utf8;
      
      -- ENGINE 设置存储引擎，CHARSET 设置编码
    
    
    -- MySQL 删除数据表
    -- drop table runoob_tb;
    
    -- ================================增删改查=========================================================
    -- MySQL 插入数据
    INSERT INTO runoob_tb
    (runoob_title,runoob_author,submission_date)
    VALUES
    ("学习PHP","菜鸟教程",NOW());
    
    INSERT INTO runoob_tb
    (runoob_title,runoob_author,submission_date)
    VALUES
    ("学习mysql","菜鸟教程",NOW());
    
    INSERT INTO runoob_tb
    (runoob_title,runoob_author,submission_date)
    VALUES
    ("学习java","菜鸟教程",NOW());
    
    -- NOW() 是一个 MySQL 函数，该函数返回日期和时间
    
    -- INSERT 插入多条数据
    INSERT INTO runoob_tb
    (runoob_title,runoob_author,submission_date)
    VALUES
    ("学习python","菜鸟教程",NOW()),
    ("学习jsp","菜鸟教程",NOW()),
    ("学习c","菜鸟教程",NOW()),
    ("学习c++","菜鸟教程",NOW()),
    ("学习c#","菜鸟教程",NOW());
    
    -- ---------------------------------------------------------------------------
    
    -- MySQL 查询数据
    
    /*
    mysql的 SELECT 语法:
    
    SELECT column_name,column_name
    FROM table_name
    [WHERE Clause]
    [LIMIT N][ OFFSET M]
    
    select * : 返回所有记录
     limit N : 返回 N 条记录
     offset M : 跳过 M 条记录, 默认 M=0, 单独使用似乎不起作用
     limit N,M : 相当于 offset N limit M , 从第 N 条记录开始, 返回 M 条记录
     
    查询语句中你可以使用一个或者多个表，表之间使用逗号(,)分割，并使用WHERE语句来设定查询条件。
    SELECT 命令可以读取一条或者多条记录。
    你可以使用星号（*）来代替其他字段，SELECT语句会返回表的所有字段数据
    你可以使用 WHERE 语句来包含任何条件。
    你可以使用 LIMIT 属性来设定返回的记录数。
    你可以通过OFFSET指定SELECT语句开始查询的数据偏移量。默认情况下偏移量为0
    
    */
    
    -- 查询所有数据(*表示所有列)
    SELECT * FROM runoob_tb;
    
    -- 返回前5条记录
    SELECT	* FROM runoob_tb LIMIT 5;
    -- 从第1条记录开始，返回5条记录
    SELECT * FROM runoob_tb LIMIT 0,5;
    -- 以上这两句话，效果相同
    
    /*
    一共8条记录，要求分页，每页显示3条
    即8/3=2余2
    8%3=2
    
    总记录数totalRecord=8
    每页记录数pageSize=3
    
    求总页数totalPageNum：
    
      总页数=(8%3)+1=3    即每页3条，可以分3页显示
    int totalPageNum = (totalRecord % pageSize) + 1;
    
      总页数=(8+3-1)/3=3  在java中 /相当于取整 ，%是取余
    int totalPageNum = (totalRecord + pageSize  - 1) / pageSize;
    
    三目运算符，(判断总记录数是否能整除，不能整除则取整后加1)
    totalPageNum=(totalRecord%pagesize==0)?totalRecord/pagesize:totalRecord/pagesize+1;
    
    
    --------------
    三目运算符:
      变量 = 表达式1 ? 表达式2 : 表达式3;
      
    计算方法：  
      若 表达式1 为真,变量等于 表达式2
      若 表达式1 为假,变量等于 表达式3
    
    
    ------------------计算页码对应的记录-------------------
    第一页页码begin=1                     1~3
    第二页页码                            4~6
    第三页页码(最末页)end=3               7~8 （不足3条也要占1页）
    
    
    上一页页码last                        3n-6~3n-3
                 
    当前页页码pageNow=2(假设为第二页)     2*3=6，本页最后的记录为第6条记录
    当前页页码pageNow=n                   n*3=3n，本页最后的记录为第3n条记录
                                          即当前的记录为3n-3 ~ 3n 
    
    下一页页码next                        3n+1~最后
    
    
    ----
    总结：
    要求分页显示，每页显示3条记录
    上一页的页码last       对应的记录为  3*pageNow-6 ~ 3*pageNow-3  (即LIMIT 0,3)
    
    设当前页页码为pageNow，对应的记录为  3*pageNow-3 ~ 3*pageNow    (即LIMIT 3,3)
    
    下一页的页码next       对应的记录为  3*pageNow   ~ 3*pageNow+3  (即LIMIT 6,3)
    
    
    
    
    简记：
    第一条： select * from 表名 limit 1;
    最后一条：select * from 表名 order by 表_id desc limit 1
    
    
    */
    
    -- 查询总记录数
    SELECT COUNT(*) FROM runoob_tb
    
    -- 第一页begin,对应第一条记录 
    SELECT * FROM runoob_tb LIMIT 1
    
    -- 最末页end,对应最后一条记录
    SELECT * FROM runoob_tb ORDER BY runoob_id DESC LIMIT 1
    
    -- =========MySQL分页法1=================================
    -- 从第1条记录开始，返回3条记录（即1~3）
    SELECT * FROM runoob_tb LIMIT 0,3;
    -- 从第4条记录开始，返回3条记录（即4~6）
    SELECT * FROM runoob_tb LIMIT 3,3;
    -- 从第7条记录开始，返回3条记录(剩余的不够3条，就返回剩余记录)
    SELECT * FROM runoob_tb LIMIT 6,3;
    
    
    -- ========MySQL分页法2==================================
    -- 跳过0条记录，返回3条记录（即1~3）
    SELECT * FROM runoob_tb LIMIT 3 OFFSET 0;
    -- 跳过3条记录，返回3条记录（即4~6）
    SELECT * FROM runoob_tb LIMIT 3 OFFSET 3;
    -- 跳过6条记录，返回3条记录(剩余的不够3条，就返回剩余记录)
    SELECT * FROM runoob_tb LIMIT 3 OFFSET 6;
    
    
    -- *****************************************************************************************
    /* 模糊查询表数据 
    LIKE 子句
    语法
    SELECT field1, field2,...fieldN 
    FROM table_name
    WHERE field1 LIKE condition1 [AND [OR]] filed2 = 'somevalue'
    
    你可以在 WHERE 子句中指定任何条件。
    你可以在 WHERE 子句中使用LIKE子句。
    你可以使用LIKE子句代替等号 =。
    LIKE 通常与 % 一同使用，类似于一个元字符的搜索。
    你可以使用 AND 或者 OR 指定一个或多个条件。
    你可以在 DELETE 或 UPDATE 命令中使用 WHERE...LIKE 子句来指定条件
    
    ----------------------------------------------
    like 模糊匹配，会与 % 和 _ 结合使用。
    
    '%a'     //以a结尾的数据
    'a%'     //以a开头的数据
    '%a%'    //含有a的数据
    '_a_'    //三位且中间字母是a的
    '_a'     //两位且结尾字母是a的
    'a_'     //两位且开头字母是a的
    
    -----------------------------------------------
    */
    -- 以p结尾的数据,%号表示任意长度的任意字符
    SELECT * FROM runoob_tb WHERE runoob_title LIKE "%p";  
    -- 以p开头的数据,%号表示任意长度的任意字符
    SELECT * FROM runoob_tb WHERE runoob_title LIKE "p%";  
    -- 模糊查询时不区分大小写，所以能查出python和PHP
    
    
    -- 以c开头的数据,_下划线表示1个长度的任意字符
    SELECT * FROM runoob_tb WHERE runoob_title LIKE "c_";  
    
    -- 以p结尾的数据,2个_下划线表示2个长度的任意字符
    SELECT * FROM runoob_tb WHERE runoob_title LIKE "__p"; 
    
    
    -- 模糊查询首字符任意，第二个字符为a，余下为任意长度的任意字符
    SELECT * FROM runoob_tb WHERE runoob_title LIKE "_a%"; 
    
    
    -- *********************************************************************************
    -- 查询表字段数据 
    SELECT runoob_title FROM runoob_tb;
    /* 查询表字段下where条件数据 */
    SELECT * FROM runoob_tb WHERE runoob_title = "PHP";  
    
    /*
    MySQL WHERE 子句
    语法
    SELECT field1, field2,...fieldN FROM table_name1, table_name2...
    [WHERE condition1 [AND [OR]] condition2.....
    
    查询语句中你可以使用一个或者多个表，表之间使用逗号, 分割，并使用WHERE语句来设定查询条件。
    你可以在 WHERE 子句中指定任何条件。
    你可以使用 AND 或者 OR 指定一个或多个条件。
    WHERE 子句也可以运用于 SQL 的 DELETE 或者 UPDATE 命令。
    WHERE 子句类似于程序语言中的 if 条件，根据 MySQL 表中的字段值来读取指定的数据
    ------------------------------------------------------------------------------------------------
    =	等号，检测两个值是否相等，如果相等返回true	(A = B) 返回false。
    
    <>, !=	不等于，检测两个值是否相等，如果不相等返回true	(A != B) 返回 true。
    
    >    大于号，检测左边的值是否大于右边的值, 如果左边的值大于右边的值返回true	(A > B) 返回false。
    
    <    小于号，检测左边的值是否小于右边的值, 如果左边的值小于右边的值返回true	(A < B) 返回 true。
    
    >=   大于等于号，检测左边的值是否大于或等于右边的值, 如果左边的值大于或等于右边的值返回true	(A >= B) 返回false。
    
    <=   小于等于号，检测左边的值是否小于于或等于右边的值, 如果左边的值小于或等于右边的值返回true	(A <= B) 返回 true
    
    ------------------------------------------------------------------------------------------------------------------------
    
    */
    
    SELECT * FROM runoob_tb;
    SELECT * FROM runoob_tb WHERE runoob_author='菜鸟教程';
    SELECT runoob_title FROM runoob_tb;
    
    /* 查询表下字段范围数据 */
    SELECT * FROM runoob_tb WHERE runoob_id BETWEEN "2" AND "5";
    /* 查询去重值 */
    SELECT DISTINCT runoob_author FROM runoob_tb;
    /*查询表下范围条件数据*/
    SELECT * FROM runoob_tb WHERE runoob_author="runoob" AND submission_date > "2018-11-02";
    /* 查询表下条件不同值 */
    SELECT * FROM runoob_tb WHERE runoob_author="runoob" OR submission_date < "2018-11-05";
    
    -- 按runoob_title升序排序
    SELECT * FROM runoob_tb ORDER BY runoob_title;
    
    -- 按runoob_title降序排序
    SELECT * FROM runoob_tb ORDER BY runoob_title DESC;
    
    -- 查询前6条数据
    SELECT * FROM runoob_tb LIMIT 6;
    
    -- 查询某一列的值，然后起别名
    SELECT runoob_title AS "技术" FROM runoob_tb;
    
    
    
    -- ===================================================================================
    -- 查询某个库所有表
    SELECT * FROM information_schema.`TABLES`
    WHERE table_schema = 'runoob'
    
    -- 查询某个库所有表的字段
    SELECT * FROM information_schema.COLUMNS
    WHERE table_schema = 'runoob'
    
    -- 查询所有表的注释和字段注释
    SELECT
    a.table_name 表名,
    a.table_comment 表说明,
    b.COLUMN_NAME 字段名,
    b.column_comment 字段说明,
    b.column_type 字段类型,
    b.column_key 约束
    FROM
    information_schema. TABLES a
    LEFT JOIN information_schema. COLUMNS b ON a.table_name = b.TABLE_NAME
    WHERE
    a.table_schema = 'runoob'
    ORDER BY
    a.table_name
    
    
    --  查询某个数据库中所有表名
    SELECT table_name FROM information_schema.tables WHERE table_schema='runoob' AND table_type='base table';
    
    -- 查询指定数据库中指定表的所有字段名column_name
    SELECT column_name FROM information_schema.columns WHERE table_schema='runoob' AND table_name='runoob_tb'
    
    
    -- ========================================================================================================
    -- -----------------------------------------------------------------
    
    
    
    CREATE TABLE w3cschool_tb(
      id INT NOT NULL AUTO_INCREMENT,
      title VARCHAR(100) NOT NULL,
      author VARCHAR(40) NOT NULL,
      sub_date DATE,
      PRIMARY KEY (id)
    );
    
    
    INSERT INTO w3cschool_tb
    (title, author, sub_date)
     VALUES
    ("Learn PHP", "John Poul", NOW());
    
    
    INSERT INTO w3cschool_tb
    (title, author, sub_date)
     VALUES
    ("Learn MySQL", "Abdul S", NOW()),
    ("JAVA Tutorial", "Sanjay", '2007-05-06');
    
    
    
    -- ---------------------------------------------------------------------
    -- UPDATE 更新
    /*
    语法
    UPDATE table_name SET field1=new-value1, field2=new-value2
    [WHERE Clause]
    update 表名称 set 列名称=新值 where 更新条件;
    
    你可以同时更新一个或多个字段。
    你可以在 WHERE 子句中指定任何条件
    
    */
    
    UPDATE runoob_tb 
    SET runoob_title = '学C++' 
    WHERE runoob_id = 7;
    
    SELECT * FROM runoob_tb WHERE runoob_id = 7;
    
    -- --------------------------------------------------------------
    /*
    delete  删除
    
    语法
    DELETE FROM table_name [WHERE Clause]
    
    如果没有指定 WHERE 子句，MySQL 表中的所有记录将被删除。
    可以在 WHERE 子句中指定任何条件
    可以在单个表中一次性删除记录
    
    */
    
    -- 删除 id 为 7 的行
    DELETE FROM runoob_tb WHERE runoob_id = 7;
    
    -- 删除所有 `sex` != '男'的行
    DELETE FROM USER WHERE user.`sex` != '男';
    
    
    -- ======================================================================================
    /*
    MySQL UNION 操作符 （全连接查询）
    
    MySQL UNION 操作符用于连接两个以上的 SELECT 语句的结果组合到一个结果集合中。多个 SELECT 语句会删除重复的数据。
    
    MySQL UNION 操作符语法格式：
    
    SELECT expression1, expression2, ... expression_n
    FROM tables
    [WHERE conditions]
    UNION [ALL | DISTINCT]
    SELECT expression1, expression2, ... expression_n
    FROM tables
    [WHERE conditions];
    
    参数
    expression1, expression2, ... expression_n: 要检索的列
    tables: 要检索的数据表。
    WHERE conditions: 可选， 检索条件。
    
    DISTINCT: 可选，删除结果集中重复的数据。默认情况下 UNION 操作符已经删除了重复数据，所以 DISTINCT 修饰符对结果没啥影响
    
    ALL: 可选，返回所有结果集，包含重复数据
    --------------------------------------
    UNION 语句：用于将不同表中相同列中查询的数据展示出来；（不包括重复数据）
    
    UNION ALL 语句：用于将不同表中相同列中查询的数据展示出来；（包括重复数据）
    ----------------------------
    */
    SELECT * FROM Websites;
    SELECT * FROM app;
    
    -- 从 "Websites" 和 "app" 表中选取所有不同的country（只有不同的值）
    SELECT country FROM Websites
    UNION
    SELECT country FROM app
    ORDER BY country;
    
    -- 使用 UNION ALL 从 "Websites" 和 "app" 表中选取所有的country（也有重复的值）
    SELECT country FROM Websites
    UNION ALL
    SELECT country FROM app
    ORDER BY country;
    
    
    -- 使用 UNION ALL 从 "Websites" 和 "app" 表中选取所有的中国(CN)的数据（也有重复的值）
    SELECT country, NAME FROM Websites
    WHERE country='CN'
    UNION ALL
    SELECT country, app_name FROM app
    WHERE country='CN'
    ORDER BY country;
    
    -- ==============================================================================================
    
    /*
    MySQL 排序
    
    SELECT field1, field2,...fieldN table_name1, table_name2...
    ORDER BY field1, [field2...] [ASC [DESC]]
    
    可以使用任何字段来作为排序的条件，从而返回排序后的查询结果。
    可以设定多个字段来排序。
    可以使用 ASC 或 DESC 关键字来设置查询结果是按升序或降序排列。 默认情况下，它是按升序排列
    可以添加 WHERE...LIKE 子句来设置条件。
    
    */
    
    
     SELECT * FROM runoob_tb ORDER BY submission_date ASC;
    
     SELECT * FROM runoob_tb ORDER BY submission_date DESC;
     
     -- ========================================================================================
     
     /*
     GROUP BY 语句
     
     SELECT column_name, function(column_name)
    FROM table_name
    WHERE column_name operator value
    GROUP BY column_name;
    
    
     
     */
     
     
    /* 
     SET NAMES utf8;
    SET FOREIGN_KEY_CHECKS = 0;
    
    -- ----------------------------
    --  Table structure for `employee_tbl`
    -- ----------------------------
    DROP TABLE IF EXISTS `employee_tbl`;
    CREATE TABLE `employee_tbl` (
      `id` int(11) NOT NULL,
      `name` char(10) NOT NULL DEFAULT '',
      `date` datetime NOT NULL,
      `singin` tinyint(4) NOT NULL DEFAULT '0' COMMENT '登录次数',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    --  Records of `employee_tbl`
    -- ----------------------------
    BEGIN;
    INSERT INTO `employee_tbl` VALUES ('1', '小明', '2016-04-22 15:25:33', '1'), ('2', '小王', '2016-04-20 15:25:47', '3'), ('3', '小丽', '2016-04-19 15:26:02', '2'), ('4', '小王', '2016-04-07 15:26:14', '4'), ('5', '小明', '2016-04-11 15:26:40', '4'), ('6', '小明', '2016-04-04 15:26:54', '2');
    COMMIT;
    
    SET FOREIGN_KEY_CHECKS = 1;
     
     
     */
     
     SELECT * FROM employee_tbl;
     
     SELECT NAME, COUNT(*) FROM   employee_tbl GROUP BY NAME;
     
     
    -- 使用 WITH ROLLUP
    -- WITH ROLLUP 可以实现在分组统计数据基础上再进行相同的统计（SUM,AVG,COUNT…）。
    
    SELECT NAME, SUM(singin) AS singin_count FROM  employee_tbl GROUP BY NAME WITH ROLLUP;
    
    
    -- **********************************************************************************************
    /*
    Mysql 连接查询
    
     按照功能大致分为如下三类：
    
    INNER JOIN（内连接,或等值连接）：获取两个表中字段匹配关系的记录。
    LEFT JOIN（左外连接）：获取左表所有记录，即使右表没有对应匹配的记录。
    RIGHT JOIN（右外连接）： 与 LEFT JOIN 相反，用于获取右表所有记录，即使左表没有对应匹配的记录
    
    内连接,或等值连接：INNER JOIN ... ON ...
    左连接查询：left join ... on ...
    右连接查询：right join ... on ...
    
    格式：
    select 字段 
    from 表1 
    right join 表2 
    on  条件 (一般为表1与表2的关联条件)
    
    
    
    */
    -- 内连接
    SELECT user.*,orders.`number` 
    FROM USER 
    INNER JOIN orders
    ON user.`id` = orders.`user_id`;
    
    -- 内连接：获取两个表中字段匹配关系的记录
    SELECT a.runoob_id, a.runoob_author, b.runoob_count 
    FROM runoob_tb a 
    INNER JOIN tcount_tb b 
    ON a.runoob_author = b.runoob_author;
    
    -- 以上 SQL 语句等价于
    SELECT a.runoob_id, a.runoob_author, b.runoob_count 
    FROM runoob_tb a, tcount_tb b 
    WHERE a.runoob_author = b.runoob_author;
    
    
    -- ========================
    
    -- 左外连接
    
    /*
    
    LEFT JOIN 会读取左边数据表的全部数据，即便右边表无对应数据
    
    LEFT JOIN读取的数据除了公共部分外，还包括左边全部数据。
    */
    
    SELECT a.`runoob_id`,a.`runoob_author`,b.`runoob_count`
    FROM runoob_tb a
    LEFT JOIN tcount_tb b
    ON a.`runoob_author`=b.`runoob_author`;
    
    -- 左外连接
    SELECT user.*,orders.`number` 
    FROM USER 
    LEFT JOIN orders 
    ON user.`id` = orders.`user_id`
    
    
    
    -- =================================
    
    -- 右外连接
    /*
    RIGHT JOIN 会读取右边数据表的全部数据，即便左边边表无对应数据。
    RIGHT JOIN读取的数据除了公共部分外，还包括右边全部数据
    */
    
    SELECT a.`runoob_id`,a.`runoob_author`,b.`runoob_count`
    FROM runoob_tb a
    RIGHT JOIN tcount_tb b
    ON a.`runoob_author`=b.`runoob_author`;
    
    
    -- *********************************************************************************
    
    -- -------------------------------------------------
    /*
    NULL 值处理
    
    MySQL提供了三大运算符:
    
    IS NULL: 当列的值是 NULL,此运算符返回 true。
    IS NOT NULL: 当列的值不为 NULL, 运算符返回 true。
    <=>: 比较操作符（不同于=运算符），当比较的的两个值为 NULL 时返回 true
    
    
    */
    
    
    CREATE TABLE runoob_test_tbl
    (
    runoob_author VARCHAR(40) NOT NULL,
    runoob_count  INT
    );
    
    
    INSERT INTO runoob_test_tbl (runoob_author, runoob_count) VALUES ('RUNOOB', 20);
    INSERT INTO runoob_test_tbl (runoob_author, runoob_count) VALUES ('菜鸟教程', NULL);
    INSERT INTO runoob_test_tbl (runoob_author, runoob_count) VALUES ('Google', NULL);
    INSERT INTO runoob_test_tbl (runoob_author, runoob_count) VALUES ('FK', 20);
    
    /*where 限定某列为空null ,不能用=等号限定，
      而是需要用is null 操作符判断
    */
    SELECT * FROM  runoob_test_tbl WHERE runoob_count =NULL;
    SELECT * FROM  runoob_test_tbl WHERE runoob_count !=NULL;
    -- 你可以看到 = 和 != 运算符是不起作用的
    --  必须使用is null 或 is not null 来判断
    SELECT * FROM  runoob_test_tbl WHERE runoob_count IS NULL;
    SELECT * FROM  runoob_test_tbl WHERE runoob_count IS NOT NULL;
    
    
    -- *************************************************************************************
    /*
    MySQL 正则表达式
    
    MySQL除了可以通过 LIKE ...% 来进行模糊匹配之外，
    还可以使用正则表达式
    
     用法如下：(在where 子句中使用REGEXP 正则表达式)
     
      SELECT name FROM person_tbl WHERE name REGEXP '^st';
      
      
    常用的REGEXP 操作符：
      
    ^	匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。
    $	匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。
    .	匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
    [...]	字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
    [^...]	负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'。
    p1|p2|p3	匹配 p1 或 p2 或 p3。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
    *	匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
    +	匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
    {n}	n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
    {n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。
    
    
    */
    
    -- 查找以'p'为结尾的所有数据：
    SELECT * FROM runoob_tb WHERE runoob_title REGEXP 'p$';
    
    -- 查找以'j'为开头的所有数据
    SELECT * FROM runoob_tb WHERE runoob_title REGEXP '^j';
    
    -- 包含'a'字符串的所有数据：
    SELECT * FROM runoob_tb WHERE runoob_title REGEXP 'a';
    
    
    
    -- ********************************************************************************
    
    -- 等值连接（where子句中使用=等号为限定条件）
    SELECT *
    FROM runoob_tb a, tcount_tb b 
    WHERE a.runoob_author = b.runoob_author;
    
    
    -- 自然连接NATURAL JOIN （自然连接只考虑属性相同的元组对）
    SELECT * FROM runoob_tb NATURAL JOIN tcount_tb;
    
    
    -- 笛卡尔积 （使用,逗号连接两个表 ，mysql默认的连接就是笛卡尔积连接）
    -- 即表A中的每一个元素，都对表B中的所有元素做连接运算
    -- 假设A中有m 个元组，B中有n个元组，则笛卡尔乘积= m*n 个元组
    
    SELECT * FROM runoob_tb , tcount_tb;
    
    -- **********************************************************************************
    
    /*
    
    MySQL 事务主要用于处理操作量大，复杂度高的数据
    
    1.在 MySQL 中只有使用了 Innodb 数据库引擎的数据库或表才支持事务。
    2.事务处理可以用来维护数据库的完整性，保证成批的 SQL 语句要么全部执行，要么全部不执行。
    3.事务用来管理 insert,update,delete 语句
    
    事务是必须满足4个条件（ACID）：
    	原子性（Atomicity，或称不可分割性）
    	一致性（Consistency）
    	隔离性（Isolation，又称独立性）
    	持久性（Durability）。
    
    事务控制语句：
    BEGIN或START TRANSACTION；显式地开启一个事务；
    
    COMMIT；也可以使用COMMIT WORK，不过二者是等价的。COMMIT会提交事务，并使已对数据库进行的所有修改成为永久性的；
    
    ROLLBACK；有可以使用ROLLBACK WORK，不过二者是等价的。回滚会结束用户的事务，并撤销正在进行的所有未提交的修改；
    
    SAVEPOINT identifier；SAVEPOINT允许在事务中创建一个保存点，一个事务中可以有多个SAVEPOINT；
    
    RELEASE SAVEPOINT identifier；删除一个事务的保存点，当没有指定的保存点时，执行该语句会抛出一个异常；
    
    ROLLBACK TO identifier；把事务回滚到标记点；
    
    SET TRANSACTION；用来设置事务的隔离级别。InnoDB存储引擎提供事务的隔离级别有READ UNCOMMITTED、READ COMMITTED、REPEATABLE READ和SERIALIZABLE。
    
    ------------------------------------------------
    
    MYSQL 事务处理主要有两种方法：
    1、用 BEGIN, ROLLBACK, COMMIT来实现
    
    BEGIN 开始一个事务
    ROLLBACK 事务回滚
    COMMIT 事务确认
    2、直接用 SET 来改变 MySQL 的自动提交模式:
    
    SET AUTOCOMMIT=0 禁止自动提交
    SET AUTOCOMMIT=1 开启自动提交	
    
    */
    
    # 创建数据表
    CREATE TABLE runoob_transaction_test( id INT(5)) ENGINE=INNODB;  
    
    SELECT * FROM runoob_transaction_test;
    
    #开始事务
    BEGIN;
    
    #可以将多个增删改操作写入一个事务中
    INSERT INTO runoob_transaction_test VALUE(1);
    INSERT INTO runoob_transaction_test VALUE(2);
    
    ROLLBACK; -- 回滚生效，因为数据还未提交
    
    INSERT INTO runoob_transaction_test VALUE(7);
    INSERT INTO runoob_transaction_test VALUE(8);
    
    #提交事务后，就不能再回滚  
    COMMIT;
    
    -- ROLLBACK; 回滚无效，因为数据已经提交
    
    -- 再次查询，发现只有7,8插入生效，1,2因为回滚插入失败
    SELECT * FROM runoob_transaction_test;
    
    -----------------------------------------
    
    #开始事务
    BEGIN;
    INSERT INTO runoob_transaction_test VALUES(7);
    # 回滚
    ROLLBACK;   
    # 因为回滚所以数据没有插入
    SELECT * FROM runoob_transaction_test;   
    
    
    -- ******************************************************************************
    /* alter 修改表结构  */
    
    CREATE TABLE testalter_tb
    (
    i INT,
    c CHAR(1)
    );
    
    -- 删除列 
    ALTER TABLE testalter_tb
    DROP i;
    
    -- 添加列
    ALTER TABLE testalter_tb
    ADD i INT;
    
    -- 指定新增字段的位置,关键字 FIRST (设定位第一列)
    ALTER TABLE testalter_tb DROP i;
    ALTER TABLE testalter_tb ADD i INT FIRST;
    
    -- 指定新增字段的位置,AFTER 字段名（设定位于某个字段之后）
    ALTER TABLE testalter_tb DROP i;
    ALTER TABLE testalter_tb ADD i INT AFTER c;
    
    
    -- 修改字段类型及名称
    ALTER TABLE testalter_tb MODIFY c CHAR(10);
    
    
    -- 在 CHANGE 关键字之后，紧跟着的是你要修改的字段名，然后指定新字段名及类型
    ALTER TABLE testalter_tb CHANGE i  j BIGINT;
    
    ALTER TABLE testalter_tb CHANGE j i INT;
    
    -- 修改非空和默认值
    
    ALTER TABLE testalter_tb
    MODIFY j BIGINT NOT NULL DEFAULT 100;
    
    -- 若不设置字段的默认值，则mysql会自动设置字段默认值为null 
    
    ALTER TABLE testalter_tb ALTER i SET DEFAULT 1000;
    
    
    -- 使用 ALTER 命令及 DROP子句来删除字段的默认值
    ALTER TABLE testalter_tb ALTER i DROP DEFAULT;
    
    -- 修改数据表类型(修改存储引擎),将表 testalter_tbl 的类型修改为 MYISAM 
    
    ALTER TABLE testalter_tb ENGINE = MYISAM;
    
    -- 修改表名
    ALTER TABLE testalter_tb RENAME TO alter_tb;
    
    -- 删除外键约束：keyName是外键别名
    
    -- alter table tableName drop foreign key keyName;
    
    ALTER TABLE orders DROP FOREIGN KEY fk_1;
    
    
    -- **************************************************************************************
    /*
    MySQL 索引
    
    通过索引可以更加快速高效地查询数据。
    用户无法看到索引，它们只能被用来加速查询
    索引也是一张表，该表保存了主键与索引字段，并指向实体表的记录
    
    索引可以大大提高MySQL的检索速度。
    
    索引也会有它的缺点：
       索引会降低更新表的速度，
       如对表进行INSERT、UPDATE和DELETE。
       因为更新表时，MySQL不仅要保存数据，还要保存一下索引文件
    */
    
    -- 创建普通索引
    /*
    语法：
    
    create index  索引名
    on  表名(表的主键)
    
    */
    
    -- 创建普通索引
    CREATE INDEX  runoob_tb_index
    ON runoob_tb (runoob_id);
    
    -- 用户无法看到索引，它们只能被用来加速查询
    SELECT * FROM runoob_tb;
    
    
    /*
    在修改表结构时，添加索引
    语法：
    alter table 表名
    add index  索引名(表的主键)
    */
    -- 在修改表结构时，添加索引
    ALTER TABLE websites 
    ADD INDEX websites_index(id);
    
    
    /*
    创建表的时候直接指定索引
    语法：
    CREATE TABLE 表名(
     列名  类型  约束,
     列名  类型  约束,
     列名  类型  约束,
     
     index  索引名(列名)
    );
    */
    
    -- drop table mytable;
    
    CREATE TABLE mytable(  
    ID INT NOT NULL,   
    username VARCHAR(16) NOT NULL,  
    INDEX   mytable_index (username)
    );  
    
    
    /*
    删除索引
    
    法1：
    DROP INDEX 索引名 ON  表名; 
    
    法2:
    alter table 表名
    drop index  索引名
    */
    
    
    DROP INDEX mytable_index ON mytable;
    
    
    ALTER TABLE websites
    DROP INDEX websites_index;
    
    
    /*
    创建唯一索引
    CREATE  UNIQUE INDEX  索引名
    ON 表名 (表的主键或其他列名);
    
    唯一索引：
    索引列的值必须唯一，但允许有空值。
    如果是组合索引，则列值的组合必须唯一
    
    */
    
    CREATE  UNIQUE INDEX  websites_index
    ON websites (id);
    
    DROP INDEX websites_index ON websites;
    
    -- ==============================================================================
    
    
    /*
    视图是基于 SQL 语句的结果集的可视化的表。
    视图是虚拟的表，本身不包含数据，也就不能对其进行索引操作。
    对视图的操作和对普通表的操作一样
    */
    -- 创建视图
    CREATE VIEW top_2_runoob_tb_view AS
    SELECT runoob_id,runoob_title
    FROM runoob_tb
    WHERE runoob_id < 3;	
     
     
    -- 查询视图
    SELECT * FROM top_2_runoob_tb_view;
     
    -- 撤销视图
    DROP VIEW top_2_runoob_tb_view;
    
    
    -- ***********************************************************