关于java:MySQL一一数据类型与函数

Mysql 数据类型和函数

知识点
数据类型分类

CHAR       
VARCHAR       
int       
float       
DATETIME      
TIMESTAMP    
TEXT        
Blob  

函数

avg() 求平均值    
   
count() 求返回的记录行数  

max() 计算最大值  

min() 计算最小值   
   
sum() 求和      

分组函数的空值 NULL    

分组函数中的反复值   

GROUP BY 子句     

除了 sql 之外，还整顿了一些 Java 根底等一系列的内容，欢送大家来探讨!!!

1. 数据类型分类

   1. 字符类型
      CHAR 10 admin 10
      VARCHAR 10 admin 5
   2. 数值类型
      int
      float
   3. 日期类型
      DATE 准确到秒
      DATETIME
      TIMESTAMP 准确到毫秒
   4. 其余类型
      BLOB

   5. 字符数据类型

      1. CHAR

      2. VARCHAR

      3. float

      4.int

      1. 日期数据类型

      总结: 理论罕用的类型 CHAR VARCHAR , int ,float, DATE ,datetime,TIMESTAMP 大文本 text, 秘密或文件二进制数据用 : BLOB

      创立一个客户表 customer
      CREATE TABLE customer
      (
      id int(10),
      name VARCHAR(10),
      fund float(10,2),
      reg_time DateTime,
      oper_time timestamp,
      content text

       );
      
      

2. 函数

   CONV(N,from_base,to_base)
   在不同的数字基之间变换数字。返回数字 N 的字符串数字，从 from_base 基变换为 to_base 基，如果任何参数是 NULL，返回 NULL。

参数 N 解释为一个整数，然而能够指定为一个整数或一个字符串。最小基是 2 且最大的基是 36。
如果 to_base 是一个正数，N 被认为是一个有符号数，否则，N 被当作无符号数。CONV 以 64 位点精度工作。
mysql> select CONV(“a”,16,2);

  -> '1010'

mysql> select CONV(“6E”,18,8);

  -> '172'

mysql> select CONV(-17,10,-18);

  -> '-H'

mysql> select CONV(10+”10″+’10’+0xa,10,10);

  -> '40'

 

CHAR(N,…)
CHAR()将参数解释为整数并且返回由这些整数的 ASCII 代码字符组成的一个字符串。NULL 值被跳过。
mysql> select CHAR(77,121,83,81,’76’);

  -> 'MySQL'

mysql> select CHAR(77,77.3,’77.3′);

  -> 'MMM'

CONCAT(str1,str2,…)
返回来自于参数连结的字符串。如果任何参数是 NULL，返回 NULL。能够有超过 2 个的参数。一个数字参数被变换为等价的字符串模式。
mysql> select CONCAT(‘My’, ‘S’, ‘QL’);

  -> 'MySQL'

mysql> select CONCAT(‘My’, NULL, ‘QL’);

  -> NULL

mysql> select CONCAT(14.3);

  -> '14.3'

LENGTH(str)

OCTET_LENGTH(str)

CHAR_LENGTH(str)

CHARACTER_LENGTH(str)
返回字符串 str 的长度。
mysql> select LENGTH(‘text’);

  -> 4

mysql> select OCTET_LENGTH(‘text’);

  -> 4

留神，对于多字节字符，其 CHAR_LENGTH()仅计算一次。
LOCATE(substr,str)

POSITION(substr IN str)
返回子串 substr 在字符串 str 第一个呈现的地位，如果 substr 不是在 str 外面，返回 0.
mysql> select LOCATE(‘bar’, ‘foobarbar’);

  -> 4

mysql> select LOCATE(‘xbar’, ‘foobar’);

  -> 0

该函数是多字节牢靠的。
LOCATE(substr,str,pos)
返回子串 substr 在字符串 str 第一个呈现的地位，从地位 pos 开始。如果 substr 不是在 str 外面，返回 0。
mysql> select LOCATE(‘bar’, ‘foobarbar’,5);

  -> 7

这函数是多字节牢靠的。

INSTR(str,substr)
返回子串 substr 在字符串 str 中的第一个呈现的地位。这与有 2 个参数模式的 LOCATE()雷同，除了参数被颠倒。
mysql> select INSTR(‘foobarbar’, ‘bar’);

  -> 4

mysql> select INSTR(‘xbar’, ‘foobar’);

  -> 0

这函数是多字节牢靠的。

LPAD(str,len,padstr)
返回字符串 str，右面用字符串 padstr 填补直到 str 是 len 个字符长。
mysql> select LPAD(‘hi’,4,’??’);

  -> '??hi'

RPAD(str,len,padstr)
返回字符串 str，右面用字符串 padstr 填补直到 str 是 len 个字符长。
mysql> select RPAD(‘hi’,5,’?’);

  -> 'hi???'

LEFT(str,len)
返回字符串 str 的最右面 len 个字符。
mysql> select LEFT(‘foobarbar’, 5);

  -> 'fooba'

该函数是多字节牢靠的。

RIGHT(str,len)
返回字符串 str 的最右面 len 个字符。
mysql> select RIGHT(‘foobarbar’, 4);

  -> 'rbar'

该函数是多字节牢靠的。
SUBSTRING(str,pos,len)

SUBSTRING(str FROM pos FOR len)

MID(str,pos,len)
从字符串 str 返回一个 len 个字符的子串，从地位 pos 开始。应用 FROM 的变种模式是 ANSI SQL92 语法。
mysql> select SUBSTRING(‘Quadratically’,5,6);

  -> 'ratica'

该函数是多字节牢靠的。
SUBSTRING(str,pos)

SUBSTRING(str FROM pos)
从字符串 str 的起始地位 pos 返回一个子串。
mysql> select SUBSTRING(‘Quadratically’,5);

  -> 'ratically'

mysql> select SUBSTRING(‘foobarbar’ FROM 4);

  -> 'barbar'

该函数是多字节牢靠的。

SUBSTRING_INDEX(str,delim,count)
返回从字符串 str 的第 count 个呈现的分隔符 delim 之后的子串。如果 count 是负数，返回最初的分隔符到右边 (从右边数) 的所有字符。
如果 count 是正数，返回最初的分隔符到左边的所有字符(从左边数)。
mysql> select SUBSTRING_INDEX(‘www.mysql.com’, ‘.’, 2);

  -> 'www.mysql'

mysql> select SUBSTRING_INDEX(‘www.mysql.com’, ‘.’, -2);

  -> 'mysql.com'

该函数对多字节是牢靠的。

LTRIM(str)
返回删除了其前置空格字符的字符串 str。
mysql> select LTRIM(‘ barbar’);

  -> 'barbar'

RTRIM(str)

返回删除了其拖后空格字符的字符串 str。
mysql> select RTRIM(‘barbar ‘);

  -> 'barbar'

该函数对多字节是牢靠的。
TRIM([[BOTH | LEA

DING | TRAILING] [remstr] FROM] str)
返回字符串 str，其所有 remstr 前缀或后缀被删除了。如果没有修饰符 BOTH、LEADING 或 TRAILING 给出，BOTH 被假设。如果 remstr 没被指定，空格被删除。
mysql> select TRIM(‘ bar ‘);

  -> 'bar'

mysql> select TRIM(LEADING ‘x’ FROM ‘xxxbarxxx’);

  -> 'barxxx'

mysql> select TRIM(BOTH ‘x’ FROM ‘xxxbarxxx’);

  -> 'bar'

mysql> select TRIM(TRAILING ‘xyz’ FROM ‘barxxyz’);

  -> 'barx'

该函数对多字节是牢靠的。

SOUNDEX(str)
返回 str 的一个同音字符串。听起来“大致相同”的 2 个字符串应该有雷同的同音字符串。
一个“规范”的同音字符串长是 4 个字符，然而 SOUNDEX()函数返回一个任意长的字符串。
你能够在后果上应用 SUBSTRING()失去一个“规范”的 同音串。所有非数字字母字符在给定的字符串中被疏忽。所有在 A - Z 之外的字符国内字母被当作元音。
mysql> select SOUNDEX(‘Hello’);

  -> 'H400'

mysql> select SOUNDEX(‘Quadratically’);

  -> 'Q36324'

SPACE(N)
返回由 N 个空格字符组成的一个字符串。
mysql> select SPACE(6);

  -> ' '

REPLACE(str,from_str,to_str)
返回字符串 str，其字符串 from_str 的所有呈现由字符串 to_str 代替。
mysql> select REPLACE(‘www.mysql.com’, ‘w’, ‘Ww’);

  -> 'WwWwWw.mysql.com'

该函数对多字节是牢靠的。

REPEAT(str,count)
返回由反复 countTimes 次的字符串 str 组成的一个字符串。如果 count <= 0，返回一个空字符串。如果 str 或 count 是 NULL，返回 NULL。
mysql> select REPEAT(‘MySQL’, 3);

  -> 'MySQLMySQLMySQL'

REVERSE(str)
返回颠倒字符程序的字符串 str。
mysql> select REVERSE(‘abc’);

  -> 'cba'

该函数对多字节牢靠的。

INSERT(str,pos,len,newstr)
返回字符串 str，在地位 pos 起始的子串且 len 个字符长得子串由字符串 newstr 代替。
mysql> select INSERT(‘Quadratic’, 3, 4, ‘What’);

  -> 'QuWhattic'

该函数对多字节是牢靠的。

ELT(N,str1,str2,str3,…)
如果 N = 1，返回 str1，如果 N = 2，返回 str2，等等。如果 N 小于 1 或大于参数个数，返回 NULL。ELT()是 FIELD()反运算。
mysql> select ELT(1, ‘ej’, ‘Heja’, ‘hej’, ‘foo’);

  -> 'ej'

mysql> select ELT(4, ‘ej’, ‘Heja’, ‘hej’, ‘foo’);

  -> 'foo'

FIELD(str,str1,str2,str3,…)
返回 str 在 str1, str2, str3, … 清单的索引。如果 str 没找到，返回 0。FIELD()是 ELT()反运算。
mysql> select FIELD(‘ej’, ‘Hej’, ‘ej’, ‘Heja’, ‘hej’, ‘foo’);

  -> 2

mysql> select FIELD(‘fo’, ‘Hej’, ‘ej’, ‘Heja’, ‘hej’, ‘foo’);

  -> 0

FIND_IN_SET(str,strlist)
如果字符串 str 在由 N 子串组成的表 strlist 之中，返回一个 1 到 N 的值。一个字符串表是被“,”分隔的子串组成的一个字符串。
如果第一个参数是一个常数字符串并且第二个参数是一种类型为 SET 的列，FIND_IN_SET()函数被优化而应用位运算！
如果 str 不是在 strlist 外面或如果 strlist 是空字符串，返回 0。如果任何一个参数是 NULL，返回 NULL。如果第一个参数蕴含一个“,”，该函数将工作不失常。
mysql> SELECT FIND_IN_SET(‘b’,’a,b,c,d’);

  -> 2

MAKE_SET(bits,str1,str2,…)
返回一个汇合 (蕴含由“,”字符分隔的子串组成的一个字符串)，由相应的位在 bits 汇合中的的字符串组成。
str1 对应于位 0，str2 对应位 1，等等。在 str1, str2, … 中的 NULL 串不增加到后果中。
mysql> SELECT MAKE_SET(1,’a’,’b’,’c’);

  -> 'a'

mysql> SELECT MAKE_SET(1 | 4,’hello’,’nice’,’world’);

  -> 'hello,world'

mysql> SELECT MAKE_SET(0,’a’,’b’,’c’);

  -> ''

EXPORT_SET(bits,on,off,[separator,[number_of_bits]])
返回一个字符串，在这里对于在“bits”中设定每一位，你失去一个“on”字符串，并且对于每个复位 (reset) 的位，
你失去一个“off”字符串。每个字符串用“separator”分隔 (缺省“,”)，并且只有“bits”的“number_of_bits”(缺省 64) 位被应用。
mysql> select EXPORT_SET(5,’Y’,’N’,’,’,4)

  -> Y,N,Y,N 

LCASE(str)

LOWER(str)
返回字符串 str，依据以后字符集映射 (缺省是 ISO-8859-1 Latin1) 把所有的字符扭转成小写。该函数对多字节是牢靠的。
mysql> select LCASE(‘QUADRATICALLY’);

  -> 'quadratically'

UCASE(str)

UPPER(str)
返回字符串 str，依据以后字符集映射 (缺省是 ISO-8859-1 Latin1) 把所有的字符扭转成大写。该函数对多字节是牢靠的。
mysql> select UCASE(‘Hej’);

  -> 'HEJ'
 

MySQL 必要时主动变换数字为字符串，并且反过来也如此：
mysql> SELECT 1+”1″;

  -> 2

mysql> SELECT CONCAT(2,’ test’);

  -> '2 test'

如果你想要明确地变换一个数字到一个字符串，把它作为参数传递到 CONCAT()。
如果字符串函数提供一个二进制字符串作为参数，后果字符串也是一个二进制字符串。被变换到一个字符串的数字被当作是一个二进制字符串。这仅影响比拟

  

                                   mysql 工夫函数用法汇合



这里是一个应用日期函数的例子。上面的查问抉择了所有记录，其 date_col 的值是在最初 30 天以内：mysql> SELECT something FROM table
  WHERE TO_DAYS(NOW()) - TO_DAYS(date_col) <= 30;  

  DAYOFWEEK(date)  
  返回日期 date 的星期索引(1= 星期天，2= 星期一, ……7= 星期六)。这些索引值对应于 ODBC 规范。mysql> select DAYOFWEEK('1998-02-03');  
  -> 3  

  WEEKDAY(date)  
  返回 date 的星期索引(0= 星期一，1= 星期二, ……6= 星期天)。mysql> select WEEKDAY('1997-10-04 22:23:00');  
  -> 5  
  mysql> select WEEKDAY('1997-11-05');  
  -> 2  

  DAYOFMONTH(date)  
  返回 date 的月份中日期，在 1 到 31 范畴内。mysql> select DAYOFMONTH('1998-02-03');  
  -> 3  

  DAYOFYEAR(date)  
  返回 date 在一年中的日数, 在 1 到 366 范畴内。mysql> select DAYOFYEAR('1998-02-03');  
  -> 34  

  MONTH(date)  
  返回 date 的月份，范畴 1 到 12。mysql> select MONTH('1998-02-03');  
  -> 2  

  DAYNAME(date)  
  返回 date 的星期名字。mysql> select DAYNAME("1998-02-05");  
  -> 'Thursday'

  MONTHNAME(date)  
  返回 date 的月份名字。mysql> select MONTHNAME("1998-02-05");  
  -> 'February'

  QUARTER(date)  
  返回 date 一年中的季度，范畴 1 到 4。mysql> select QUARTER('98-04-01');  
  -> 2  

  WEEK(date)  
     
  WEEK(date,first)  
  对于星期天是一周的第一天的中央，有一个单个参数，返回 date 的周数，范畴在 0 到 52。2 个参数模式 WEEK()容许你指定星期是否开始于星期天或星期一。

如果第二个参数是 0，星期从星期天开始，如果第二个参数是 1，从星期一开始。

  mysql> select WEEK('1998-02-20');  
  -> 7  
  mysql> select WEEK('1998-02-20',0);  
  -> 7  
  mysql> select WEEK('1998-02-20',1);  
  -> 8  

  YEAR(date)  
  返回 date 的年份，范畴在 1000 到 9999。mysql> select YEAR('98-02-03');  
  -> 1998  

  HOUR(time)  
  返回 time 的小时，范畴是 0 到 23。mysql> select HOUR('10:05:03');  
  -> 10  

  MINUTE(time)  
  返回 time 的分钟，范畴是 0 到 59。mysql> select MINUTE('98-02-03 10:05:03');  
  -> 5  

  SECOND(time)  
  回来 time 的秒数，范畴是 0 到 59。mysql> select SECOND('10:05:03');  
  -> 3  

  PERIOD_ADD(P,N)  
  减少 N 个月到阶段 P（以格局 YYMM 或 YYYYMM)。以格局 YYYYMM 返回值。留神阶段参数 P 不是日期值。mysql> select PERIOD_ADD(9801,2);  
  -> 199803  

  PERIOD_DIFF(P1,P2)  
  返回在期间 P1 和 P2 之间月数，P1 和 P2 应该以格局 YYMM 或 YYYYMM。留神，期间参数 P1 和 P2 不是日期值。mysql> select PERIOD_DIFF(9802,199703);  
  -> 11  

  DATE_ADD(date,INTERVAL expr type)  
     
  DATE_SUB(date,INTERVAL expr type)  
     
  ADDDATE(date,INTERVAL expr type)  
     
  SUBDATE(date,INTERVAL expr type)  
  这些性能执行日期运算。对于 MySQL 3.22，他们是新的。ADDDATE()和 SUBDATE()是 DATE_ADD()和 DATE_SUB()的同义词。在 MySQL 3.23 中，你能够应用 + 和 - 而不是 DATE_ADD()和 DATE_SUB()。（见例子）date 是一个指定开始日期的 
  DATETIME 或 DATE 值，expr 是指定加到开始日期或从开始日期减去的距离值一个表达式，expr 是一个字符串；它能够以 
  一个“-”开始示意负距离。type 是一个关键词，指明表达式应该如何被解释。EXTRACT(type FROM date)函数从日期 
  中返回“type”距离。下表显示了 type 和 expr 参数怎么被关联：type 值 含意 冀望的 expr 格局  
  SECOND 秒 SECONDS  
  MINUTE 分钟 MINUTES  
  HOUR 工夫 HOURS  
  DAY 天 DAYS  
  MONTH 月 MONTHS  
  YEAR 年 YEARS  
  MINUTE_SECOND 分钟和秒 "MINUTES:SECONDS"
  HOUR_MINUTE 小时和分钟 "HOURS:MINUTES"
  DAY_HOUR 天和小时 "DAYS HOURS"
  YEAR_MONTH 年和月 "YEARS-MONTHS"
  HOUR_SECOND 小时, 分钟，"HOURS:MINUTES:SECONDS"
  DAY_MINUTE 天, 小时, 分钟 "DAYS HOURS:MINUTES"
  DAY_SECOND 天, 小时, 分钟, 秒 "DAYS HOURS:MINUTES:SECONDS"

  MySQL 在 expr 格局中容许任何标点分隔符。示意显示的是倡议的分隔符。

如果 date 参数是一个 DATE 值并且你的计算仅仅蕴含 YEAR、MONTH 和 DAY 局部(即，没有工夫局部)，后果是一个 DATE 值。否则后果是一个 DATETIME 值。

  mysql> SELECT "1997-12-31 23:59:59" + INTERVAL 1 SECOND;  
  -> 1998-01-01 00:00:00  
  mysql> SELECT INTERVAL 1 DAY + "1997-12-31";  
  -> 1998-01-01  
  mysql> SELECT "1998-01-01" - INTERVAL 1 SECOND;  
  -> 1997-12-31 23:59:59  
  mysql> SELECT DATE_ADD("1997-12-31 23:59:59",  
  INTERVAL 1 SECOND);  
  -> 1998-01-01 00:00:00  
  mysql> SELECT DATE_ADD("1997-12-31 23:59:59",  
  INTERVAL 1 DAY);  
  -> 1998-01-01 23:59:59  
  mysql> SELECT DATE_ADD("1997-12-31 23:59:59",  
  INTERVAL "1:1" MINUTE_SECOND);  
  -> 1998-01-01 00:01:00  
  mysql> SELECT DATE_SUB("1998-01-01 00:00:00",  
  INTERVAL "1 1:1:1" DAY_SECOND);  
  -> 1997-12-30 22:58:59  
  mysql> SELECT DATE_ADD("1998-01-01 00:00:00",  
  INTERVAL "-1 10" DAY_HOUR);  
  -> 1997-12-30 14:00:00  
  mysql> SELECT DATE_SUB("1998-01-02", INTERVAL 31 DAY);  
  -> 1997-12-02  
  mysql> SELECT EXTRACT(YEAR FROM "1999-07-02");  
  -> 1999  
  mysql> SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03");  
  -> 199907  
  mysql> SELECT EXTRACT(DAY_MINUTE FROM "1999-07-02 01:02:03");  
  -> 20102  

  如果你指定太短的距离值(不包含 type 关键词冀望的距离局部)，MySQL 假如你省掉了距离值的最右面局部。

例如，如果你指定一个 type 是 DAY_SECOND，值 expr 被心愿有天、小时、分钟和秒局部。
如果你象 ”1:10″ 这样指定值，MySQL 假如日子和小时局部是失落的并且值代表分钟和秒。换句话说，”1:10″ DAY_SECOND 以它等价于 ”1:10″ MINUTE_SECOND 的形式解释，
这对那 MySQL 解释 TIME 值示意通过的工夫而非作为一天的工夫的形式有二义性。如果你应用的确不正确的日期，后果是 NULL。
如果你减少 MONTH、YEAR_MONTH 或 YEAR 并且后果日期大于新月份的最大值天数，日子在新月用最大的天调整。

  mysql> select DATE_ADD('1998-01-30', Interval 1 month);  
  -> 1998-02-28  

  留神，从后面的例子中词 INTERVAL 和 type 关键词不是辨别大小写的。TO_DAYS(date)  
  给出一个日期 date，返回一个天数(从 0 年的天数)。mysql> select TO_DAYS(950501);  
  -> 728779  
  mysql> select TO_DAYS('1997-10-07');  
  -> 729669  

  TO_DAYS()
  不打算用于应用格列高里历 (1582) 呈现前的值。FROM_DAYS(N)  
  给出一个天数 N，返回一个 DATE 值。mysql> select FROM_DAYS(729669);  
  -> '1997-10-07'

  DATE_FORMAT(date,format)  
  依据 format 字符串格式化 date 值。下列修饰符能够被用在 format 字符串中：%M 月名字(January……December)  

%W 星期名字(Sunday……Saturday)
%D 有英语前缀的月份的日期(1st, 2nd, 3rd, 等等。）
%Y 年, 数字, 4 位
%y 年, 数字, 2 位
%a 缩写的星期名字(Sun……Sat)
%d 月份中的天数, 数字(00……31)
%e 月份中的天数, 数字(0……31)
%m 月, 数字(01……12)
%c 月, 数字(1……12)
%b 缩写的月份名字(Jan……Dec)
%j 一年中的天数(001……366)
%H 小时(00……23)
%k 小时(0……23)
%h 小时(01……12)
%I 小时(01……12)
%l 小时(1……12)
%i 分钟, 数字(00……59)
%r 工夫,12 小时(hh:mm:ss [AP]M)
%T 工夫,24 小时(hh:mm:ss)
%S 秒(00……59)
%s 秒(00……59)
%p AM 或 PM
%w 一个星期中的天数(0=Sunday ……6=Saturday）
%U 星期(0……52), 这里星期天是星期的第一天
%u 星期(0……52), 这里星期一是星期的第一天
%% 一个文字“%”。

  所有的其余字符不做解释被复制到后果中。mysql> select DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');  
  -> 'Saturday October 1997'
  mysql> select DATE_FORMAT('1997-10-04 22:23:00', '%H:%i:%s');  
  -> '22:23:00'
  mysql> select DATE_FORMAT('1997-10-04 22:23:00',  
  '%D %y %a %d %m %b %j');  
  -> '4th 97 Sat 04 10 Oct 277'
  mysql> select DATE_FORMAT('1997-10-04 22:23:00',  
  '%H %k %I %r %T %S %w');  
  -> '22 22 10 10:23:00 PM 22:23:00 00 6'
  MySQL3.23 中，在格局修饰符字符前须要 %。在 MySQL 更早的版本中，% 是可选的。TIME_FORMAT(time,format)  
  这象下面的 DATE_FORMAT()函数一样应用，然而 format 字符串只能蕴含解决小时、分钟和秒的那些格局修饰符。其余修饰符产生一个 NULL 值或 0。CURDATE()  
     
  CURRENT_DATE
  以 'YYYY-MM-DD' 或 YYYYMMDD 格局返回明天日期值，取决于函数是在一个字符串还是数字上下文被应用。mysql> select CURDATE();  
  -> '1997-12-15'
  mysql> select CURDATE() + 0;  
  -> 19971215  

  CURTIME()  
     
  CURRENT_TIME
  以 'HH:MM:SS' 或 HHMMSS 格局返回以后工夫值，取决于函数是在一个字符串还是在数字的上下文被应用。mysql> select CURTIME();  
  -> '23:50:26'
  mysql> select CURTIME() + 0;  
  -> 235026  

  NOW()  
     
  SYSDATE()  
     
  CURRENT_TIMESTAMP
  以 'YYYY-MM-DD HH:MM:SS' 或 YYYYMMDDHHMMSS 格局返回以后的日期和工夫，取决于函数是在一个字符串还是在数字的上下文被应用。mysql> select NOW();  
  -> '1997-12-15 23:50:26'
  mysql> select NOW() + 0;  
  -> 19971215235026  

  UNIX_TIMESTAMP()  
     
  UNIX_TIMESTAMP(date)  
  如果没有参数调用，返回一个 Unix 工夫戳记(从 '1970-01-01 00:00:00'GMT 开始的秒数)。

如果 UNIX_TIMESTAMP()用一个 date 参数被调用，它返回从 ’1970-01-01 00:00:00′ GMT 开始的秒数值。
date 能够是一个 DATE 字符串、一个 DATETIME 字符串、一个 TIMESTAMP 或以 YYMMDD 或 YYYYMMDD 格局的本地工夫的一个数字。

  mysql> select UNIX_TIMESTAMP();  
  -> 882226357  
  mysql> select UNIX_TIMESTAMP('1997-10-04 22:23:00');  
  -> 875996580  
  当 UNIX_TIMESTAMP 被用于一个 TIMESTAMP 列，函数将间接承受值，没有隐含的“string-to-unix-timestamp”变换。FROM_UNIXTIME(unix_timestamp)  
  以 'YYYY-MM-DD HH:MM:SS' 或 YYYYMMDDHHMMSS 格局返回 unix_timestamp 参数所示意的值，取决于函数是在一个字符串还是或数字上下文中被应用。mysql> select FROM_UNIXTIME(875996580);  
  -> '1997-10-04 22:23:00'
  mysql> select FROM_UNIXTIME(875996580) + 0;  
  -> 19971004222300  

  FROM_UNIXTIME(unix_timestamp,format)  
  返回示意 Unix 工夫标记的一个字符串，依据 format 字符串格式化。format 能够蕴含与 DATE_FORMAT()函数列出的条目同样的修饰符。mysql> select FROM_UNIXTIME(UNIX_TIMESTAMP(),  
  '%Y %D %M %h:%i:%s %x');  
  -> '1997 23rd December 03:43:30 x'

  SEC_TO_TIME(seconds)  
  返回 seconds 参数，变换成小时、分钟和秒，值以 'HH:MM:SS' 或 HHMMSS 格式化，取决于函数是在一个字符串还是在数字上下文中被应用。mysql> select SEC_TO_TIME(2378);  
  -> '00:39:38'
  mysql> select SEC_TO_TIME(2378) + 0;  
  -> 3938  

  TIME_TO_SEC(time)  
  返回 time 参数，转换成秒。mysql> select TIME_TO_SEC('22:23:00');  
  -> 80580  
  mysql> select TIME_TO_SEC('00:39:38');  
  -> 2378 

  Mysql 取零碎函数：Select curtime();

  Select curdate():

  Select sysdate():
  select now();

1. 分组函数
   avg() 求平均值

   // 返回所有员工的工资

       SELECT avg(salary) FROM emp;
      count() 求返回的记录行数
      // 返回所有员工的记录行数
       SELECT count(*) FROM emp;
       SELECT count(1) FROM emp;
       SELECT count(id) FROM emp;
   
    max() 计算最大值
      // 返回所有员工工资的最大数
      SELECT max(salary) FROM emp;
   
    min() 计算最小值
      // 返回所有员工工资的最小数
      SELECT min(salary) FROM emp;
       
    sum() 求和
      // 返回所有员工工资的总和
      SELECT sum(salary) FROM emp;
       
    DISTINCT() 去掉反复, 不反复的记录数
    返回员工的部门编号, 去掉反复的编号
    SELECT DISTINCT(dept_id) FROM emp;
   
    返回员工, 不反复的部门数量
    SELECT count(DISTINCT(dept_id)) FROM emp;

1. 分组函数的空值 NULL
   除了 count(1),count(*) 外所有其余分组函数疏忽空值
   向 emp 插入一条 salary 为 NULL 的记录
   INSERT INTO emp(id,name)VALUES(9,’ 晓巍 ’);

查问出 emp 所有工资不为空的员工的总工资, 平均工资

   
SELECT sum(salary),count(*),avg(salary) FROM emp;
SELECT sum(salary),count(1),avg(salary) FROM emp;
SELECT sum(salary),count(id),avg(salary) FROM emp;
   
SELECT sum(salary),count(salary),avg(salary) FROM emp;

理论利用中如果要将空值纳入到分组统计计算 能够应用 nvl 函数转换
SELECT sum(nvl(salary,0)),count(nvl(salary,0)),avg(nvl(salary,0)) FROM emp;

1. 分组函数中的反复值
   DISTINCT 过滤掉反复值
   ALL 不过滤掉反复值

   SELECT sum(salary),count(salary),avg(salary) FROM emp;
   SELECT sum(ALL(salary)),count(ALL(salary)),avg(ALL(salary)) FROM emp;
   SELECT sum(DISTINCT(salary)),count(DISTINCT(salary)),avg(DISTINCT(salary)) FROM emp;

2. GROUP BY 子句
   SELECT 字段名 | 表达式, 分组函数 …
   FROM 表名
   [WHERE 查问条件]
   [GROUP BY 分组字段列表]
   [ORDER BY 排序字段列表]

WHERE 子句最先执行, 而后 GROUP BY 子句分组 , ORDER BY 子句对分组的后果排序最初执行

1. 基于单字段分组

计算每个部门的平均工资
SELECT dept_id,avg(salary) FROM emp GROUP BY dept_id;

计算每个部门的平均工资, 按部门编号倒序排列
SELECT dept_id,avg(salary) FROM emp GROUP BY dept_id ORDER BY dept_id DESC;

计算每个部门的平均工资, 按平均工资倒序排列
SELECT dept_id,avg(salary) FROM emp GROUP BY dept_id ORDER BY avg(salary) DESC;

分组中用别名
SELECT dept_id,avg(salary) avg_salary FROM emp GROUP BY dept_id ORDER BY avg_salary DESC;

留神: 应用分组函数时, 呈现在 SELECT 列表中的字段如果不蕴含在组函数中, 那么该字段必须同时在 GROUP BY 字句中呈现,
反之蕴含在 GROUP BY 子句中的字段则不必须呈现在 SELECT 列表中.

// 谬误
SELECT dept_id,name,avg(salary) FROM emp GROUP BY dept_id;

// 正确
SELECT avg(salary) FROM emp GROUP BY dept_id;

// 分组时能够用 WHERE 语句
SELECT dept_id,avg(salary) FROM emp WHERE salary>5000 GROUP BY dept_id;

但 WHERE 条件不容许用分组函数
// 谬误 起因是 WHERE 语句先执行 数据还没有分组
SELECT dept_id,avg(salary) FROM emp WHERE avg(salary)>5000 GROUP BY dept_id;

// 解决办法: 分组条件判断 HAVING 子句

  SELECT dept_id,avg(salary)  FROM emp GROUP BY dept_id HAVING avg(salary)>5000;

WHERE 和 GROUP BY 先判断再分组 并且 WHERE 不能用分组函数
GROUP BY 和 Having 先分组再 判断 Having 能够用分组函数

1. 两个表关联分组

   计算每个部门的平均工资, 显示出部门名称
   SELECT a.name,avg(b.salary)  FROM dept a,emp b WHERE a.id=b.dept_id GROUP BY a.name;