Funções de Data e Hora

Esta seção descreve as funções que podem ser usadas para manipular valores temporais.

Veja "Tipos de Data e Hora" para uma descrição da faixa de valores que cada tipo tem e os formatos válidos nos quais valores de data e hora podes ser especificados.

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 MariaDB.

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 MariaDB.

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 MariaDB.
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 MariaDB.
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 MariaDB e mais novo) é assumido. Leia "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 MariaDB 4.0.5. O valor mode de 4 e acima pode ser usado a partir do MariaDB 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 MariaDB 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 MariaDB 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 MariaDB.
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 MariaDB.
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 MariaDB 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 MariaDB.

O MariaDB 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), MariaDB 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', MariaDB 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 MariaDB 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 MariaDB, 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 MariaDB.

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 MariaDB.
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 MariaDB.

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

A razão para a faixa de valores do mês e do dia começarem com zero é que o MariaDB permite datas incompletas tais como '2004-00-00' serem armazenadas no MariaDB 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 MariaDB.

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 MariaDB. Veja Leia "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 MariaDB, 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 MariaDB.

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 MariaDB.

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 MariaDB.

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 MariaDB.
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. Leia "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 MariaDB.
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 MariaDB.
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 MariaDB.

Funções de Data e Hora

Retornar