Janeiro 2010
S	T	Q	Q	S	S	D
« Dez		Fev »
	1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30	31

Funções de Data e Hora

By Flávio Silva

Parametros, exemplos, querys para trabalharmos com Data e Hora no MySQL.

Aqui está um exemplo que usa funções de data. A consulta seguinte seleciona todos os registros com um valores em uma coluna col_data dentro dos últimos 30 dias:

mysql> SELECT algo FROM nome_tabela
           WHERE TO_DAYS(NOW()) - TO_DAYS(col_data) <= 30;

(Note que a consulta também selecionará registros com datas futuras.)

Funções que esperam valores de data normaemente aceitaram valores datetime e ignoram a parte da hora. Funções que esperam valores de hora normalmente aceitarão valores datetime e ignoram a parte da data.

Funções que retornam a data ou hora atual são avaliadas apenas uma vez por consulta, no inicio da sua execução. Isto significa que várias referências a uma função com NOW() dentro de uma mesma consulta sempre produzirá o memo resultado. Este princípio também se aplica a CURDATE(), CURTIME(), UTC_DATE(), UTC_TIME(), UTC_TIMESTAMP(), e qualquer um dos seus sinônimos.

A faixa do valor retornado na seguinte descrição da função se aplica a datas completas. Se uma data é um valor “zero” ou uma data incompleta tal como '2001-11-00', funções que extraem parte de uma data podem retornam 0. Por exemplo, DAYOFMONTH('2001-11-00') retorna 0.

DATE(expr)Extrai a parte da data da expressão date ou datetime em expr.
```
mysql> SELECT DATE('2003-12-31 01:02:03');
        -> '2003-12-31'
```
DATE() está disponível a partir do MySQL 4.1.1.

TIME(expr)Extrai a parte da hora da expressão time ou datetime em expr.

mysql> SELECT TIME('2003-12-31 01:02:03');
  -> '01:02:03'
mysql> SELECT TIME('2003-12-31 01:02:03.000123');
        -> '01:02:03.000123'

TIME() está disponível a partir do MySQL 4.1.1.

TIMESTAMP(expr), TIMESTAMP(expr,expr2)Com um argumento, retorna a expressão date ou datetime em expr como um valor datetime. Com dois argumentos, adiciona a expressão time e expr2 à expressão date ou datetime em expr e retorna um valor datetime.
```
mysql> SELECT TIMESTAMP('2003-12-31');
  -> '2003-12-31 00:00:00'
mysql> SELECT TIMESTAMP('2003-12-31 12:00:00','12:00:00');
  -> '2004-01-01 00:00:00'
```
TIMESTAMP() está disponível a partir do MySQL 4.1.1.
DAYOFWEEK(data)Retorna o índice do dia da semana para data (1 = Domingo, 2 = Segunda, … 7 = Sábado). Estes valores de índices correspondem ao padrão ODBC.
```
mysql> SELECT DAYOFWEEK('1998-02-03');
        -> 3
```

WEEKDAY(data)Retorna o índice do dia das semana para data (0 = Segunda, 1 = Terça, … 6 = Domingo):

mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
        -> 1
mysql> SELECT WEEKDAY('1997-11-05');
        -> 2

DAYOFMONTH(data)Retorna o dia do mês para data, na faixa de 1 até 31:
```
mysql> SELECT DAYOFMONTH('1998-02-03');
        -> 3
```
DAY(date)DAY() é um sinônimo para DAYOFMONTH(). Está disponível a partir do MySQL 4.1.1.
DAYOFYEAR(data)Retorna o dia do ano para data, na faixa de 1 até 366:
```
mysql> SELECT DAYOFYEAR('1998-02-03');
        -> 34
```

MONTH(data)Retorna o mês para data, na faixa de 1 até 12:

mysql> SELECT MONTH('1998-02-03');
        -> 2

DAYNAME(data)Retorna o nome do dia da semana para data:

mysql> SELECT DAYNAME('1998-02-05');
        -> 'Thurday'

MONTHNAME(data)Retorna o nome do mês para data:

mysql> SELECT MONTHNAME('1998-02-05');
        -> 'February'

QUARTER(data)Retorna o trimaster para data, na faixa de 1 até 4:
```
mysql> SELECT QUARTER('98-04-01');
        -> 2
```

WEEK(data [,modo])A função retorna o número da semana para date. A forma de dois argumentos de WEEK() permite que você especifique se a semana começa no Domingo ou na Segunda e se o valor de retorno deve estar na faixa de 0-53 ou 1-5. Quando o argumento modo é omitido, o valor de uma variável de servidor default_week_format (ou 0 no MySQL 4.0 e mais novo) é assumido. See Secção 5.5.6, “Sintaxe de SET”.A seguinte tabela demonstra como o argumento modo funciona:

Valor	Significado
0	Semana começa no Domingo; retorna o valor na faixa de 0 a 53; semana 1 é a primeira semana neste ano.
1	Semana começa na Segunda; retorna o valor na faixa de 0 a 53; semana 1 é a primeira semana com mais de 3 dias neste ano
2	Semana começa no Domingo; retorna o valor na faixa de 1 a 53; semana 1 é a primeira semana neste ano.
3	Semana começa na Segunda; retorna o valor na faixa de 1 a 53; semana 1 é a primeira semana com mais de 3 dias neste ano.
4	Semana começa no Domingo; retorna o valor na faixa de 0 a 53; semana 1 é a primeira semana com mais de 3 dias neste ano.
5	Semana começa na Segunda; retorna o valor na faixa de 0 a 53; semana 1 é a primeira semana neste ano.
6	Semana começa no Domingo; retorna o valor na faixa de 0 a 53; semana 1 é a primeira semana que tenha mais de 3 dias neste ano.
7	Semana começa na Segunda; retorna o valor na faixa de 1 a 53; semana 1 é a primeira semana neste ano.

O valor mode de 3 pode ser usado a partir do MySQL 4.0.5. O valor mode de 4 e acima pode ser usado a partir do MySQL 4.0.17.

mysql> SELECT WEEK('1998-02-20');
        -> 7
mysql> SELECT WEEK('1998-02-20',0);
        -> 7
mysql> SELECT WEEK('1998-02-20',1);
        -> 8
mysql> SELECT WEEK('1998-12-31',1);
        -> 53

Nota: Na versão 4.0, WEEK(#,0) foi alterado para corresponder ao calendário americano. Antes WEEK() era calculada de forma errada para data no EUA. (Na verdade WEEK(#) e WEEK(#,0) era errado para todos os casos).

Note que se a data for a última semana do ano anterior, o MySQL retornará 0 se você não usar 2, 3, 6 ou 7 como argumento opcional modo:

mysql> SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0);
        -> 2000, 0

Pode-se questionar que o MySQL deveria retornar 52 para a função WEEK() ja que a data dada ocorre, na verdade, ma 52a. semana de 1999. Nós decidimos retornar 0 já que queremos que função retorne “o número da semana do ano dado”. Isto faz com que o uso da função WEEK() seja seguro quando combinado com outras funções que extraiam um parte de uma data.

Se você prefere que o resultado seja avaliado em relacão ao ano que aontém o primeiro dia da semana de uma data dada, então você deve usar o 2, 3, 6 ou 7 como argumento opcional modo:

mysql> SELECT WEEK('2000-01-01',2);
        -> 52

Alternativamente você pode usar a função YEARWEEK():

mysql> SELECT YEARWEEK('2000-01-01');
        -> 199952
mysql> SELECT MID(YEARWEEK('2000-01-01'),5,2);
        -> '52'

WEEKOFYEAR(data)Retorna a semana da data como um número na faixa de 1 a 53.
```
mysql> SELECT WEEKOFYEAR('1998-02-20');
        -> 8
```
WEEKOFYEAR() esta disponível a partir do MySQL 4.1.1.

YEAR(data)Retorna o ano para data na faixa de 1000 a 9999:

mysql> SELECT YEAR('98-02-03');
        -> 1998

YEARWEEK(data), YEARWEEK(data,inicio)Retorna o ano e a semana para a data. O argumento inicio funciona exatamente como o argumento inicio de WEEK(). Note que o ano pode ser diferente do ano no argumento data para a primeira e a última semana do ano:
```
mysql> SELECT YEARWEEK('1987-01-01');
        -> 198653
```
Note que o número da semana é diferente do que seria retornado pela função WEEK() (0) para os argumentos opcionais 0 ou 1, já que WEEK() retorna a semana no centexto de um ano dado.
HOUR(hora)Retorna a hora para hora. A faixa do valor retornado será de 0 a 23 para o valor hora do dia.
```
mysql> SELECT HOUR('10:05:03');
        -> 10
```
No entanto, a faixa dos valores TIME atualmente são muito grandes, assim HOUR pode retornar valores maior que 23:
```
mysql> SELECT HOUR('272:59:59');
        -> 272
```

MINUTE(hora)Retorna o minuto para hora, na faixa de 0 a 59:

mysql> SELECT MINUTE('98-02-03 10:05:03');
        -> 5

SECOND(hora)Retorna o segundo para hora, na faixa de 0 a 59:

mysql> SELECT SECOND('10:05:03');
        -> 3

MICROSECOND(expr)Retorna os microsegundos da expressão time ou datetime em expr como um número na faixa de 0 a 999999.
```
mysql> SELECT MICROSECOND('12:00:00.123456');
        -> 123456
mysql> SELECT MICROSECOND('1997-12-31 23:59:59.000010');
        -> 10
```
MICROSECOND() está disponível a partir do MySQL 4.1.1.
PERIOD_ADD(P,N)Adiciona N meses ao período P (no formato AAMM ou AAAAMM). Retorna um valor no formato AAAAMM.Note que o argumento de período P não é um valor de data:
```
mysql> SELECT PERIOD_ADD(9801,2);
        -> 199803
```
PERIOD_DIFF(P1,P2)Retorna o número de meses entre os períodos P1 e P2. P1 e P2 devem estar no formato AAMM ou AAAAMM.Note que os argumentos de período P1 e P2 não são valores de data:
```
mysql> SELECT PERIOD_DIFF(9802,199703);
        -> 11
```

DATE_ADD(data,INTERVAL tipo expr), DATE_SUB(data,INTERVAL tipo expr)Estas funções realizam operações aritméticas em datas.A partir do MySQL 3.23, INTERVAL expr tipo é permitido nos dois lados do operador + se a expressao em ambos os lados é um valor date ou datetime. Para o operador -, INTERVAL expr tipoe é permitido apenas no lado direito, porque não faz sentido subtrair um valor date ou datetime de um intervalo. (Veja exemplo abaixo.)data é um valor DATETIME ou DATE especificando a data de início. expr is an expressão especificando o intervala a ser adicionado ou subtraido da data de início. expr é uma string; ela pode iniciar com um ‘-’ para intervalos negativos. type é uma palavra chave indicando como a expressão deve ser interpretada.

A seguinte tabela mostra como os argumentos tipo e expr se relacionam:

`tipo do` valor	Formarto esperado da `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'`
`DAY_MICROSECOND`	`'DAYS.MICROSECONDS'`
`HOUR_MICROSECOND`	`'HOURS.MICROSECONDS'`
`MINUTE_MICROSECOND`	`'MINUTES.MICROSECONDS'`
`SECOND_MICROSECOND`	`'SECONDS.MICROSECONDS'`
`MICROSECOND`	`'MICROSECONDS'`

Os valores do tipo DAY_MICROSECOND, HOUR_MICROSECOND, MINUTE_MICROSECOND, SECOND_MICROSECOND e MICROSECOND são permitidos após o MySQL 4.1.1.

O MySQL permite qualquer delimitador de pontuação no formato de expr. Os delimitadores mostrados na tabela são apenas sugeridos. Se o argumento date é um valor de DATA e seus cálculos envolvem apenas as partes ANO, MÊS, e DIA (into é, nenhuma parte de hora), o resultado é um valor do tipo DATE. Senão, o resultado é um valor do tipo 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 DATE_ADD('1992-12-31 23:59:59.000002',
        ->                 INTERVAL '1.999999' SECOND_MICROSECOND);
        -> '1993-01-01 00:00:01.000001'

Se você especificado um intervalo muito curto (não inclue todas as partes que seriam esperadas pelo intervalo para aquele tipo), MySQL assume que você não especificou a parte mais a esquerda do valor do intervalo. Por exemplo, se você especifica um tipo DAY_SECOND, o valor esperado de expr deverá ter as partes de dias, horas, minutos e segundos. Se você especifica um valor como '1:10', MySQL assume que as partes do dia e da hora foram esquecidas e o valor representa minutos e segundos. Em outras palavras, '1:10' DAY_SECOND é interpretado de forma equivalente a '1:10' MINUTE_SECOND. Isto é análogo a forma que o MySQL interpreta valores TIME representado tempo decorrido no lugar de hora do dia.

Note que se você adicionar ou subtrair de uma data algo contendo uma parte de hora, o resultado é automaticamente convertido para um valor datetime:

mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 DAY);
        -> '1999-01-02'
mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);
        -> '1999-01-01 01:00:00'

Se você utilizar datas mal formadas, o valor retornado NULL. Sê você adicionar MONTH, YEAR_MONTH, ou YEAR e a data resultante tiver um dia maior que o dia máximo para aquele mês, o dia é ajustado para o dia máximo no mês.

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

Note pelo exemplo anterior que a palavra-chave INTERVAL e o especificador tipo não são caso sensitivo.

ADDDATE(data,INTERVAL expr type), ADDDATE(expr,dias)Quando chamada com a forma INTERVAL do segundo argumento, ADDDATE() é um sinônimo para DATE_ADD(). A função relcionada SUBDATE() é um sinônimo para DATE_SUB().
```
mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
        -> '1998-02-02'
mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);
  -> '1998-02-02'
```
A partir do MySQL 4.1.1, a segunda sintaxe é permitida, onde expr é uma expresão date ou datetime e dias é o número de dias a ser adicionado a expr.
```
mysql> SELECT ADDDATE('1998-01-02', 31);
  -> '1998-02-02'
```

ADDTIME(expr,expr2)ADDTIME() adiciona expr2 a expr e retorna o resultado. expr é uma expressão date ou datetime, e expr2 é uma expressão time.

mysql> SELECT ADDTIME("1997-12-31 23:59:59.999999", "1 1:1:1.000002");
        -> '1998-01-02 01:01:01.000001'
mysql> SELECT ADDTIME("01:00:00.999999", "02:00:00.999998");
        -> '03:00:01.999997'

ADDTIME() foi adicionado no MySQL 4.1.1.

EXTRACT(tipo FROM data)A função EXTRACT() usa o mesmo tipo de intervalo especificado como DATE_ADD() ou DATE_SUB(), mas extrai partes da da data em vez de realizar aritimética de data.

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
mysql> SELECT EXTRACT(MICROSECOND FROM "2003-01-02 10:30:00.00123");
        -> 123

DATEDIFF(expr,expr2), TIMEDIFF(expr,expr2)DATEDIFF() retorna o número de dias entre a data inicial expr e a data final expr2. expr e expr2 são expressões de datas ou data e hora. Apenas a parte da data dos valores sã usados no cálculo.TIMEDIFF() retorna o tempo entre a hora inicial expr e a hora final expr2. expr e expr2 são expressões de hora ou data e hora, mas ambas devem ser do mesmo tipo.
```
mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
        -> 1
mysql> SELECT DATEDIFF('1997-11-31 23:59:59','1997-12-31');
        -> -30
mysql> SELECT TIMEDIFF('2000:01:01 00:00:00', '2000:01:01 00:00:00.000001');
        -> '-00:00:00.000001'
mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001','1997-12-30 01:01:01.000002');
        -> '46:58:57.999999'
```
DATEDIFF() e TIMEDIFF() foram adicionados no MySQL 4.1.1.
TO_DAYS(data)Dada uma data data, retorna o número do dia (o número de dias desde o ano 0);
```
mysql> SELECT TO_DAYS(950501);
        -> 728779
mysql> SELECT TO_DAYS('1997-10-07');
        -> 729669
```
TO_DAYS() não pode ser usado com valores que orecedem o advento do calendario Gregoriano (1582), porque ele não leva em conta os dias perdidos quando o calendário foi mudado.
FROM_DAYS(N)Dado um número de dia N, retorna um valor DATE:
```
mysql> SELECT FROM_DAYS(729669);
        -> '1997-10-07'
```
FROM_DAYS() não pode ser usado com valores que orecedem o advento do calendario Gregoriano (1582), porque ele não leva em conta os dias perdidos quando o calendário foi mudado.

DATE_FORMAT(data,formato)Formata o valor de data de acordo com a string formato string. Os seguintes identificadores podem ser utilizados na string formato:

Specifier	Description
`%M`	Nome do mês (`January`..`December`)
`%W`	Nome da semana (`Sunday`..`Saturday`)
`%D`	Dia do mês com sufixo Inglês (`0th`, `1st`, `2nd`, `3rd`, etc.)
`%Y`	Ano, numerico, 4 digitos
`%y`	Ano, numerico, 2 digitos
`%X`	Ano para a semana onde o Domingo é o primeiro dia da semana, numerico, 4 digitos; usado com `%V`
`%x`	Ano para a semana onde a segunda é o primeiro dia da semana, numerico, 4 digitos; usado com `%v`
`%a`	Nome da semana abreviado (`Sun`..`Sat`)
`%d`	Dia do mês, numerico (`00`..`31`)
`%e`	Dia do mês, numerico (`0`..`31`)
`%m`	Mês, numerico (`00`..`12`)
`%c`	Mês, numerico (`0`..`12`)
`%b`	Nome do mês abreviado (`Jan`..`Dec`)
`%j`	Dia do ano (`001`..`366`)
`%H`	Hora (`00`..`23`)
`%k`	Hora (`0`..`23`)
`%h`	Hora (`01`..`12`)
`%I`	Hora (`01`..`12`)
`%l`	Hora (`1`..`12`)
`%i`	Minutos, numerico (`00`..`59`)
`%r`	Tempo, 12-horas (`hh:mm:ss` seguido por `AM` ou `PM`)
`%T`	Tempo, 24-horas (`hh:mm:ss`)
`%S`	Segundos (`00`..`59`)
`%s`	Segundos (`00`..`59`)
`%f`	Microsegundos (`000000`..`999999`)
`%p`	`AM` ou `PM`
`%w`	Dia da semana (`0`=Domingo..`6`=Sabado)
`%U`	Semana(`00`..`53`), onde o Domingo é o primeiro dia da semana.
`%u`	Semana(`00`..`53`), onde a Segunda é o primeiro dia da semana.
`%V`	Semana(`01`..`53`), onde o Domingo é o primeiro dia da semana; usado com `%X`
`%v`	Semana(`01`..`53`), onde a Segunda é o primeiro dia da semana; usado com `%x`
`%%`	Um literal ‘`%`’.

Todos os outros caracteres são apenas copiados para o resultado, sem interpretação.

O especificador dr formato %f está disponível a partir do MySQL 4.1.1.

Como na versão 3.23 do MySQL, o caracter ‘%’ é exigido antes dos caracteres de especificação de formato. Em versões anteriores do MySQL ‘%’ era opcional.

A razão para a faixa de valores do mês e do dia começarem com zero é que o MySQL permite datas incompletas tais como '2004-00-00' serem armazenadas no MySQL 3.23.

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'
mysql> SELECT DATE_FORMAT('1999-01-01', '%X %V');
        -> '1998 52'

STR_TO_DATE(str,format)Esta é a função reversa da função DATE_FORMAT(). Ela pega uma string str, e um formato format, e retorna uma valor DATETIME.Os valores date, time, ou datetime contidos em str devem ser dados no formato indicado por format. Para o especificadores que podem ser usados em format, veja a tabela na descrição da função DATE_FORMAT(). Todos os outros caracteres serão apenas exibidos, não sendo interpretados. Se str contém um valor date, time, ou datetime ilegal, STR_TO_DATE() retorna NULL.
```
mysql> SELECT STR_TO_DATE('03.10.2003 09.20', '%d.%m.%Y %H.%i')
        -> 2003-10-03 09:20:00
mysql> SELECT STR_TO_DATE('10rap', '%crap')
        -> 0000-10-00 00:00:00
mysql> SELECT STR_TO_DATE('2003-15-10 00:00:00', '%Y-%m-%d %H:%i:%s')
        -> NULL
```
STR_TO_DATE() está disponível a partir do MySQL 4.1.1.

GET_FORMAT(DATE | TIME | TIMESTAMP, 'EUR' | 'USA' | 'JIS' | 'ISO' | 'INTERNAL')Retorna uma string de formato. Esta função é útil combinado com as funções DATE_FORMAT() e STR_TO_DATE(), e quando configurarmos as variáveis do servidor DATE_FORMAT, TIME_FORMAT e DATETIME_FORMAT. Os três valores possíveis para o primeiro argumento e os cinco valores possíveis para o segundo argumento resultam em 15 strings de formato possíveis (para o especificador usado, veja a tabela na descrição da função DATE_FORMAT()):

Chamada da Função	Resultado
`GET_FORMAT(DATE,'USA')`	`'%m.%d.%Y'`
`GET_FORMAT(DATE,'JIS')`	`'%Y-%m-%d'`
`GET_FORMAT(DATE,'ISO')`	`'%Y-%m-%d'`
`GET_FORMAT(DATE,'EUR')`	`'%d.%m.%Y'`
`GET_FORMAT(DATE,'INTERNAL')`	`'%Y%m%d'`
`GET_FORMAT(TIMESTAMP,'USA')`	`'%Y-%m-%d-%H.%i.%s'`
`GET_FORMAT(TIMESTAMP,'JIS')`	`'%Y-%m-%d %H:%i:%s'`
`GET_FORMAT(TIMESTAMP,'ISO')`	`'%Y-%m-%d %H:%i:%s'`
`GET_FORMAT(TIMESTAMP,'EUR')`	`'%Y-%m-%d-%H.%i.%s'`
`GET_FORMAT(TIMESTAMP,'INTERNAL')`	`'%Y%m%d%H%i%s'`
`GET_FORMAT(TIME,'USA')`	`'%h:%i:%s %p'`
`GET_FORMAT(TIME,'JIS')`	`'%H:%i:%s'`
`GET_FORMAT(TIME,'ISO')`	`'%H:%i:%s'`
`GET_FORMAT(TIME,'EUR')`	`'%H.%i.%S'`
`GET_FORMAT(TIME,'INTERNAL')`	`'%H%i%s'`

Formato ISO é do ISO ISO 9075, não do ISO 8601.

mysql> SELECT DATE_FORMAT('2003-10-03', GET_FORMAT(DATE, 'EUR')
        -> '03.10.2003'
mysql> SELECT STR_TO_DATE('10.31.2003', GET_FORMAT(DATE, 'USA'))
        -> 2003-10-31
mysql> SET DATE_FORMAT=GET_FORMAT(DATE, 'USA'); SELECT '2003-10-31';
        -> 10-31-2003

GET_FORMAT() está disponível a partir do MySQL 4.1.1. Veja See Secção 5.5.6, “Sintaxe de SET”.

SUBDATE(date,INTERVAL expr type), SUBDATE(expr,days)Quando chamado com a forma INTERVAL do segunto argumento, SUBDATE() é um sinonimo para DATE_SUB().
```
mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
    -> '1997-12-02'
mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);
    -> '1997-12-02'
```
A partir do MySQL 4.1.1, a segunda sintaxe é permitida, onde expr é uma expressão date ou datetime e days é o número de dias a ser subtraído de expr.
```
mysql> SELECT SUBDATE('1998-01-02 12:00:00', 31);
  -> '1997-12-02 12:00:00'
```
SUBTIME(expr,expr2)SUBTIME() subtrai expr2 de expr e retorna o resultado. expr é uma expressão date ou datetime, e expr2 é uma expressão time.
```
mysql> SELECT SUBTIME("1997-12-31 23:59:59.999999", "1 1:1:1.000002");
  -> '1997-12-30 22:58:58.999997'
mysql> SELECT SUBTIME("01:00:00.999999", "02:00:00.999998");
  -> '-00:59:59.999999'
```
SUBTIME() foi adicionado no MySQL 4.1.1.
TIME_FORMAT(hora,formato)É usado como a função DATE_FORMAT() acima, mas a string de formato pode conter apenas os especificadores de formato que tratam de horas, minutos e segundos. Outros especificadores produzem um valor NULL ou 0.Se o valor time contém uma hora que é maior que 23, os especificadores de formato de hora %H e %k produzem um valor maior que a faixa como de 0..23. O outro especificador do formato de hora produz o valor da hora módulo 12:
```
mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
        -> '100 100 04 04 4'
```

LAST_DAY(data)Pega um valor date ou datetime e retorna o valor correspondente para o último dia do mês. Retorna NULL se o argumento é invalido.

mysql> SELECT LAST_DAY('2003-02-05'), LAST_DAY('2004-02-05');
        -> '2003-02-28', '2004-02-29'
mysql> SELECT LAST_DAY('2004-01-01 01:01:01');
        -> '2004-01-31'
mysql> SELECT LAST_DAY('2003-03-32');
        -> NULL

LAST_DAY() está disponível a partir do MySQL 4.1.1.

MAKEDATE(ano,diadoano)Retorna uma data, dado os valores da ano e dia do ano. diadoano deve ser maior que 0 ou o resultado será NULL.

mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);
        -> '2001-01-31', '2001-02-01'
mysql> SELECT MAKEDATE(2001,365), MAKEDATE(2004,365);
  -> '2001-12-31', '2004-12-30'
mysql> SELECT MAKEDATE(2001,0);
        -> NULL

MAKEDATE() está disponível a partir do MySQL 4.1.1.

MAKETIME(hora,minuto,segundo)Retorna um valor time calculado a partir dos argmentos hora, minuto e segundo.
```
mysql> SELECT MAKETIME(12,15,30);
  -> '12:15:30'
```
MAKETIME() está disponível a partir do MySQL 4.1.1.
CURDATE(), CURRENT_DATE, CURRENT_DATE()Retorna a data atual como um valor no formato 'YYYY-MM-DD' ou YYYYMMDD, dependendo se a função é usada num contexto numérico ou de string.
```
mysql> SELECT CURDATE();
        -> '1997-12-15'
mysql> SELECT CURDATE() + 0;
        -> 19971215
```
CURTIME(), CURRENT_TIME, CURRENT_TIME()Retorna a hora atual como um valor no formato 'HH:MM:SS' ou HHMMSS, dependo se a função é usada em um contexto numérico ou como string:
```
mysql> SELECT CURTIME();
        -> '23:50:26'
mysql> SELECT CURTIME() + 0;
        -> 235026
```
NOW(), SYSDATE(), CURRENT_TIMESTAMP, CURRENT_TIMESTAMP(), LOCALTIME, LOCALTIME(), LOCALTIMESTAMP, LOCALTIMESTAMP()Retorna a data e hora atual como um valor no formato 'YYYY-MM-DD HH:MM:SS' ou YYYYMMDDHHMMSS, dependendo se a função é utilizada num contexto numérico ou de string.
```
mysql> SELECT NOW();
        -> '1997-12-15 23:50:26'
mysql> SELECT NOW() + 0;
        -> 19971215235026
```
UNIX_TIMESTAMP(), UNIX_TIMESTAMP(data)Se chamado sem argumento, retorna um tipo timestamp do Unix (segundos desde '1970-01-01 00:00:00' GMT) como um inteiro sem sinal. Se UNIX_TIMESTAMP() é chamada com um argumento data, é retornado o valor do argumento como segundo desde '1970-01-01 00:00:00' GMT. data pode ser um string DATE, uma string DATETIME, um TIMESTAMP, ou um número no formato YYMMDD ou YYYYMMDD na hora local:
```
mysql> SELECT UNIX_TIMESTAMP();
        -> 882226357
mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
        -> 875996580
```
Qaundo UNIX_TIMESTAMP é usado em uma coluna TIMESTAMP, a função retorna o valor timestamp interno diretamente, sem nenhuma conversão “string-para-unix-timestamp” implicita. Se você passar uma data fora da faixa para UNIX_TIMESTAMP(), a função irá retornar 0, mas por favor note que só verificações básicas são realizadas. (ano 1970-2037, mês 01-12, dia 01-31).

Se você subtrair colunas UNIX_TIMESTAMP(), você pode querer mudar o resultado para inteiro com sinal. See Secção 6.3.5, “Funções de Conversão”.
FROM_UNIXTIME(unix_timestamp), FROM_UNIXTIME(unix_timestamp,format)Retorna a representação do argumento unix_timestamp como um valor no formato 'YYYY-MM-DD HH:MM:SS' ou YYYYMMDDHHMMSS, dependendo de do contexto em que a funçõ é utilizada:
```
mysql> SELECT FROM_UNIXTIME(875996580);
        -> '1997-10-04 22:23:00'
mysql> SELECT FROM_UNIXTIME(875996580) + 0;
        -> 19971004222300
```
Se o formato é dado o resultado é formatado de acordo com a string formato. formato pode conter os especificadores listados acima para a função DATE_FORMAT()
```
mysql> SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(),
    ->                      '%Y %D %M %h:%i:%s %x');
    -> '2003 6th August 06:22:58 2003'
```
SEC_TO_TIME(seconds)Retorna o argumento segundos, convertido em horas, minutos e segundos como um valor no formato 'HH:MM:SS' ou HHMMSS, dependendo do contexto em que a função é utilizada:
```
mysql> SELECT SEC_TO_TIME(2378);
        -> '00:39:38'
mysql> SELECT SEC_TO_TIME(2378) + 0;
        -> 3938
```

TIME_TO_SEC(time)Retorna o argumento time, convertido em segundos:

mysql> SELECT TIME_TO_SEC('22:23:00');
        -> 80580
mysql> SELECT TIME_TO_SEC('00:39:38');
        -> 2378

UTC_DATE, UTC_DATE()Retorna a data UTC atual como um valor no formato 'YYYY-MM-DD' ou YYYYMMDD, dependendo se a função é usada emum contexto string ou numérico:
```
mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
-> '2003-08-14', 20030814
```
UTC_DATE() está disponível a partir do MySQL 4.1.1.
UTC_TIME, UTC_TIME()Retorna a hora UTC atual como um valor no formato 'HH:MM:SS' ou HHMMSS, dependendo se a função é usada em um contexto string ou numérico:
```
mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
  -> '18:07:53', 180753
```
UTC_TIME() está disponível a partir do MySQL 4.1.1.
UTC_TIMESTAMP, UTC_TIMESTAMP()Retorna a data e hora UTC atual como um valor no formato 'YYYY-MM-DD HH:MM:SS' ou YYYYMMDDHHMMSS, dependendo se a função é usada em um contexto string ou numérico:
```
mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
  -> '2003-08-14 18:08:04', 20030814180804
```
UTC_TIMESTAMP() está disponível a partir do MySQL 4.1.1.

Fonte: http://dev.mysql.com/doc

Nenhum Post Relacionado.

Artigos parecidos fornecidos por Yet Another Related Posts Plugin.

Tags: Banco de Dados, CURDATE, CURTIME, date, MySQL, PHP, TIME, TO_DAYS, UTC_DATE, UTC_TIME, UTC_TIMESTAMP

This entry was posted on Quarta-feira, Janeiro 13th, 2010 at 10:14 and is filed under Bancos de Dados, Geral, MySQL, SGBD. You can follow any responses to this entry through the RSS 2.0 feed.

Páginas

Who's Online

Medidor de Velocidade

Categorias

Arquivo

Etiquetas

Agenda

Artigos recentes

Links Recomendados

Apoio Publicitário

Cursos 24 Horas

Funções de Data e Hora

Deixe uma Resposta