现在位置: 首页 > 博客文章 > 电脑相关 > IT开发 > 数据库 > MySQL > 正文
小 中 大
MySQL5.x.x存储过程简单入门
2015年02月01日 14:29:32 ⁄ MySQL ⁄ 共 18057字 ⁄ 暂无评论 ⁄ 被围观 3,625次

存储过程是一种存储在数据库中的程序，就像是正规语言中的子程序。我们常用的操作数据库语言 SQL 语句在执行的时候需要要先编译，然后执行，而存储过程（Stored Procedure）是一组为了完成特定功能的 SQL 语句集，经编译后存储在数据库中，用户通过指定存储过程的名字并给定参数（如果该存储过程带有参数的话）来调用执行它。

MySQL 支持的“ routines（例程）”有两种：一种是我们说的存储过程， 另外一种是在其他 SQL 语句中可以返回值的函数，使用起来和 MySQL 预装载的函数一样，如 pi()。一个存储过程包括名字，参数列表，以及可以包括很多 SQL 语句的 SQL 语句集。

那么什么情况下需要用到存储过程呢？当你需要处理的是需要检查、循环、多语句但没有用户交互的重复性任务时，你就可以使用保存在服务器上的存储过程来完成。这样在执行任务的每一步时，服务器和客户端之间就没那么多的信息来往了。

想要在安装的 MySQL 上测试存储过程，必须得保证安装的 MySQL 版本是 5.0 以上，因为 5.0 之前的 MySQL版本不支持存储过程的功能，由于其它数据库都有存储过程，这使得 5.0 之前的 MySQL 版本的使用大打折扣。因此，自 MySQL 5.0 之后的版本加入了存储过程这一功能。所以在学习存储过程之前，先检查一下 MySQL 的版本。

Code   ViewPrint
  1. mysql> select version();  
  2. +-----------+  
  3. | version() |  
  4. +-----------+  
  5. | 5.7.4-m14 |  
  6. +-----------+  
  7. 1 row in set (0.00 sec)  

或者用下面的语句也可以查询版本：

Code   ViewPrint
  1. mysql> show variables like 'version';  
  2. +---------------+-----------+  
  3. | Variable_name | Value     |  
  4. +---------------+-----------+  
  5. | version       | 5.7.4-m14 |  
  6. +---------------+-----------+  
  7. 1 row in set (0.00 sec)  

注意：MySQL 语句对大小写不敏感，因此语句也可以是大写的，比如 SELECT VERSION();

创建一个测试数据库 test，用来学习存储过程。

Code   ViewPrint
  1. mysql> create database test;  
  2. Query OK, 1 row affected (0.00 sec)  
  3.   
  4. mysql> use test;  
  5. Database changed  

在 test 数据库中，创建一张表 t，并插入一条简单的数据。

Code   ViewPrint
  1. mysql> create table t (s1 int);  
  2. Query OK, 0 rows affected (0.05 sec)  
  3.   
  4. mysql> insert into t values (5);  
  5. Query OK, 1 row affected (0.00 sec)  

接下来，选择分隔符。分隔符是通知 mysql 客户端，已经完成输入一个 SQL 语句的字符或字符串符号。一直以来，我们都使用分号“； ”，但在存储过程中，这会产生不少问题，因为存储过程中有许多语句，所以每一个都需要一个分号。因此需要选择一个不太可能出现在 SQL 语句或程序中的字符串作为分隔符。比如“|”、“@”、“//”等。在这里就使用“//”。设置分隔符的 SQL 语句如下：
mysql> delimiter //

下面，关键的时刻来了，创建第一个存储过程吧。

Code   ViewPrint
  1. mysql> create procedure p1 () select * from t;//  
  2. Query OK, 0 rows affected (0.00 sec)  

解释上面的存储过程：

创建存储过程的关键字是 create procedure，存储过程名是 p1（备注：存储过程名就像 SQL 语句一样，对大小写不敏感，因此‘P1’和‘p1’是同一个名字，在同一个数据库中不能给两个存储过程取相同的名字，因为这样将会导致重载。某些DBMS允许重载（Oracle支持），但是MySQL不支持。 可以采取“数据库名.存储过程名”这样的折中方法，如“ test.p1”。存储过程名可以分开， 它可以包括空格符，其长度限制为 64 个字符，但注意不要使用 MySQL 内建函数的名字。），语句中 p1 后面的括号是参数列表，没有参数的情况下括号需保留。括号后到“//”前，是存储过程的主体。

接下来就调用上面创建的存储过程。

Code   ViewPrint
  1. mysql> call p1 ()//  
  2. +------+  
  3. | s1   |  
  4. +------+  
  5. |    5 |  
  6. +------+  
  7. 1 row in set (0.00 sec)  
  8.   
  9. Query OK, 0 rows affected (0.00 sec)  

反映存储过程特性的子句——特征子句。

Code   ViewPrint
  1. mysql> create procedure p2()   
  2.     -> LANGUAGE SQL  /* 说明下面过程的主体使用SQL语言编写 */
  3.     -> NOT DETERMINISTIC  /* 传递给系统的信息 */
  4.     -> SQL SECURITY DEFINER  /* 详细解释继续向下看 */
  5.     -> COMMENT 'A Procedure'  /* 可选的注释说明 */
  6.     -> select CURRENT_DATE, RAND() from t//  
  7. Query OK, 0 rows affected (0.00 sec)  
  8.   
  9. mysql> call p2()//  
  10. +--------------+---------------------+  
  11. | CURRENT_DATE | RAND()              |  
  12. +--------------+---------------------+  
  13. | 2015-01-31   | 0.19683208334895977 |  
  14. +--------------+---------------------+  
  15. 1 row in set (0.00 sec)  
  16.   
  17. Query OK, 0 rows affected (0.00 sec)  

SQL SECURITY，可以定义为 SQL SECURITY DEFINER 或 SQL SECURITY INVOKER。 这就进入了权限控制的领域了。SQL SECURITY DEFINER 意味着在调用时检查创建过程用户的权限，SQL SECURITY INVOKER 意味着一直会检查用户的权限。使用 SQL SECURITY DEFINER 指令告诉 MySQL 服务器检查创建过程的用户就可以了，当过程已经被调用，就不检查执行调用过程的用户了。而SQL SECURITY INVOKER 则是告诉服务器在这一步仍然要检查调用者的权限。

现在，详细解释一下存储过程的参数。

Code   ViewPrint
  1. 1. CREATE PROCEDURE p() ...  
  2. 2. CREATE PROCEDURE p([IN] name data-type) ...  
  3. 3. CREATE PROCEDURE p(OUT name data-type) ...  
  4. 4. CREATE PROCEDURE p(INOUT name data-type) ...  

上面的参数中，IN 是可以省略的，因为存储过程如果有参数，默认为 IN。IN 输入参数，表示该参数的值必须在调用存储过程时指定，在存储过程中修改该参数的值不能被返回，还是为原来的值；OUT 输出参数，该值可以在存储过程内部被改变，并可返回；INOUT 输入输出参数，该值在调用时指定，在存储过程内部被改变后，可以返回，为改变后的值。下面看几个通俗易懂的详细例子。

IN 输入的例子：

Code   ViewPrint
  1. mysql> create procedure demo_in_parameter(IN p_in int)  
  2.     -> begin  
  3.     -> select p_in;  
  4.     -> set p_in=2;  
  5.     -> select p_in;  
  6.     -> end //  
  7. Query OK, 0 rows affected (0.00 sec)  
  8.   
  9. mysql> set @p_in=1 //  
  10. Query OK, 0 rows affected (0.00 sec)  
  11.   
  12. mysql> call demo_in_parameter(@p_in) //  
  13. +------+  
  14. | p_in |  
  15. +------+  
  16. |    1 |  
  17. +------+  
  18. 1 row in set (0.00 sec)  
  19.   
  20. +------+  
  21. | p_in |  
  22. +------+  
  23. |    2 |  
  24. +------+  
  25. 1 row in set (0.00 sec)  
  26.   
  27. Query OK, 0 rows affected (0.00 sec)  
  29. mysql> select @p_in //
  30. +--------+
  31. | @p_in |
  32. +--------+
  33. |         1 |
  34. +--------+
  35. 1 row in set (0.00 sec)

OUT 输出的例子：

Code   ViewPrint
  1. mysql> create procedure demo_out_parameter(OUT p_out int)  
  2.     -> begin  
  3.     -> select p_out;  
  4.     -> set p_out=2;  
  5.     -> select p_out;  
  6.     -> end //  
  7. Query OK, 0 rows affected (0.00 sec)  
  8.   
  9. mysql> set @p_out=1 //  
  10. Query OK, 0 rows affected (0.00 sec)  
  11.   
  12. mysql> call demo_out_parameter(@p_out) //  
  13. +-------+  
  14. | p_out |  
  15. +-------+  
  16. |  NULL |  
  17. +-------+  
  18. 1 row in set (0.00 sec)  
  19.   
  20. +-------+  
  21. | p_out |  
  22. +-------+  
  23. |     2 |  
  24. +-------+  
  25. 1 row in set (0.00 sec)  
  26.   
  27. Query OK, 0 rows affected (0.00 sec)  
  28. w
  29. mysql> select @p_out //
  30. +----------+ 
  31. | @p_out | 
  32. +----------+ 
  33. |           2 | 
  34. +----------+ 
  35. 1 row in set (0.00 sec) 

INOUT 输入输出的例子：

Code   ViewPrint
  1. mysql> create procedure demo_inout_parameter(INOUT p_inout int)  
  2.     -> begin  
  3.     -> select p_inout;  
  4.     -> set p_inout=2;  
  5.     -> select p_inout;  
  6.     -> end //  
  7. Query OK, 0 rows affected (0.00 sec)  
  8.   
  9. mysql> set @p_inout=1 //  
  10. Query OK, 0 rows affected (0.00 sec)  
  11.   
  12. mysql> call demo_inout_parameter(@p_inout) //  
  13. +---------+  
  14. | p_inout |  
  15. +---------+  
  16. |       1 |  
  17. +---------+  
  18. 1 row in set (0.00 sec)  
  19.   
  20. +---------+  
  21. | p_inout |  
  22. +---------+  
  23. |       2 |  
  24. +---------+  
  25. 1 row in set (0.00 sec)  
  26.   
  27. Query OK, 0 rows affected (0.00 sec)  
  28.   
  29. mysql> select @p_inout //  
  30. +----------+  
  31. | @p_inout |  
  32. +----------+  
  33. |        2 |  
  34. +----------+  
  35. 1 row in set (0.00 sec)  

在这里，顺便说一下 MySQL 存储过程的注释方式，主要有三种：

-- 需要注释的部分：用于单行注释；

# 需要注释的部分：用于单行注释；

/* 需要注释的部分 */：用户多行注释；

注意：不管单行和多行的注释，如果把分隔符“//”写到注释中，则分隔符失效，需要在注释外重新写分隔符。另外，“--”和“#”的单行注释风格和 C 或 JAVA 等语言的“//”注释一样，不过最好在标记和被注释的内容间加个空格。

MySQL 存储过程中变量的声明和赋值：

用关键字 declare 声明变量，用 set 关键字给变量赋值。

MySQL 存储过程的控制语句：

1. 作用域问题。

Code   ViewPrint
  1. mysql> create procedure p11()  
  2.     -> begin  
  3.     -> declare xx char(5) default 'outer';  
  4.     -> begin  
  5.     -> declare xx char(5) default 'inner';  
  6.     -> select xx;  
  7.     -> end;  
  8.     -> select xx;  
  9.     -> end;  
  10.     -> //  
  11. Query OK, 0 rows affected (0.00 sec)  
  12.   
  13. mysql> call p11() //  
  14. +-------+  
  15. | xx    |  
  16. +-------+  
  17. | inner |  
  18. +-------+  
  19. 1 row in set (0.00 sec)  
  20.   
  21. +-------+  
  22. | xx    |  
  23. +-------+  
  24. | outer |  
  25. +-------+  
  26. 1 row in set (0.00 sec)  
  27.   
  28. Query OK, 0 rows affected (0.00 sec)  

2. 条件语句 IF...THEN... 和 IF...THEN...  ELSE...

Code   ViewPrint
  1. mysql> select * from t //  
  2. +------+  
  3. | s1   |  
  4. +------+  
  5. |    5 |  
  6. |    5 |  
  7. |    5 |  
  8. |    5 |  
  9. +------+  
  10. 4 rows in set (0.00 sec)  
  11.   
  12. mysql> create procedure p12(IN pp int)  
  13.     -> begin  
  14.     -> declare vv int;  
  15.     -> set vv=pp+1;  
  16.     -> if vv=0 then   
  17.     -> insert into t values (17);  
  18.     -> end if;  
  19.     -> if pp=0 then  
  20.     -> update t set s1=s1+1;  
  21.     -> else   
  22.     -> update t set s1=s1+2;  
  23.     -> end if;  
  24.     -> end;  
  25.     -> //  
  26. Query OK, 0 rows affected (0.00 sec)  
  27.   
  28. mysql> select * from t //  
  29. +------+  
  30. | s1   |  
  31. +------+  
  32. |    6 |  
  33. |    6 |  
  34. |    6 |  
  35. |    6 |  
  36. +------+  
  37. 4 rows in set (0.00 sec)  

3. case语句

Code   ViewPrint
  1. mysql> select * from t;//  
  2. +------+  
  3. | s1   |  
  4. +------+  
  5. |    6 |  
  6. |    6 |  
  7. |    6 |  
  8. |    6 |  
  9. +------+  
  10. 4 rows in set (0.00 sec)  
  11.   
  12. mysql> create procedure p13(IN pp int)  
  13.     -> begin  
  14.     ->   declare vv int;  
  15.     ->   set vv = pp + 1;  
  16.     ->   case vv  
  17.     ->     when 0 then insert into t values(17);  
  18.     ->     when 1 then insert into t values(18);  
  19.     ->     else insert into t values (19);  
  20.     ->   end case;  
  21.     -> end;  
  22.     -> //  
  23. Query OK, 0 rows affected (0.00 sec)  
  24.   
  25. mysql> call p13(0)//  
  26. Query OK, 1 row affected (0.01 sec)  
  27.   
  28. mysql> select * from t//  
  29. +------+  
  30. | s1   |  
  31. +------+  
  32. |    6 |  
  33. |    6 |  
  34. |    6 |  
  35. |    6 |  
  36. |   18 |  
  37. +------+  
  38. 5 rows in set (0.00 sec)  

4. 循环语句 while...end while、loop...end loop、repeat...end repeat 以及很难驾驭的 goto。

Code   ViewPrint
  1. mysql> select * from t//  
  2. +------+  
  3. | s1   |  
  4. +------+  
  5. |    6 |  
  6. |    6 |  
  7. |    6 |  
  8. |    6 |  
  9. |   18 |  
  10. +------+  
  11. 5 rows in set (0.00 sec)  
  12.   
  13. mysql> create procedure p14()  
  14.     -> begin  
  15.     ->   declare v int;  
  16.     ->   set v = 0;  
  17.     ->   while v < 5 do  
  18.     ->     insert into t values(v);  
  19.     ->     set v = v + 1;  
  20.     ->   end while;  
  21.     -> end; //  
  22. Query OK, 0 rows affected (0.00 sec)  
  23.   
  24. mysql> call p14() //  
  25. Query OK, 1 row affected (0.04 sec)  
  26.   
  27. mysql> select * from t; //  
  28. +------+  
  29. | s1   |  
  30. +------+  
  31. |    6 |  
  32. |    6 |  
  33. |    6 |  
  34. |    6 |  
  35. |   18 |  
  36. |    0 |  
  37. |    1 |  
  38. |    2 |  
  39. |    3 |  
  40. |    4 |  
  41. +------+  
  42. 10 rows in set (0.00 sec)  
Code   ViewPrint
  1. mysql> create procedure p15()  
  2.     -> begin  
  3.     ->   declare v int;  
  4.     ->   set v=0;  
  5.     ->   repeat  
  6.     ->     insert into t values(v);  
  7.     ->     set v=v+1;  
  8.     ->     until v>=5  
  9.     ->   end repeat;  
  10.     -> end; //  
  11. Query OK, 0 rows affected (0.00 sec)  
Code   ViewPrint
  1. mysql> create procedure p16()  
  2.     -> begin   
  3.     ->   declare v int;  
  4.     ->   set v=0;  
  5.     ->   loop_label:LOOP  
  6.     ->     insert into t values(v);  
  7.     ->     set v=v+1;  
  8.     ->     if v>=5 then   
  9.     ->       leave loop_label;  
  10.     ->     end if;  
  11.     ->   end LOOP;  
  12.     -> end; //  
  13. Query OK, 0 rows affected (0.00 sec)  

以上循环的代码都会向表 t 中插入 5 行数据，值分别为 0、1、2、3、4。

下面是个迭代语句 ITERATE，相当于其它高级语言中的 continue 关键字，跳过当次循环，接着进行下一次。

Code   ViewPrint
  1. mysql> create procedure p20()  
  2.     -> begin  
  3.     ->   declare v int;  
  4.     ->   set v=0;  
  5.     ->   loop_label:LOOP  
  6.     ->   if v=3 then  
  7.     ->     set v=v+1;  
  8.     ->     iterate loop_label;  
  9.     ->   end if;  
  10.     ->   insert into t values(v);  
  11.     ->   set v=v+1;  
  12.     ->   if v>=5 then  
  13.     ->     leave loop_label;  
  14.     ->   end if;  
  15.     ->   end LOOP;  
  16.     -> end; //  
  17. Query OK, 0 rows affected (0.00 sec)  

这个存储过程执行后的结果是，向表 t 中插入 4 条数据，分别为 0、1、2、4。

GOTO 循环平时很少用，原因是控制不好，可能会导致代码流程特别乱，很难管理，这里也就不多做介绍了。到这里，存储过程基础大概讲的差不多了，让我们把分隔符先还原成默认的分号。
mysql> delimiter ;

讲了这么多存储过程的东西，现在已经建了很多个存储过程了。在 MySQL 中如何管理这些存储过程呢？接下来就讲讲这方面的东西吧。

1. 查看数据库下都有什么存储过程。

语句一：

Code   ViewPrint
  1. mysql> select name from mysql.proc where db='test';  
  2. +----------------------+  
  3. | name                 |  
  4. +----------------------+  
  5. | demo_inout_parameter |  
  6. | demo_in_parameter    |  
  7. | demo_out_parameter   |  
  8. | p1                   |  
  9. | p10                  |  
  10. | p11                  |  
  11. | p12                  |  
  12. | p13                  |  
  13. | p14                  |  
  14. | p15                  |  
  15. | p16                  |  
  16. | p2                   |  
  17. | p20                  |  
  18. | p7                   |  
  19. | p8                   |  
  20. | p_in                 |  
  21. | p_out                |  
  22. +----------------------+  
  23. 17 rows in set (0.00 sec)  

语句二：

Code   ViewPrint
  1. mysql> select routine_name from information_schema.routines where routine_schema='test';  
  2. +----------------------+  
  3. | routine_name         |  
  4. +----------------------+  
  5. | demo_inout_parameter |  
  6. | demo_in_parameter    |  
  7. | demo_out_parameter   |  
  8. | p1                   |  
  9. | p10                  |  
  10. | p11                  |  
  11. | p12                  |  
  12. | p13                  |  
  13. | p14                  |  
  14. | p15                  |  
  15. | p16                  |  
  16. | p2                   |  
  17. | p20                  |  
  18. | p7                   |  
  19. | p8                   |  
  20. | p_in                 |  
  21. | p_out                |  
  22. +----------------------+  
  23. 17 rows in set (0.00 sec)  

语句三：

Code   ViewPrint
  1. mysql> show procedure status where db='test';  
  2. +------+----------------------+-----------+----------------+---------------------+---------------------+---------------+-------------+----------------------+----------------------+--------------------+  
  3. | Db   | Name                 | Type      | Definer        | Modified            | Created             | Security_type | Comment     | character_set_client | collation_connection | Database Collation |  
  4. +------+----------------------+-----------+----------------+---------------------+---------------------+---------------+-------------+----------------------+----------------------+--------------------+  
  5. | test | demo_inout_parameter | PROCEDURE | root@localhost | 2015-02-01 14:16:36 | 2015-02-01 14:16:36 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  6. | test | demo_in_parameter    | PROCEDURE | root@localhost | 2015-02-01 13:56:44 | 2015-02-01 13:56:44 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  7. | test | demo_out_parameter   | PROCEDURE | root@localhost | 2015-02-01 14:03:09 | 2015-02-01 14:03:09 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  8. | test | p1                   | PROCEDURE | root@localhost | 2015-01-31 18:40:37 | 2015-01-31 18:40:37 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  9. | test | p10                  | PROCEDURE | root@localhost | 2015-02-01 15:06:28 | 2015-02-01 15:06:28 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  10. | test | p11                  | PROCEDURE | root@localhost | 2015-02-01 15:09:19 | 2015-02-01 15:09:19 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  11. | test | p12                  | PROCEDURE | root@localhost | 2015-02-01 15:18:15 | 2015-02-01 15:18:15 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  12. | test | p13                  | PROCEDURE | root@localhost | 2015-02-01 16:07:37 | 2015-02-01 16:07:37 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  13. | test | p14                  | PROCEDURE | root@localhost | 2015-02-01 16:16:24 | 2015-02-01 16:16:24 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  14. | test | p15                  | PROCEDURE | root@localhost | 2015-02-01 17:13:16 | 2015-02-01 17:13:16 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  15. | test | p16                  | PROCEDURE | root@localhost | 2015-02-01 17:17:10 | 2015-02-01 17:17:10 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  16. | test | p2                   | PROCEDURE | root@localhost | 2015-01-31 19:12:49 | 2015-01-31 19:12:49 | DEFINER       | A Procedure | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  17. | test | p20                  | PROCEDURE | root@localhost | 2015-02-01 17:28:21 | 2015-02-01 17:28:21 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  18. | test | p7                   | PROCEDURE | root@localhost | 2015-02-01 14:58:04 | 2015-02-01 14:58:04 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  19. | test | p8                   | PROCEDURE | root@localhost | 2015-02-01 15:04:12 | 2015-02-01 15:04:12 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  20. | test | p_in                 | PROCEDURE | root@localhost | 2015-01-31 19:47:34 | 2015-01-31 19:47:34 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  21. | test | p_out                | PROCEDURE | root@localhost | 2015-01-31 19:50:40 | 2015-01-31 19:50:40 | DEFINER       |             | utf8                 | utf8_general_ci      | latin1_swedish_ci  |  
  22. +------+----------------------+-----------+----------------+---------------------+---------------------+---------------+-------------+----------------------+----------------------+--------------------+  
  23. 17 rows in set (0.00 sec)  

如果想查看某一个存储过程的详细信息，可以用语句 show create procedure 数据库名.存储过程名;
mysql> show create procedure test.p2;

存储过程的修改语句 alert procedure。不过修改好像只能修改执行权限等，如果需要修改主题，很多人建议删了重建。

删除存储过程的语句是 delete procedure 存储过程名;

最后，有网友整理了些 MySQL 存储过程中的基本函数，顺便分享给大家。

Code   ViewPrint
  1. /** 
  2.  * 字符串类 
  3.  */  
  4. CHARSET(str) //返回字串字符集  
  5. CONCAT (string2 [,... ]) //连接字串  
  6. INSTR (string ,substring ) //返回substring首次在string中出现的位置,不存在返回0  
  7. LCASE (string2 ) //转换成小写  
  8. LEFT (string2 ,length ) //从string2中的左边起取length个字符  
  9. LENGTH (string ) //string长度  
  10. LOAD_FILE (file_name ) //从文件读取内容  
  11. LOCATE (substring , string [,start_position ] ) 同INSTR,但可指定开始位置  
  12. LPAD (string2 ,length ,pad ) //重复用pad加在string开头,直到字串长度为length  
  13. LTRIM (string2 ) //去除前端空格  
  14. REPEAT (string2 ,count ) //重复count次  
  15. REPLACE (str ,search_str ,replace_str ) //在str中用replace_str替换search_str  
  16. RPAD (string2 ,length ,pad) //在str后用pad补充,直到长度为length  
  17. RTRIM (string2 ) //去除后端空格  
  18. STRCMP (string1 ,string2 ) //逐字符比较两字串大小,  
  19. SUBSTRING (str , position [,length ]) //从str的position开始,取length个字符,  
  20. // 注：mysql中处理字符串时，默认第一个字符下标为1，即参数position必须大于等于1  
  21. TRIM([[BOTH|LEADING|TRAILING] [padding] FROM]string2) //去除指定位置的指定字符  
  22. UCASE (string2 ) //转换成大写  
  23. RIGHT(string2,length) //取string2最后length个字符  
  24. SPACE(count) //生成count个空格  
  25.   
  26. /** 
  27.  * 数学类 
  28.  */  
  29. ABS (number2 ) //绝对值  
  30. BIN (decimal_number ) //十进制转二进制  
  31. CEILING (number2 ) //向上取整  
  32. CONV(number2,from_base,to_base) //进制转换  
  33. FLOOR (number2 ) //向下取整  
  34. FORMAT (number,decimal_places ) //保留小数位数  
  35. HEX (DecimalNumber ) //转十六进制  
  36. // 注：HEX()中可传入字符串，则返回其ASC-11码，如HEX('DEF')返回4142143  
  37. // 也可以传入十进制整数，返回其十六进制编码，如HEX(25)返回19  
  38. LEAST (number , number2 [,..]) //求最小值  
  39. MOD (numerator ,denominator ) //求余  
  40. POWER (number ,power ) //求指数  
  41. RAND([seed]) //随机数  
  42. ROUND (number [,decimals ]) //四舍五入,decimals为小数位数]  
  43.   
  44. /** 
  45.  * 日期时间类 
  46.  */  
  47. ADDTIME (date2 ,time_interval ) //将time_interval加到date2  
  48. CONVERT_TZ (datetime2 ,fromTZ ,toTZ ) //转换时区  
  49. CURRENT_DATE ( ) //当前日期  
  50. CURRENT_TIME ( ) //当前时间  
  51. CURRENT_TIMESTAMP ( ) //当前时间戳  
  52. DATE (datetime ) //返回datetime的日期部分  
  53. DATE_ADD (date2 , INTERVAL d_value d_type ) //在date2中加上日期或时间  
  54. DATE_FORMAT (datetime ,FormatCodes ) //使用formatcodes格式显示datetime  
  55. DATE_SUB (date2 , INTERVAL d_value d_type ) //在date2上减去一个时间  
  56. DATEDIFF (date1 ,date2 ) //两个日期差  
  57. DAY (date ) //返回日期的天  
  58. DAYNAME (date ) //英文星期  
  59. DAYOFWEEK (date ) //星期(1-7) ,1为星期天  
  60. DAYOFYEAR (date ) //一年中的第几天  
  61. EXTRACT (interval_name FROM date ) //从date中提取日期的指定部分  
  62. MAKEDATE (year ,day ) //给出年及年中的第几天,生成日期串  
  63. MAKETIME (hour ,minute ,second ) //生成时间串  
  64. MONTHNAME (date ) //英文月份名  
  65. NOW ( ) //当前时间  
  66. SEC_TO_TIME (seconds ) //秒数转成时间  
  67. STR_TO_DATE (string ,format ) //字串转成时间,以format格式显示  
  68. TIMEDIFF (datetime1 ,datetime2 ) //两个时间差  
  69. TIME_TO_SEC (time ) //时间转秒数]  
  70. WEEK (date_time [,start_of_week ]) //第几周  
  71. YEAR (datetime ) //年份  
  72. DAYOFMONTH(datetime) //月的第几天  
  73. HOUR(datetime) //小时  
  74. LAST_DAY(date) //date的月的最后日期  
  75. MICROSECOND(datetime) //微秒  
  76. MONTH(datetime) //月  
  77. MINUTE(datetime) //分返回符号,正负或0  
  78. SQRT(number2) //开平方  

好了，基础部分到此结束，希望对你有所帮助。

分享到0
返回
Avatar photo

作者:

【上篇】
【下篇】

您可能还会对这些文章感兴趣！

  1. Linux 下执行定时任务之 Systemd Timers
  2. DJango 框架学习入门教程（三） —— DJango 框架使
  3. DJango 框架学习入门教程（二） —— DJango 框架使
  4. MySQL 数据库生成连续日期
  5. Premature end of script headers 或 End of script o
  6. 博客从 WordPress 迁移至 Halo
  7. 设置 MYSQL 数据库编码为 utf8mb4
  8. Oracle 数据库表空间管理基础
此景只应天上有
博客从 WordPress 迁移至 Halo
两年后
因为婚事失眠
Win10预览版坏消息：没激活码了
在Ubuntu14.04上安装MySQL数据库
观影《2001太空漫游》
网页在线小游戏

给我留言

留言无头像?


插入图片

Copyright © 2010-2024 孟郎郎 辽ICP备19011093号