O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). # Perfis de data e hora Nesta seção, você pode encontrar informações sobre as funções escalares de data e hora compatíveis com o Amazon Redshift. **Topics** + [Resumo das funções de data e hora](#date-functions-summary) + [Funções de data e hora em transações](#date-functions-transactions) + [Funções somente nó de liderança defasadas](#date-functions-deprecated) + [Operador \$1 (Concatenação)](r_DATE-CONCATENATE_function.md) + [Função ADD\$1MONTHS](r_ADD_MONTHS.md) + [Função AT TIME ZONE](r_AT_TIME_ZONE.md) + [Função CONVERT\$1TIMEZONE](CONVERT_TIMEZONE.md) + [Função CURRENT\$1DATE](r_CURRENT_DATE_function.md) + [Função DATE\$1CMP](r_DATE_CMP.md) + [Função DATE\$1CMP\$1TIMESTAMP](r_DATE_CMP_TIMESTAMP.md) + [Função DATE\$1CMP\$1TIMESTAMPTZ](r_DATE_CMP_TIMESTAMPTZ.md) + [Função DATEADD](r_DATEADD_function.md) + [Função DATEDIFF](r_DATEDIFF_function.md) + [Função DATE\$1PART](r_DATE_PART_function.md) + [Função DATE\$1PART\$1YEAR](r_DATE_PART_YEAR.md) + [Função DATE\$1TRUNC](r_DATE_TRUNC.md) + [Função EXTRACT](r_EXTRACT_function.md) + [Função GETDATE](r_GETDATE.md) + [Função INTERVAL\$1CMP](r_INTERVAL_CMP.md) + [Função LAST\$1DAY](r_LAST_DAY.md) + [Função MONTHS\$1BETWEEN](r_MONTHS_BETWEEN_function.md) + [Função NEXT\$1DAY](r_NEXT_DAY.md) + [Função SYSDATE](r_SYSDATE.md) + [Função TIMEOFDAY](r_TIMEOFDAY_function.md) + [Função TIMESTAMP\$1CMP](r_TIMESTAMP_CMP.md) + [Função TIMESTAMP\$1CMP\$1DATE](r_TIMESTAMP_CMP_DATE.md) + [Função TIMESTAMP\$1CMP\$1TIMESTAMPTZ](r_TIMESTAMP_CMP_TIMESTAMPTZ.md) + [Função TIMESTAMPTZ\$1CMP](r_TIMESTAMPTZ_CMP.md) + [Função TIMESTAMPTZ\$1CMP\$1DATE](r_TIMESTAMPTZ_CMP_DATE.md) + [Função TIMESTAMPTZ\$1CMP\$1TIMESTAMP](r_TIMESTAMPTZ_CMP_TIMESTAMP.md) + [Função TIMEZONE](r_TIMEZONE.md) + [Função TO\$1TIMESTAMP](r_TO_TIMESTAMP.md) + [Função TRUNC](r_TRUNC_date.md) + [Partes da data para funções de data ou de timestamp](r_Dateparts_for_datetime_functions.md) ## Resumo das funções de data e hora [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/Date_functions_header.html) **nota** Segundos intercalados não são considerados em cálculos tempo decorrido. ## Funções de data e hora em transações Quando você executa as seguintes funções em um bloco de transação (BEGIN… END), a função retorna a data ou hora de início da transação atual, não o início da instrução atual. + SYSDATE + TIMESTAMP + CURRENT\$1DATE As seguintes funções sempre retornam a data ou hora de início da atual instrução, mesmo quando estiverem em um bloco de transação. + GETDATE + TIMEOFDAY ## Funções somente nó de liderança defasadas As seguintes funções de data estão defasadas, pois executam somente no nó de liderança. Para obter mais informações, consulte [Função de apenas nó líder](c_SQL_functions_leader_node_only.md). + AGE. Use [Função DATEDIFF](r_DATEDIFF_function.md) em vez disso. + CURRENT\$1TIME. Use [Função GETDATE](r_GETDATE.md) ou [SYSDATE](r_SYSDATE.md) em vez disso. + CURRENT\$1TIMESTAMP. Use [Função GETDATE](r_GETDATE.md) ou [SYSDATE](r_SYSDATE.md) em vez disso. + LOCALTIME. Use [Função GETDATE](r_GETDATE.md) ou [SYSDATE](r_SYSDATE.md) em vez disso. + LOCALTIMESTAMP. Use [Função GETDATE](r_GETDATE.md) ou [SYSDATE](r_SYSDATE.md) em vez disso. + ISFINITE + NOW. Use [Função GETDATE](r_GETDATE.md) ou [SYSDATE](r_SYSDATE.md) em vez disso. Se você usar a função NOW em uma visão materializada, ela será definida como o carimbo de data/hora da criação da visão materializada, em vez do carimbo de data/hora atual. # Operador \$1 (Concatenação) Concatena um DATE para um TIME ou TIMETZ em ambos os lados do símbolo \$1 e retorna um TIMESTAMP ou TIMESTAMPTZ. ## Sintaxe ``` date + {time | timetz} ``` A ordem dos argumentos pode ser invertida. Por exemplo, *hora* \$1 *data*. ## Argumentos *date* Uma coluna de tipo de dados `DATE` ou uma expressão que é avaliada implicitamente como um tipo `DATE`. *hora* Uma coluna de tipo de dados `TIME` ou uma expressão que é avaliada implicitamente como um tipo `TIME`. *timetz* Uma coluna de tipo de dados `TIMETZ` ou uma expressão que é avaliada implicitamente como um tipo `TIMETZ`. ## Tipo de retorno TIMESTAMP se a entrada for *date* \$1 *time*. TIMESTAMPTZ se a entrada for *date* \$1 *timetz*. ## Exemplos ### Exemplo de configuração Para configurar as tabelas TIME\$1TEST e TIMETZ\$1TEST utilizadas nos exemplos, use o comando a seguir. ``` create table time_test(time_val time); insert into time_test values ('20:00:00'), ('00:00:00.5550'), ('00:58:00'); create table timetz_test(timetz_val timetz); insert into timetz_test values ('04:00:00+00'), ('00:00:00.5550+00'), ('05:58:00+00'); ``` ### Exemplos com uma coluna time O TIME\$1TEST da tabela a seguir tem uma coluna TIME\$1VAL (tipo TIME) com três valores inseridos. ``` select time_val from time_test; time_val --------------------- 20:00:00 00:00:00.5550 00:58:00 ``` O exemplo a seguir concatena um literal de data e uma coluna TIME\$1VAL. ``` select date '2000-01-02' + time_val as ts from time_test; ts --------------------- 2000-01-02 20:00:00 2000-01-02 00:00:00.5550 2000-01-02 00:58:00 ``` O exemplo a seguir concatena um literal de data e um literal de tempo. ``` select date '2000-01-01' + time '20:00:00' as ts; ts --------------------- 2000-01-01 20:00:00 ``` O exemplo a seguir concatena um literal de hora e um literal de data. ``` select time '20:00:00' + date '2000-01-01' as ts; ts --------------------- 2000-01-01 20:00:00 ``` ### Exemplos com uma coluna TIMETZ O TIMETZ\$1TEST da tabela de exemplo a seguir tem uma coluna TIMETZ\$1VAL (tipo TIMETZ) com três valores inseridos. ``` select timetz_val from timetz_test; timetz_val ------------------ 04:00:00+00 00:00:00.5550+00 05:58:00+00 ``` O exemplo a seguir concatena um literal de data e uma coluna TIMETZ\$1VAL. ``` select date '2000-01-01' + timetz_val as ts from timetz_test; ts --------------------- 2000-01-01 04:00:00+00 2000-01-01 00:00:00.5550+00 2000-01-01 05:58:00+00 ``` O exemplo a seguir concatena uma coluna TIMETZ\$1VAL e um literal de data. ``` select timetz_val + date '2000-01-01' as ts from timetz_test; ts --------------------- 2000-01-01 04:00:00+00 2000-01-01 00:00:00.5550+00 2000-01-01 05:58:00+00 ``` O exemplo a seguir concatena um literal DATE e um literal TIMETZ. O exemplo retorna um TIMESTAMPTZ que está no fuso horário UTC por padrão. O UTC está oito horas à frente do PST, então o resultado está oito horas antes do horário da entrada. ``` select date '2000-01-01' + timetz '20:00:00 PST' as ts; ts ------------------------ 2000-01-02 04:00:00+00 ``` # Função ADD\$1MONTHS ADD\$1MONTHS adiciona o número especificado de meses a um valor ou expressão de data ou timestamp. A função [DATEADD](r_DATEADD_function.md) oferece funcionalidade semelhante. ## Sintaxe ``` ADD_MONTHS( {date | timestamp}, integer) ``` ## Argumentos *date* \$1 *timestamp* Uma coluna de tipo de dados `DATE` ou `TIMESTAMP` ou uma expressão que é avaliada implicitamente como um tipo `DATE` ou `TIMESTAMP`. Se a data for o último dia do mês ou se o mês resultante for mais curto, a função retorna o último dia do mês nos resultados. Para outras datas, o resultado contém o mesmo número de dia que a expressão de data. *integer* Um valor de de tipo de dados `INTEGER`. Use um número negativo para subtrair meses de datas. ## Tipo de retorno TIMESTAMP ## Exemplos A seguinte consulta usa a função de ADD\$1MONTHS dentro de uma função TRUNC. A função TRUNC remove o horário do dia dos resultados de ADD\$1MONTHS. A função ADD\$1MONTHS adiciona 12 meses a cada valor da coluna CALDATE. Os valores na coluna CALDATE são datas. ``` select distinct trunc(add_months(caldate, 12)) as calplus12, trunc(caldate) as cal from date order by 1 asc; calplus12 | cal ------------+------------ 2009-01-01 | 2008-01-01 2009-01-02 | 2008-01-02 2009-01-03 | 2008-01-03 ... (365 rows) ``` O exemplo a seguir usa a função ADD\$1MONTHS para adicionar um mês a um *carimbo de data/hora*. ``` select add_months('2008-01-01 05:07:30', 1); add_months --------------------- 2008-02-01 05:07:30 ``` Os seguintes exemplos demonstram o comportamento quando a função ADD\$1MONTHS opera em datas com meses que têm diferentes número de dias. Este exemplo mostra como a função lida com a adição de um mês a 31 de março e a adição de um mês a 30 de abril. Abril tem 30 dias, então adicionar 1 mês a 31 de março resulta em 30 de abril. Maio tem 31 dias, então adicionar 1 mês a 30 de abril resulta em 31 de maio. ``` select add_months('2008-03-31',1); add_months --------------------- 2008-04-30 00:00:00 select add_months('2008-04-30',1); add_months --------------------- 2008-05-31 00:00:00 ``` # Função AT TIME ZONE AT TIME ZONE especifica qual fuso horário a usar com uma expressão TIMESTAMP ou TIMESTAMPTZ. ## Sintaxe ``` AT TIME ZONE 'timezone' ``` ## Argumentos *timezone* O `TIMEZONE` do valor de retorno. O fuso horário pode ser especificado como um nome de fuso horário (como **'Africa/Kampala'** ou **'Singapore'**) ou como uma abreviação de fuso horário (como **'UTC'** ou **'PDT'**). Para visualizar uma lista de nomes de fusos horários compatíveis, execute o comando a seguir. ``` select pg_timezone_names(); ``` Para visualizar uma lista de abreviações de fusos horários compatíveis, execute o comando a seguir. ``` select pg_timezone_abbrevs(); ``` Para ter mais informações e exemplos, consulte [Observações quanto ao uso de fuso horário](CONVERT_TIMEZONE.md#CONVERT_TIMEZONE-usage-notes). ## Tipo de retorno TIMESTAMPTZ quando usado com uma expressão TIMESTAMP. TIMESTAMP quando usado com uma expressão TIMESTAMPTZ. ## Exemplos O exemplo a seguir converte um valor de carimbo de data/hora sem fuso horário e o interpreta como o fuso MST (UTC\$17 em POSIX). O exemplo retorna um valor do tipo de dados TIMESTAMPTZ para o fuso horário UTC. Se configurar o fuso horário padrão como um fuso horário diferente de UTC, você poderá ver um resultado diferente. ``` SELECT TIMESTAMP '2001-02-16 20:38:40' AT TIME ZONE 'MST'; timezone ------------------------ 2001-02-17 03:38:40+00 ``` O exemplo a seguir pega um time stamp de entrada com um valor de fuso horário em que o fuso horário especificado é EST (UTC\$15 em POSIX) e o converte para MST (UTC\$17 em POSIX). O exemplo retorna um valor do tipo de dados TIMESTAMP. ``` SELECT TIMESTAMPTZ '2001-02-16 20:38:40-05' AT TIME ZONE 'MST'; timezone ------------------------ 2001-02-16 18:38:40 ``` # Função CONVERT\$1TIMEZONE CONVERT\$1TIMEZONE converte um timestamp de um fuso horário para outro. A função se ajusta automaticamente para o horário de verão. ## Sintaxe ``` CONVERT_TIMEZONE( ['source_timezone',] 'target_timezone', 'timestamp') ``` ## Argumentos *source\$1timezone* (Opcional) O fuso horário do timestamp atual. O padrão é UTC. Para obter mais informações, consulte [Observações quanto ao uso de fuso horário](#CONVERT_TIMEZONE-usage-notes). *target\$1timezone* O fuso horário do novo timestamp. Para obter mais informações, consulte [Observações quanto ao uso de fuso horário](#CONVERT_TIMEZONE-usage-notes). *timestamp* Uma coluna de timestamp ou uma expressão que converta implicitamente para um timestamp. ## Tipo de retorno TIMESTAMP ## Observações quanto ao uso de fuso horário *source\$1timezone* ou *target\$1timezone* pode ser especificado como o nome do fuso horário (tal como “África/Kampala” ou “Singapura”) ou como uma abreviatura de fuso horário (tal como “UTC” ou “PDT”). Você não precisa converter nomes de fuso horário em nomes ou abreviaturas em abreviaturas. Por exemplo, você pode escolher um carimbo de data e hora do nome de fuso horário de origem “Singapura” e convertê-lo em um carimbo de data e hora na abreviatura de fuso horário “PDT”. **nota** Os resultados da utilização de um nome de fuso horário ou de uma abreviatura de fuso horário podem ser diferentes devido ao horário sazonal local, como o horário de verão. ### Usar um nome de fuso horário Para visualizar uma lista completa e atualizada de nomes de fuso horário, execute o comando a seguir. ``` select pg_timezone_names(); ``` Cada linha contém uma string separada por vírgula com o nome do fuso horário, abreviatura, deslocamento do UTC e indicador se o fuso horário segue o horário de verão (`t` ou `f`). Por exemplo, o trecho a seguir mostra duas linhas resultantes. A primeira linha é o fuso horário `Antarctica/South Pole`, abreviatura `NZDT`, com deslocamento `13:00:00` do UTC e `f` para indicar que não segue o horário de verão. A segunda linha é o fuso horário `Europe/Paris`, abreviatura `CET`, com deslocamento `01:00:00` do UTC e `f` para indicar que segue o horário de verão. ``` pg_timezone_names ------------------ (Antarctica/South_Pole,NZDT,13:00:00,t) (Europe/Paris,CET,01:00:00,f) ``` Execute a instrução SQL para obter a lista inteira e encontrar um nome de fuso horário. Aproximadamente 600 linhas são retornadas. Embora alguns dos nomes de fuso horário retornados sejam iniciais em maiúsculas ou acrônimos (por exemplo, GB, PRC, ROK), a função CONVERT\$1TIMEZONE os trata como nomes de fuso horário, e não abreviações. Se você especificar um fuso horário usando um nome de fuso horário, CONVERT\$1TIMEZONE fará o ajuste automático para o horário de verão (DST) ou qualquer outro protocolo sazonal local, tal como horário de verão, horário padrão ou horário de inverno, que esteja em vigor durante a data e hora especificadas pelo “*carimbo de data/hora*”. Por exemplo, “Europa/Londres” representa UTC no inverno e adiciona uma hora no verão. Observe que o Amazon Redshift usa o [banco de dados de fuso horário IANA](https://www.iana.org/time-zones) como fonte autorizada de especificação de fuso horário. ### Usar uma abreviação de fuso horário Para visualizar uma lista completa e atualizada de abreviaturas de fuso horário, execute o comando a seguir. ``` select pg_timezone_abbrevs(); ``` Os resultados contêm uma string separada por vírgulas com a abreviatura do fuso horário, o deslocamento do UTC e o indicador que informa se o fuso horário segue o horário de verão (`t` ou `f`). Por exemplo, o trecho a seguir mostra duas linhas resultantes. A primeira linha contém a abreviatura de Pacific Daylight Time, `PDT`, com um deslocamento de `-07:00:00` do UTC e `t` para indicar que segue o horário de verão. A segunda linha contém a abreviatura de Pacific Standard Time, `PST`, com um deslocamento de `-08:00:00` do UTC e `f` para indicar que não segue o horário de verão. ``` pg_timezone_abbrevs -------------------- (PDT,-07:00:00,t) (PST,-08:00:00,f) ``` Execute a instrução SQL para obter a lista completa e encontrar uma abreviatura com base em seu deslocamento e indicador de horário de verão. Aproximadamente 200 linhas são retornadas. As abreviações de fuso horário representam um deslocamento fixo do UTC. Se você especificar um fuso horário usando uma abreviatura de fuso horário, CONVERT\$1TIMEZONE usará o deslocamento fixo do UTC e não fará o ajuste para nenhum protocolo sazonal local. ### Usar o formato de estilo POSIX Uma especificação de fuso horário no estilo POSIX tem o formato *STDoffset* ou *STDoffsetDST*, em que *STD* é uma abreviatura de fuso horário, *offset* é o desvio numérico em horas a oeste de UTC e *DST* é uma abreviatura opcional de fuso horário de verão. Supõe-se que o horário de verão seja uma hora a mais que o deslocamento fornecido. Os formatos de fuso horário estilo POSIX usam deslocamentos positivos à Oeste de Greenwich, em contraste com a convenção ISO-8601, usando deslocamentos positivos à Leste de Greenwich. A seguir, exemplos de fusos horários no estilo POSIX: + PST8 + PST8PDT + EST5 + EST5EDT **nota** O Amazon Redshift não valida especificações de fuso horário no estilo POSIX, portanto é possível definir o fuso horário com um valor inválido. Por exemplo, o seguinte comando não retorna um erro, mesmo que ele defina o fuso horário com um valor inválido. ``` set timezone to ‘xxx36’; ``` ## Exemplos Muitos dos exemplos usam a amostra de conjunto de dados TICKIT. Para obter mais informações, consulte [Banco de dados de amostra](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html). O exemplo a seguir converte o valor de carimbo de data/hora do fuso horário UTC padrão em PST. ``` select convert_timezone('PST', '2008-08-21 07:23:54'); convert_timezone ------------------------ 2008-08-20 23:23:54 ``` O exemplo a seguir converte o valor do timestamp na coluna LISTTIME do fuso horário UTC padrão para PST. Embora o timestamp esteja no período de horário de verão, ele é convertido para o horário padrão, pois o fuso horário de destino é especificado como uma abreviação (PST). ``` select listtime, convert_timezone('PST', listtime) from listing where listid = 16; listtime | convert_timezone --------------------+------------------- 2008-08-24 09:36:12 2008-08-24 01:36:12 ``` O seguinte exemplo converte uma coluna de fuso horário LISTTIME do fuso horário UTC padrão para o fuso horário EUA/Pacífico. A fuso horário de destino usa um nome de fuso horário e o timestamp está no horário de verão, portanto a função retorna o horário de verão. ``` select listtime, convert_timezone('US/Pacific', listtime) from listing where listid = 16; listtime | convert_timezone --------------------+--------------------- 2008-08-24 09:36:12 | 2008-08-24 02:36:12 ``` O exemplo a seguir converte uma string de timestamp de EST para PST: ``` select convert_timezone('EST', 'PST', '20080305 12:25:29'); convert_timezone ------------------- 2008-03-05 09:25:29 ``` O exemplo a seguir converte um timestamp para o horário padrão do Leste dos EUA, pois o fuso horário de destino usa um nome de fuso horário (America/New\$1York) e o timestamp está dentro do período de horário padrão. ``` select convert_timezone('America/New_York', '2013-02-01 08:00:00'); convert_timezone --------------------- 2013-02-01 03:00:00 (1 row) ``` O seguinte exemplo converte o timestamp para o horário de verão do Leste dos EUA, pois o fuso horário de destino usa um nome de fuso horário (America/New\$1York) e o timestamp está dentro do período do horário de verão. ``` select convert_timezone('America/New_York', '2013-06-01 08:00:00'); convert_timezone --------------------- 2013-06-01 04:00:00 (1 row) ``` O seguinte exemplo demonstra o uso de deslocamentos. ``` SELECT CONVERT_TIMEZONE('GMT','NEWZONE +2','2014-05-17 12:00:00') as newzone_plus_2, CONVERT_TIMEZONE('GMT','NEWZONE-2:15','2014-05-17 12:00:00') as newzone_minus_2_15, CONVERT_TIMEZONE('GMT','America/Los_Angeles+2','2014-05-17 12:00:00') as la_plus_2, CONVERT_TIMEZONE('GMT','GMT+2','2014-05-17 12:00:00') as gmt_plus_2; newzone_plus_2 | newzone_minus_2_15 | la_plus_2 | gmt_plus_2 ---------------------+---------------------+---------------------+--------------------- 2014-05-17 10:00:00 | 2014-05-17 14:15:00 | 2014-05-17 10:00:00 | 2014-05-17 10:00:00 (1 row) ``` # Função CURRENT\$1DATE CURRENT\$1DATE retorna uma data no fuso horário da sessão atual (UTC por padrão) no formato padrão: AAAA-MM-DD. **nota** CURRENT\$1DATE retorna a data de início para a transação atual, não para o início da instrução atual. Considere o cenário em que você inicia uma transação contendo várias declarações em 10/01/08 23:59, e a declaração contendo CURRENT\$1DATE é executada em 10/02/08 00:00. CURRENT\$1DATE retorna `10/01/08`, não `10/02/08`. ## Sintaxe ``` CURRENT_DATE ``` ## Tipo de retorno DATE ## Exemplos O exemplo a seguir retorna a data atual (na Região da AWS onde a função é executada). ``` select current_date; date ------------ 2008-10-01 ``` O exemplo a seguir cria uma tabela, insere uma linha em que o padrão da coluna `todays_date` é CURRENT\$1DATE e, depois, seleciona todas as linhas na tabela. ``` CREATE TABLE insert_dates( label varchar(128) NOT NULL, todays_date DATE DEFAULT CURRENT_DATE); INSERT INTO insert_dates(label) VALUES('Date row inserted'); SELECT * FROM insert_dates; label | todays_date ------------------+------------- Date row inserted | 2023-05-10 ``` # Função DATE\$1CMP DATE\$1CMP compara duas datas. A função exibe `0` se as datas forem idênticas, `1` se *date1* for maior e `-1` se *date2* for maior. ## Sintaxe ``` DATE_CMP(date1, date2) ``` ## Argumentos *date1* Uma coluna de tipo de dados `DATE` ou uma expressão que é avaliada como um tipo `DATE`. *date2* Uma coluna de tipo de dados `DATE` ou uma expressão que é avaliada como um tipo `DATE`. ## Tipo de retorno INTEGER ## Exemplos A seguinte consulta compara os valores de DATE na coluna CALDATE à data 4 de janeiro de 2008 e retorna se o valor em CALDATE é antes (`-1`), igual a (`0`) ou depois (`1`) de 4 de janeiro de 2008: ``` select caldate, '2008-01-04', date_cmp(caldate,'2008-01-04') from date order by dateid limit 10; caldate | ?column? | date_cmp -----------+------------+---------- 2008-01-01 | 2008-01-04 | -1 2008-01-02 | 2008-01-04 | -1 2008-01-03 | 2008-01-04 | -1 2008-01-04 | 2008-01-04 | 0 2008-01-05 | 2008-01-04 | 1 2008-01-06 | 2008-01-04 | 1 2008-01-07 | 2008-01-04 | 1 2008-01-08 | 2008-01-04 | 1 2008-01-09 | 2008-01-04 | 1 2008-01-10 | 2008-01-04 | 1 (10 rows) ``` # Função DATE\$1CMP\$1TIMESTAMP DATE\$1CMP\$1TIMESTAMP compara uma data a um carimbo de data/hora e exibe `0` se os valores forem idênticos, `1` se *date* for maior cronologicamente e `-1` se *timestamp* for maior. ## Sintaxe ``` DATE_CMP_TIMESTAMP(date, timestamp) ``` ## Argumentos *date* Uma coluna de tipo de dados `DATE` ou uma expressão que é avaliada como um tipo `DATE`. *timestamp* Uma coluna de tipo de dados `TIMESTAMP` ou uma expressão que é avaliada como um tipo `TIMESTAMP`. ## Tipo de retorno INTEGER ## Exemplos O seguinte exemplo compara a data `2008-06-18` à LISTTIME. Os valores da coluna LISTTIME são carimbos de data/hora. Ofertas feitas antes desta data retornam `1`; ofertas feitas após esta data retornam `-1`. ``` select listid, '2008-06-18', listtime, date_cmp_timestamp('2008-06-18', listtime) from listing order by 1, 2, 3, 4 limit 10; listid | ?column? | listtime | date_cmp_timestamp --------+------------+---------------------+-------------------- 1 | 2008-06-18 | 2008-01-24 06:43:29 | 1 2 | 2008-06-18 | 2008-03-05 12:25:29 | 1 3 | 2008-06-18 | 2008-11-01 07:35:33 | -1 4 | 2008-06-18 | 2008-05-24 01:18:37 | 1 5 | 2008-06-18 | 2008-05-17 02:29:11 | 1 6 | 2008-06-18 | 2008-08-15 02:08:13 | -1 7 | 2008-06-18 | 2008-11-15 09:38:15 | -1 8 | 2008-06-18 | 2008-11-09 05:07:30 | -1 9 | 2008-06-18 | 2008-09-09 08:03:36 | -1 10 | 2008-06-18 | 2008-06-17 09:44:54 | 1 (10 rows) ``` # Função DATE\$1CMP\$1TIMESTAMPTZ DATE\$1CMP\$1TIMESTAMPTZ compara uma data a um carimbo de data/hora com fuso horário e exibe `0` se os valores forem idênticos, `1` se *date* for maior cronologicamente e `-1` se *timestamptz* for maior. ## Sintaxe ``` DATE_CMP_TIMESTAMPTZ(date, timestamptz) ``` ## Argumentos *date* Uma coluna de tipo de dados `DATE` ou uma expressão que é avaliada implicitamente como um tipo `DATE`. *timestamptz* Uma coluna de tipo de dados `TIMESTAMPTZ` ou uma expressão que é avaliada implicitamente como um tipo `TIMESTAMPTZ`. ## Tipo de retorno INTEGER ## Exemplos O seguinte exemplo compara a data `2008-06-18` à LISTTIME. Ofertas feitas antes desta data retornam `1`; ofertas feitas após esta data retornam `-1`. ``` select listid, '2008-06-18', CAST(listtime AS timestamptz), date_cmp_timestamptz('2008-06-18', CAST(listtime AS timestamptz)) from listing order by 1, 2, 3, 4 limit 10; listid | ?column? | timestamptz | date_cmp_timestamptz --------+------------+------------------------+---------------------- 1 | 2008-06-18 | 2008-01-24 06:43:29+00 | 1 2 | 2008-06-18 | 2008-03-05 12:25:29+00 | 1 3 | 2008-06-18 | 2008-11-01 07:35:33+00 | -1 4 | 2008-06-18 | 2008-05-24 01:18:37+00 | 1 5 | 2008-06-18 | 2008-05-17 02:29:11+00 | 1 6 | 2008-06-18 | 2008-08-15 02:08:13+00 | -1 7 | 2008-06-18 | 2008-11-15 09:38:15+00 | -1 8 | 2008-06-18 | 2008-11-09 05:07:30+00 | -1 9 | 2008-06-18 | 2008-09-09 08:03:36+00 | -1 10 | 2008-06-18 | 2008-06-17 09:44:54+00 | 1 (10 rows) ``` # Função DATEADD Incrementa um valor DATE, TIME, TIMETZ ou TIMESTAMP com um intervalo especificado. ## Sintaxe ``` DATEADD( datepart, interval, {date|time|timetz|timestamp} ) ``` ## Argumentos *datepart* A parte da data (ano, mês, dia ou hora, por exemplo) sobre a qual a função atua. Para obter mais informações, consulte [Partes da data para funções de data ou de timestamp](r_Dateparts_for_datetime_functions.md). *intervalo* Um número inteiro que especificou o intervalo (número de dias, por exemplo) a adicionar à expressão de destino. Um número inteiro negativo subtrai o intervalo. *date*\$1*time*\$1*timetz*\$1*timestamp* Uma coluna DATE, TIME, TIMETZ ou TIMESTAMP ou uma expressão que converta implicitamente para DATE, TIME, TIMETZ ou TIMESTAMP A expressão DATE, TIME, TIMETZ ou TIMESTAMP deve conter a parte de data especificada. ## Tipo de retorno TIMESTAMP, TIME ou TIMETZ, dependendo do tipo de dados de entrada. ## Exemplos com uma coluna DATE O exemplo a seguir adiciona 30 dias a cada data em novembro que existe na tabela DATE. ``` select dateadd(day,30,caldate) as novplus30 from date where month='NOV' order by dateid; novplus30 --------------------- 2008-12-01 00:00:00 2008-12-02 00:00:00 2008-12-03 00:00:00 ... (30 rows) ``` O exemplo a seguir adiciona 18 meses a um valor de data literal. ``` select dateadd(month,18,'2008-02-28'); date_add --------------------- 2009-08-28 00:00:00 (1 row) ``` O nome padrão da coluna para uma função DATEADD é DATE\$1ADD. O timestamp padrão para um valor de data é `00:00:00`. O exemplo a seguir adiciona 30 minutos a um valor de data que não especifica um timestamp. ``` select dateadd(m,30,'2008-02-28'); date_add --------------------- 2008-02-28 00:30:00 (1 row) ``` Você pode nomear as partes da data por completo ou abreviá-las. Neste caso, *m* significa minutos, não meses. ## Exemplos com uma coluna TIME O TIME\$1TEST da tabela a seguir tem uma coluna TIME\$1VAL (tipo TIME) com três valores inseridos. ``` select time_val from time_test; time_val --------------------- 20:00:00 00:00:00.5550 00:58:00 ``` O exemplo a seguir adiciona 5 minutos a cada TIME\$1VAL na tabela TIME\$1TEST. ``` select dateadd(minute,5,time_val) as minplus5 from time_test; minplus5 --------------- 20:05:00 00:05:00.5550 01:03:00 ``` O exemplo a seguir adiciona 8 horas a um valor de tempo literal. ``` select dateadd(hour, 8, time '13:24:55'); date_add --------------- 21:24:55 ``` O exemplo a seguir mostra quando um tempo passa por 24:00:00 ou abaixo de 00:00:00. ``` select dateadd(hour, 12, time '13:24:55'); date_add --------------- 01:24:55 ``` ## Exemplos com uma coluna TIMETZ Os valores de saída nestes exemplos estão em UTC, que é o fuso horário padrão. O TIMETZ\$1TEST da tabela de exemplo a seguir tem uma coluna TIMETZ\$1VAL (tipo TIMETZ) com três valores inseridos. ``` select timetz_val from timetz_test; timetz_val ------------------ 04:00:00+00 00:00:00.5550+00 05:58:00+00 ``` O exemplo a seguir adiciona 5 minutos a cada TIMETZ\$1VAL na tabela TIMETZ\$1TEST. ``` select dateadd(minute,5,timetz_val) as minplus5_tz from timetz_test; minplus5_tz --------------- 04:05:00+00 00:05:00.5550+00 06:03:00+00 ``` O exemplo a seguir adiciona 2 horas a um valor timetz literal. ``` select dateadd(hour, 2, timetz '13:24:55 PST'); date_add --------------- 23:24:55+00 ``` ## Exemplos com uma coluna TIMESTAMP Os valores de saída nestes exemplos estão em UTC, que é o fuso horário padrão. O exemplo de tabela TIMESTAMP\$1TEST a seguir tem uma coluna TIMESTAMP\$1VAL (tipo TIMESTAMP) com três valores inseridos. ``` SELECT timestamp_val FROM timestamp_test; timestamp_val ------------------ 1988-05-15 10:23:31 2021-03-18 17:20:41 2023-06-02 18:11:12 ``` O exemplo a seguir adiciona 20 anos somente aos valores de TIMESTAMP\$1VAL em TIMESTAMP\$1TEST anteriores ao ano 2000. ``` SELECT dateadd(year,20,timestamp_val) FROM timestamp_test WHERE timestamp_val < to_timestamp('2000-01-01 00:00:00', 'YYYY-MM-DD HH:MI:SS'); date_add --------------- 2008-05-15 10:23:31 ``` O exemplo a seguir adiciona 5 segundos a um valor literal de carimbo de data/hora gravado sem um indicador de segundos. ``` SELECT dateadd(second, 5, timestamp '2001-06-06'); date_add --------------- 2001-06-06 00:00:05 ``` ## Observações de uso As funções DATEADD(month, …) e ADD\$1MONTHS lidam com datas que caiam no final do mês de forma diferente. + ADD\$1MONTHS: Se a data que você estiver adicionando for o último dia do mês, o resultado será sempre o último dia do mês do resultado, independentemente do tamanho do mês. Por exemplo, 30 de abril \$1 1 mês é o dia 31 de maio. ``` select add_months('2008-04-30',1); add_months --------------------- 2008-05-31 00:00:00 (1 row) ``` + DATEADD: Se houver menos dias na data que você está adicionando do que no mês de resultado, o resultado será o dia correspondente do mês de resultado, não o último dia desse mês. Por exemplo, 30 de abril \$1 1 mês é o dia 30 de maio. ``` select dateadd(month,1,'2008-04-30'); date_add --------------------- 2008-05-30 00:00:00 (1 row) ``` A função DATEADD lida com a data de ano bissexto 02-29 de forma diferente ao usar dateadd(month, 12,…) ou dateadd(year, 1, …). ``` select dateadd(month,12,'2016-02-29'); date_add --------------------- 2017-02-28 00:00:00 select dateadd(year, 1, '2016-02-29'); date_add --------------------- 2017-03-01 00:00:00 ``` # Função DATEDIFF DATEDIFF retorna a diferença entre as partes de data de duas expressões de data ou hora. ## Sintaxe ``` DATEDIFF( datepart, {date|time|timetz|timestamp}, {date|time|timetz|timestamp} ) ``` ## Argumentos *datepart* A parte específica do valor de data ou hora (ano, mês ou dia, hora, minuto, segundo, milissegundo ou microsegundo) sobre a qual a função atua. Para obter mais informações, consulte [Partes da data para funções de data ou de timestamp](r_Dateparts_for_datetime_functions.md). Especificamente, DATEDIFF determina o número de limites da parte da data que são cruzados entre duas expressões. Por exemplo, suponha que você esteja calculando a diferença em anos entre duas datas, `12-31-2008` e `01-01-2009`. Neste caso, a função retorna 1 ano, apesar do fato de que essas datas são apenas um dia de diferença. Se você estiver encontrando a diferença em horas entre dois timestamps, `01-01-2009 8:30:00` e `01-01-2009 10:00:00`, o resultado é 2 horas. Se você estiver encontrando a diferença em horas entre dois timestamps, `8:30:00` e `10:00:00`, o resultado é 2 horas. *date*\$1*time*\$1*timetz*\$1*timestamp* Uma coluna ou expressões DATE, TIME, TIMETZ ou TIMESTAMP que implicitamente convertem em DATE, TIME, TIMETZ ou TIMESTAMP. As expressões devem conter a parte da data ou hora especificada. Se a segunda data ou hora for mais recente do que a primeira data ou hora, o resultado será positivo. Se a segunda data ou hora for mais antiga do que a primeira data ou hora, o resultado será negativo. ## Tipo de retorno BIGINT ## Exemplos com uma coluna DATE O exemplo a seguir encontra a diferença, em número de semanas, entre dois valores de data literais. ``` select datediff(week,'2009-01-01','2009-12-31') as numweeks; numweeks ---------- 52 (1 row) ``` O exemplo a seguir encontra a diferença, em horas, entre dois valores de data literais. Quando você não fornece o valor de hora para uma data, o padrão é 00:00:00. ``` select datediff(hour, '2023-01-01', '2023-01-03 05:04:03'); date_diff ---------- 53 (1 row) ``` O exemplo a seguir encontra a diferença, em dias, entre dois valores literais de TIMESTAMETZ. ``` Select datediff(days, 'Jun 1,2008 09:59:59 EST', 'Jul 4,2008 09:59:59 EST') date_diff ---------- 33 ``` O exemplo a seguir encontra a diferença, em dias, entre duas datas na mesma linha de uma tabela. ``` select * from date_table; start_date | end_date -----------+----------- 2009-01-01 | 2009-03-23 2023-01-04 | 2024-05-04 (2 rows) select datediff(day, start_date, end_date) as duration from date_table; duration --------- 81 486 (2 rows) ``` O exemplo a seguir encontra a diferença, em número de trimestres, entre um valor literal no passado e a data de hoje. Este exemplo presume que a data atual seja 5 de junho de 2008. Você pode nomear as partes da data por completo ou abreviá-las. O nome padrão da coluna para a função DATEDIFF é DATE\$1DIFF. ``` select datediff(qtr, '1998-07-01', current_date); date_diff ----------- 40 (1 row) ``` O exemplo a seguir une as tabelas SALES e LISTING para calcular quantos dias os ingressos foram vendidos para as listagens 1000 a 1005 depois de serem listados. A espera mais longa para vendas dessas ofertas foi de 15 dias e a espera mais curta foi de menos de um dia (0 dias). ``` select priceperticket, datediff(day, listtime, saletime) as wait from sales, listing where sales.listid = listing.listid and sales.listid between 1000 and 1005 order by wait desc, priceperticket desc; priceperticket | wait ---------------+------ 96.00 | 15 123.00 | 11 131.00 | 9 123.00 | 6 129.00 | 4 96.00 | 4 96.00 | 0 (7 rows) ``` Este exemplo calcula o número médio de horas que os vendedores esperaram para todas as vendas de ingressos. ``` select avg(datediff(hours, listtime, saletime)) as avgwait from sales, listing where sales.listid = listing.listid; avgwait --------- 465 (1 row) ``` ## Exemplos com uma coluna TIME O TIME\$1TEST da tabela a seguir tem uma coluna TIME\$1VAL (tipo TIME) com três valores inseridos. ``` select time_val from time_test; time_val --------------------- 20:00:00 00:00:00.5550 00:58:00 ``` O exemplo a seguir localiza a diferença no número de horas entre a coluna TIME\$1VAL e um literal de tempo. ``` select datediff(hour, time_val, time '15:24:45') from time_test; date_diff ----------- -5 15 15 ``` O exemplo a seguir localiza a diferença no número de minutos entre dois valores de tempo literal. ``` select datediff(minute, time '20:00:00', time '21:00:00') as nummins; nummins ---------- 60 ``` ## Exemplos com uma coluna TIMETZ O TIMETZ\$1TEST da tabela de exemplo a seguir tem uma coluna TIMETZ\$1VAL (tipo TIMETZ) com três valores inseridos. ``` select timetz_val from timetz_test; timetz_val ------------------ 04:00:00+00 00:00:00.5550+00 05:58:00+00 ``` O exemplo a seguir localiza as diferenças no número de horas, entre um literal TIMETZ e timetz\$1val. ``` select datediff(hours, timetz '20:00:00 PST', timetz_val) as numhours from timetz_test; numhours ---------- 0 -4 1 ``` O exemplo a seguir localiza a diferença no número de horas, entre dois valores TIMETZ literal. ``` select datediff(hours, timetz '20:00:00 PST', timetz '00:58:00 EST') as numhours; numhours ---------- 1 ``` # Função DATE\$1PART DATE\$1PART extrai os valores de parte da data de uma expressão. DATE\$1PART é sinônimo da função PGDATE\$1PART. ## Sintaxe ``` DATE_PART(datepart, {date|timestamp}) ``` ## Argumentos *datepart* O literal ou a string de um identificador da parte específica do valor de data (por exemplo, ano, mês ou dia) sobre a qual a função atua. Para obter mais informações, consulte [Partes da data para funções de data ou de timestamp](r_Dateparts_for_datetime_functions.md). \$1*date*\$1*timestamp*\$1 Uma coluna de data ou timestamp ou uma expressão que se converta implicitamente em uma data ou timestamp. A coluna ou expressão em *date* ou *timestamp* deve conter a parte da data especificada em *datepart*. ## Tipo de retorno DOUBLE ## Exemplos O nome padrão da coluna para a função DATE\$1PART é `pgdate_part`. Para obter mais informações sobre os dados usados em alguns desses exemplos, consulte [Banco de dados de exemplo](c_sampledb.md). O exemplo a seguir encontra o minuto de um literal do carimbo de data/hora. ``` SELECT DATE_PART(minute, timestamp '20230104 04:05:06.789'); pgdate_part ----------- 5 ``` O exemplo a seguir encontra o número da semana de um literal do carimbo de data/hora. O cálculo do número da semana segue o padrão ISO 8601. Para obter mais informações, consulte [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) na Wikipédia. ``` SELECT DATE_PART(week, timestamp '20220502 04:05:06.789'); pgdate_part ----------- 18 ``` O exemplo a seguir encontra o dia do mês de um literal do carimbo de data/hora. ``` SELECT DATE_PART(day, timestamp '20220502 04:05:06.789'); pgdate_part ----------- 2 ``` O exemplo a seguir encontra o dia da semana de um literal do carimbo de data/hora. O cálculo do número do dia da semana é um inteiro de 0 a 6, começando no domingo. ``` SELECT DATE_PART(dayofweek, timestamp '20220502 04:05:06.789'); pgdate_part ----------- 1 ``` O exemplo a seguir encontra o século de um literal do carimbo de data/hora. O cálculo do número do século segue o padrão ISO 8601. Para obter mais informações, consulte [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) na Wikipédia. ``` SELECT DATE_PART(century, timestamp '20220502 04:05:06.789'); pgdate_part ----------- 21 ``` O exemplo a seguir encontra o milênio de um literal de timestamp. O cálculo do milênio segue o padrão ISO 8601. Para obter mais informações, consulte [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) na Wikipédia. ``` SELECT DATE_PART(millennium, timestamp '20220502 04:05:06.789'); pgdate_part ----------- 3 ``` O exemplo a seguir encontra a quantidade de microssegundos de um literal de timestamp. O cálculo do número do microssegundos segue o padrão ISO 8601. Para obter mais informações, consulte [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) na Wikipédia. ``` SELECT DATE_PART(microsecond, timestamp '20220502 04:05:06.789'); pgdate_part ----------- 789000 ``` O exemplo a seguir encontra o mês de um literal da data. ``` SELECT DATE_PART(month, date '20220502'); pgdate_part ----------- 5 ``` O exemplo a seguir aplica a função DATE\$1PART à uma coluna em uma tabela. ``` SELECT date_part(w, listtime) AS weeks, listtime FROM listing WHERE listid=10 weeks | listtime ------+--------------------- 25 | 2008-06-17 09:44:54 (1 row) ``` Você pode nomear partes da data completamente ou abreviá-las; nesse caso, *w* representa semanas. A parte da data do dia da semana retorna um número inteiro de 0 a 6, começando com domingo. Use DATE\$1PART com dow (DAYOFWEEK) para visualizar eventos em um sábado. ``` SELECT date_part(dow, starttime) AS dow, starttime FROM event WHERE date_part(dow, starttime)=6 ORDER BY 2,1; dow | starttime -----+--------------------- 6 | 2008-01-05 14:00:00 6 | 2008-01-05 14:00:00 6 | 2008-01-05 14:00:00 6 | 2008-01-05 14:00:00 ... (1147 rows) ``` # Função DATE\$1PART\$1YEAR A função DATE\$1PART\$1YEAR Extrai o ano a partir de uma data. ## Sintaxe ``` DATE_PART_YEAR(date) ``` ## Argumento *date* Uma coluna de tipo de dados `DATE` ou uma expressão que é avaliada implicitamente como um tipo `DATE`. ## Tipo de retorno INTEGER ## Exemplos O exemplo a seguir encontra o ano de um literal da data. ``` SELECT DATE_PART_YEAR(date '20220502 04:05:06.789'); date_part_year --------------- 2022 ``` O exemplo a seguir extrai o ano a partir da coluna CALDATE. Os valores na coluna CALDATE são datas. Para obter mais informações sobre os dados usados nesse exemplo, consulte [Banco de dados de exemplo](c_sampledb.md). ``` select caldate, date_part_year(caldate) from date order by dateid limit 10; caldate | date_part_year -----------+---------------- 2008-01-01 | 2008 2008-01-02 | 2008 2008-01-03 | 2008 2008-01-04 | 2008 2008-01-05 | 2008 2008-01-06 | 2008 2008-01-07 | 2008 2008-01-08 | 2008 2008-01-09 | 2008 2008-01-10 | 2008 (10 rows) ``` # Função DATE\$1TRUNC A função DATE\$1TRUNC trunca uma expressão de timestamp ou literal com base na parte da data especificada, tal como hora, dia ou mês. ## Sintaxe ``` DATE_TRUNC('datepart', timestamp) ``` ## Argumentos *datepart* A parte da data para qual truncar o valor de timestamp. A entrada *timestamp* é truncada para que a entrada *datepart* seja precisa. Por exemplo, `month` trunca para o primeiro dia do mês. Os formatos válidos são: + microssegundo, microssegundos + milissegundo, milissegundos + segundo, segundos + minuto, minutos + hora, horas + dia, dias + semana, semanas + mês, meses + trimestre, trimestres + ano, anos + década, décadas + século, séculos + milênio, milênios Para obter mais informações sobre a abreviação de alguns formatos, consulte [Partes da data para funções de data ou de timestamp](r_Dateparts_for_datetime_functions.md) *timestamp* Uma coluna de timestamp ou uma expressão que converta implicitamente para um timestamp. ## Tipo de retorno TIMESTAMP ## Exemplos Truncar o carimbo de data/hora de entrada para o segundo. ``` SELECT DATE_TRUNC('second', TIMESTAMP '20200430 04:05:06.789'); date_trunc 2020-04-30 04:05:06 ``` Truncar timestamp para minuto. ``` SELECT DATE_TRUNC('minute', TIMESTAMP '20200430 04:05:06.789'); date_trunc 2020-04-30 04:05:00 ``` Truncar timestamp para hora. ``` SELECT DATE_TRUNC('hour', TIMESTAMP '20200430 04:05:06.789'); date_trunc 2020-04-30 04:00:00 ``` Truncar timestamp para dia. ``` SELECT DATE_TRUNC('day', TIMESTAMP '20200430 04:05:06.789'); date_trunc 2020-04-30 00:00:00 ``` Truncar timestamp para o primeiro dia de um mês. ``` SELECT DATE_TRUNC('month', TIMESTAMP '20200430 04:05:06.789'); date_trunc 2020-04-01 00:00:00 ``` Truncar timestamp para o primeiro dia de um trimestre. ``` SELECT DATE_TRUNC('quarter', TIMESTAMP '20200430 04:05:06.789'); date_trunc 2020-04-01 00:00:00 ``` Truncar timestamp para o primeiro dia de um ano. ``` SELECT DATE_TRUNC('year', TIMESTAMP '20200430 04:05:06.789'); date_trunc 2020-01-01 00:00:00 ``` Truncar timestamp para o primeiro dia de um século. ``` SELECT DATE_TRUNC('millennium', TIMESTAMP '20200430 04:05:06.789'); date_trunc 2001-01-01 00:00:00 ``` Trunque o carimbo de data/hora de entrada para o a segunda-feira de uma semana. ``` select date_trunc('week', TIMESTAMP '20220430 04:05:06.789'); date_trunc 2022-04-25 00:00:00 ``` No exemplo a seguir, a função DATE\$1TRUNC usa a parte da data “week” para retornar a data para a segunda-feira de cada semana. ``` select date_trunc('week', saletime), sum(pricepaid) from sales where saletime like '2008-09%' group by date_trunc('week', saletime) order by 1; date_trunc | sum ------------+------------- 2008-09-01 | 2474899 2008-09-08 | 2412354 2008-09-15 | 2364707 2008-09-22 | 2359351 2008-09-29 | 705249 ``` # Função EXTRACT A função EXTRACT retorna a parte da data ou hora de um valor de TIMESTAMP, TIMESTAMPTZ, TIME, TIMETZ, INTERVAL YEAR TO MONTH ou INTERVAL DAY TO SECOND. Os exemplos incluem um dia, mês, ano, hora, minuto, segundo, milissegundo ou microssegundo de um timestamp. ## Sintaxe ``` EXTRACT(datepart FROM source) ``` ## Argumentos *datepart* O subcampo de uma data ou hora que será extraído, como dia, mês, ano, hora, minuto, segundo, milissegundo ou microssegundo. Para os possíveis valores, consulte [Partes da data para funções de data ou de timestamp](r_Dateparts_for_datetime_functions.md). *Fonte de* Uma coluna ou expressão que é avaliada como um tipo de dado TIMESTAMP, TIMESTAMPTZ, TIME, TIMETZ, INTERVAL YEAR TO MONTH ou INTERVAL DAY TO SECOND. ## Tipo de retorno INTEGER se o valor de *source* for avaliado como TIMESTAMP, TIME, TIMETZ, INTERVAL YEAR TO MONTH ou INTERVAL DAY TO SECOND. DOUBLE PRECISION se o valor de *source* for avaliado como TIMESTAMPTZ. ## Exemplos com TIMESTAMP O exemplo a seguir determina os números da semana para vendas em que o preço pago foi de \$110.000 ou mais. Este exemplo usa os dados de TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md). ``` select salesid, extract(week from saletime) as weeknum from sales where pricepaid > 9999 order by 2; salesid | weeknum --------+--------- 159073 | 6 160318 | 8 161723 | 26 ``` O exemplo a seguir retorna o valor de minutos de um valor de timestamp literal. ``` select extract(minute from timestamp '2009-09-09 12:08:43'); date_part ----------- 8 ``` O exemplo a seguir retorna o número de milissegundos de um valor de timestamp literal. ``` select extract(ms from timestamp '2009-09-09 12:08:43.101'); date_part ----------- 101 ``` ## Exemplos com TIMESTAMPTZ O exemplo a seguir retorna o ano de um valor de timestamp literal. ``` select extract(year from timestamptz '1.12.1997 07:37:16.00 PST'); date_part ----------- 1997 ``` ## Exemplos com TIME O TIME\$1TEST da tabela a seguir tem uma coluna TIME\$1VAL (tipo TIME) com três valores inseridos. ``` select time_val from time_test; time_val --------------------- 20:00:00 00:00:00.5550 00:58:00 ``` O exemplo a seguir extrai os minutos de cada time\$1val. ``` select extract(minute from time_val) as minutes from time_test; minutes ----------- 0 0 58 ``` O exemplo a seguir extrai as horas de cada time\$1val. ``` select extract(hour from time_val) as hours from time_test; hours ----------- 20 0 0 ``` O exemplo a seguir extrai milissegundos de um valor literal. ``` select extract(ms from time '18:25:33.123456'); date_part ----------- 123 ``` ## Exemplos com TIMETZ O TIMETZ\$1TEST da tabela de exemplo a seguir tem uma coluna TIMETZ\$1VAL (tipo TIMETZ) com três valores inseridos. ``` select timetz_val from timetz_test; timetz_val ------------------ 04:00:00+00 00:00:00.5550+00 05:58:00+00 ``` O exemplo a seguir extrai as horas de cada timetz\$1val. ``` select extract(hour from timetz_val) as hours from time_test; hours ----------- 4 0 5 ``` O exemplo a seguir extrai milissegundos de um valor literal. Literais não são convertidos para UTC antes da extração ser processada. ``` select extract(ms from timetz '18:25:33.123456 EST'); date_part ----------- 123 ``` O exemplo a seguir retorna a diferença de horas de um fuso horário em relação ao UTC de um valor de timetz literal. ``` select extract(timezone_hour from timetz '1.12.1997 07:37:16.00 PDT'); date_part ----------- -7 ``` ## Exemplos com INTERVAL YEAR TO MONTH e INTERVAL DAY TO SECOND O exemplo a seguir extrai a parte do dia de `1` de INTERVAL DAY TO SECOND que define 36 horas, que é 1 dia e 12 horas. ``` select EXTRACT('days' from INTERVAL '36 hours' DAY TO SECOND) date_part ------------------ 1 ``` O exemplo a seguir extrai a parte do mês de `3` de YEAR TO MONTH que define 15 meses, ou seja, 1 ano e 3 meses. ``` select EXTRACT('month' from INTERVAL '15 months' YEAR TO MONTH) date_part ------------------ 3 ``` O exemplo a seguir extrai a parte do mês de `6` de 30 meses, que é 2 anos e 6 meses. ``` select EXTRACT('month' from INTERVAL '30' MONTH) date_part ------------------ 6 ``` O exemplo a seguir extrai a parte da hora de `2` de 50 horas, que é 2 dias 2 horas. ``` select EXTRACT('hours' from INTERVAL '50' HOUR) date_part ------------------ 2 ``` O exemplo a seguir extrai a parte dos minutos de `11` de 1 hora, 11 minutos e 11.123 segundos. ``` select EXTRACT('minute' from INTERVAL '70 minutes 70.123 seconds' MINUTE TO SECOND) date_part ------------------ 11 ``` O exemplo a seguir extrai a parte dos segundos de `1.11` de 1 dia, 1 hora, 1 minuto e 1.11 segundos. ``` select EXTRACT('seconds' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) date_part ------------------ 1.11 ``` O exemplo a seguir extrai o número total de horas em um INTERVAL. Cada parte é extraída e adicionada a um total. ``` select EXTRACT('days' from INTERVAL '50' HOUR) * 24 + EXTRACT('hours' from INTERVAL '50' HOUR) ?column? ------------------ 50 ``` O exemplo a seguir extrai o número total de horas em um INTERVAL. Cada parte é extraída e adicionada a um total. ``` select EXTRACT('days' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) * 86400 + EXTRACT('hours' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) * 3600 + EXTRACT('minutes' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) * 60 + EXTRACT('seconds' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) ?column? ------------------ 90061.11 ``` # Função GETDATE GETDATE retorna a atual data e hora no fuso horário da sessão atual (UTC por padrão). Retorna a data ou hora de início da instrução atual, mesmo quando está dentro de um bloco de transação. ## Sintaxe ``` GETDATE() ``` Os parênteses são necessários. ## Tipo de retorno TIMESTAMP ## Exemplos O exemplo a seguir usa a função GETDATE para retornar o timestamp completo para a data atual. ``` select getdate(); timestamp --------------------- 2008-12-04 16:10:43 ``` O exemplo a seguir usa a função GETDATE dentro da função TRUNC para retornar a data atual sem a hora. ``` select trunc(getdate()); trunc ------------ 2008-12-04 ``` # Função INTERVAL\$1CMP INTERVAL\$1CMP compara dois intervalos e retorna `1` se o primeiro intervalo for maior, `-1` se o segundo intervalo for maior e `0` se os intervalos forem iguais. Para obter mais informações, consulte [Exemplos de literais de intervalo sem sintaxe de qualificador](r_interval_literals.md). ## Sintaxe ``` INTERVAL_CMP(interval1, interval2) ``` ## Argumentos *interval1* Um valor de intervalo literal. *interval2* Um valor de intervalo literal. ## Tipo de retorno INTEGER ## Exemplos O exemplo a seguir compara o valor de `3 days` com `1 year`. ``` select interval_cmp('3 days','1 year'); interval_cmp -------------- -1 ``` Este exemplo compara o valor `7 days` com `1 week`. ``` select interval_cmp('7 days','1 week'); interval_cmp -------------- 0 ``` O exemplo a seguir compara o valor de `1 year` com `3 days`. ``` select interval_cmp('1 year','3 days'); interval_cmp -------------- 1 ``` # Função LAST\$1DAY LAST\$1DAY retorna a data do último dia do mês que contenha *date*. O tipo de retorno é sempre DATE, independente do tipo de dado do argumento *date*. Para obter mais informações sobre como recuperar partes específicas de uma data, consulte [Função DATE\$1TRUNC](r_DATE_TRUNC.md). ## Sintaxe ``` LAST_DAY( { date | timestamp } ) ``` ## Argumentos *date* \$1 *timestamp* Uma coluna de tipo de dados `DATE` ou `TIMESTAMP` ou uma expressão que é avaliada implicitamente como um tipo `DATE` ou `TIMESTAMP`. ## Tipo de retorno DATE ## Exemplos O exemplo a seguir retorna a data do último dia no mês atual. ``` select last_day(sysdate); last_day ------------ 2014-01-31 ``` O exemplo a seguir retorna o número de ingressos vendido em cada um dos últimos 7 dias do mês. Os valores da coluna SALETIME são carimbos de data/hora. ``` select datediff(day, saletime, last_day(saletime)) as "Days Remaining", sum(qtysold) from sales where datediff(day, saletime, last_day(saletime)) < 7 group by 1 order by 1; days remaining | sum ---------------+------- 0 | 10140 1 | 11187 2 | 11515 3 | 11217 4 | 11446 5 | 11708 6 | 10988 (7 rows) ``` # Função MONTHS\$1BETWEEN MONTHS\$1BETWEEN determina o número de meses entre duas datas. Se a primeira data for mais recente do que a segunda, o resultado será positivo; caso contrário, o resultado será negativo. Se um dos argumentos for nulo o resultado será NULL. ## Sintaxe ``` MONTHS_BETWEEN( date1, date2 ) ``` ## Argumentos *date1* Uma coluna de tipo de dados `DATE` ou uma expressão que é avaliada implicitamente como um tipo `DATE`. *date2* Uma coluna de tipo de dados `DATE` ou uma expressão que é avaliada implicitamente como um tipo `DATE`. ## Tipo de retorno FLOAT8 A porção inteira do número do resultado é baseada na diferença entre os valores de ano e de mês das datas. A parte fracionária do resultado é calculada a partir dos valores de dia e timestamp das datas e presume um mês de 31 dias. Se *date1* e *date2* contêm a mesma data em um mês (por exemplo, 1/15/14 e 2/15/14) ou o último dia do mês (por exemplo, 8/31/14 e 9/30/14), o resultado é um número inteiro baseado nos valores de ano e mês das datas, independente de correspondência na porção do timestamp, se houver. ## Exemplos O exemplo a seguir retorna os meses entre 18/1/1969 e 18/3/1969. ``` select months_between('1969-01-18', '1969-03-18') as months; months ---------- -2 ``` O exemplo a seguir retorna os meses entre 18/1/1969 e 18/1/1969. ``` select months_between('1969-01-18', '1969-01-18') as months; months ---------- 0 ``` O exemplo a seguir retorna os meses entre a primeira e a última exibição de um evento. ``` select eventname, min(starttime) as first_show, max(starttime) as last_show, months_between(max(starttime),min(starttime)) as month_diff from event group by eventname order by eventname limit 5; eventname first_show last_show month_diff --------------------------------------------------------------------------- .38 Special 2008-01-21 19:30:00.0 2008-12-25 15:00:00.0 11.12 3 Doors Down 2008-01-03 15:00:00.0 2008-12-01 19:30:00.0 10.94 70s Soul Jam 2008-01-16 19:30:00.0 2008-12-07 14:00:00.0 10.7 A Bronx Tale 2008-01-21 19:00:00.0 2008-12-15 15:00:00.0 10.8 A Catered Affair 2008-01-08 19:30:00.0 2008-12-19 19:00:00.0 11.35 ``` # Função NEXT\$1DAY NEXT\$1DAY retorna a data da primeira instância do dia especificado que é mais recente do que a data fornecida. Se o valor *dia* for o mesmo dia da semana da data fornecida, a próxima ocorrência desse dia será retornada. ## Sintaxe ``` NEXT_DAY( { date | timestamp }, day ) ``` ## Argumentos *date* \$1 *timestamp* Uma coluna de tipo de dados `DATE` ou `TIMESTAMP` ou uma expressão que é avaliada implicitamente como um tipo `DATE` ou `TIMESTAMP`. *dia* Uma string que contém o nome de qualquer dia. O uso de letras maiúsculas não importa. Os valores válidos são conforme se segue. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_NEXT_DAY.html) ## Tipo de retorno DATE ## Exemplos O seguinte exemplo retorna a data da primeira terça-feira após 8/20/2014. ``` select next_day('2014-08-20','Tuesday'); next_day ----------- 2014-08-26 ``` O exemplo a seguir retorna a data da primeira terça-feira após 1.º/1/2008 às 5:54:44. ``` select listtime, next_day(listtime, 'Tue') from listing limit 1; listtime | next_day --------------------+----------- 2008-01-01 05:54:44 | 2008-01-08 ``` O exemplo a seguir obtém as datas de marketing de destino para o terceiro trimestre. ``` select username, (firstname ||' '|| lastname) as name, eventname, caldate, next_day (caldate, 'Monday') as marketing_target from sales, date, users, event where sales.buyerid = users.userid and sales.eventid = event.eventid and event.dateid = date.dateid and date.qtr = 3 order by marketing_target, eventname, name; username | name | eventname | caldate | marketing_target ----------+-------------------+----------------------+--------------+------------------- MBO26QSG | Callum Atkinson | .38 Special | 2008-07-06 | 2008-07-07 WCR50YIU | Erasmus Alvarez | A Doll's House | 2008-07-03 | 2008-07-07 CKT70OIE | Hadassah Adkins | Ana Gabriel | 2008-07-06 | 2008-07-07 VVG07OUO | Nathan Abbott | Armando Manzanero | 2008-07-04 | 2008-07-07 GEW77SII | Scarlet Avila | August: Osage County | 2008-07-06 | 2008-07-07 ECR71CVS | Caryn Adkins | Ben Folds | 2008-07-03 | 2008-07-07 KUW82CYU | Kaden Aguilar | Bette Midler | 2008-07-01 | 2008-07-07 WZE78DJZ | Kay Avila | Bette Midler | 2008-07-01 | 2008-07-07 HXY04NVE | Dante Austin | Britney Spears | 2008-07-02 | 2008-07-07 URY81YWF | Wilma Anthony | Britney Spears | 2008-07-02 | 2008-07-07 ``` # Função SYSDATE SYSDATE retorna a atual data e hora no fuso horário da sessão atual (UTC por padrão). **nota** SYSDATE retorna a data e hora de início para a transação atual, não para o início da instrução atual. ## Sintaxe ``` SYSDATE ``` Essa função não requer um argumento. ## Tipo de retorno TIMESTAMP ## Exemplos O exemplo a seguir usa a função SYSDATE para retornar o timestamp completo para a data atual. ``` select sysdate; timestamp ---------------------------- 2008-12-04 16:10:43.976353 ``` O exemplo a seguir usa a função SYSDATE dentro da função TRUNC para retornar a data atual sem a hora. ``` select trunc(sysdate); trunc ------------ 2008-12-04 ``` A consulta a seguir retorna informações de vendas para datas que caem entre a data em que a consulta é emitida e a data de 120 dias antes. ``` select salesid, pricepaid, trunc(saletime) as saletime, trunc(sysdate) as now from sales where saletime between trunc(sysdate)-120 and trunc(sysdate) order by saletime asc; salesid | pricepaid | saletime | now ---------+-----------+------------+------------ 91535 | 670.00 | 2008-08-07 | 2008-12-05 91635 | 365.00 | 2008-08-07 | 2008-12-05 91901 | 1002.00 | 2008-08-07 | 2008-12-05 ... ``` # Função TIMEOFDAY TIMEOFDAY é um alias especial usado para retornar o dia da semana, data e hora como um valor de string. Retorna a string de hora do dia para a instrução atual, mesmo quando está dentro de um bloco de transação. ## Sintaxe ``` TIMEOFDAY() ``` ## Tipo de retorno VARCHAR ## Exemplos O exemplo a seguir retorna a data e hora atuais usando a função TIMEOFDAY. ``` select timeofday(); timeofday ------------ Thu Sep 19 22:53:50.333525 2013 UTC ``` # Função TIMESTAMP\$1CMP Compara o valor de dois timestamps e retorna um número inteiro. Se os carimbos de data/hora forem idênticos, a função retornará `0`. Se o primeiro carimbo de data/hora for maior, a função retornará `1`. Se o segundo carimbo de data/hora for maior, a função retornará `-1`. ## Sintaxe ``` TIMESTAMP_CMP(timestamp1, timestamp2) ``` ## Argumentos *timestamp1* Uma coluna de tipo de dados `TIMESTAMP` ou uma expressão que é avaliada implicitamente como um tipo `TIMESTAMP`. *timestamp2* Uma coluna de tipo de dados `TIMESTAMP` ou uma expressão que é avaliada implicitamente como um tipo `TIMESTAMP`. ## Tipo de retorno INTEGER ## Exemplos O exemplo a seguir compara os carimbos de data/hora e mostra os resultados da comparação. ``` SELECT TIMESTAMP_CMP('2008-01-24 06:43:29', '2008-01-24 06:43:29'), TIMESTAMP_CMP('2008-01-24 06:43:29', '2008-02-18 02:36:48'), TIMESTAMP_CMP('2008-02-18 02:36:48', '2008-01-24 06:43:29'); timestamp_cmp | timestamp_cmp | timestamp_cmp ---------------+---------------+--------------- 0 | -1 | 1 ``` O seguinte exemplo compara o LISTTIME e SALETIME de uma oferta. Observe que o valor referente a TIMESTAMP\$1CMP é de `-1` para todas as listagens, pois o carimbo de data/hora da venda é posterior ao carimbo de data/hora das listagens. ``` select listing.listid, listing.listtime, sales.saletime, timestamp_cmp(listing.listtime, sales.saletime) from listing, sales where listing.listid=sales.listid order by 1, 2, 3, 4 limit 10; listid | listtime | saletime | timestamp_cmp --------+---------------------+---------------------+--------------- 1 | 2008-01-24 06:43:29 | 2008-02-18 02:36:48 | -1 4 | 2008-05-24 01:18:37 | 2008-06-06 05:00:16 | -1 5 | 2008-05-17 02:29:11 | 2008-06-06 08:26:17 | -1 5 | 2008-05-17 02:29:11 | 2008-06-09 08:38:52 | -1 6 | 2008-08-15 02:08:13 | 2008-08-31 09:17:02 | -1 10 | 2008-06-17 09:44:54 | 2008-06-26 12:56:06 | -1 10 | 2008-06-17 09:44:54 | 2008-07-10 02:12:36 | -1 10 | 2008-06-17 09:44:54 | 2008-07-16 11:59:24 | -1 10 | 2008-06-17 09:44:54 | 2008-07-22 02:23:17 | -1 12 | 2008-07-25 01:45:49 | 2008-08-04 03:06:36 | -1 (10 rows) ``` Este exemplo mostra que TIMESTAMP\$1CMP retorna um 0 para timestamps idênticos: ``` select listid, timestamp_cmp(listtime, listtime) from listing order by 1 , 2 limit 10; listid | timestamp_cmp --------+--------------- 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 10 | 0 (10 rows) ``` # Função TIMESTAMP\$1CMP\$1DATE TIMESTAMP\$1CMP\$1DATE compara o valor de um timestamp e uma data. Se os valores de carimbo de data/hora e data forem idênticos, a função retornará `0`. Se o carimbo de data/hora for maior cronologicamente, a função retornará `1`. Se a data for maior, a função retornará `-1`. ## Sintaxe ``` TIMESTAMP_CMP_DATE(timestamp, date) ``` ## Argumentos *timestamp* Uma coluna de tipo de dados `TIMESTAMP` ou uma expressão que é avaliada implicitamente como um tipo `TIMESTAMP`. *date* Uma coluna de tipo de dados `DATE` ou uma expressão que é avaliada implicitamente como um tipo `DATE`. ## Tipo de retorno INTEGER ## Exemplos O seguinte exemplo compara LISTTIME à data `2008-06-18`. Ofertas feitas após esta data retornam `1`; ofertas feitas antes desta data retornam `-1`. Os valores LISTTIME são carimbos de data/hora. ``` select listid, listtime, timestamp_cmp_date(listtime, '2008-06-18') from listing order by 1, 2, 3 limit 10; listid | listtime | timestamp_cmp_date --------+---------------------+-------------------- 1 | 2008-01-24 06:43:29 | -1 2 | 2008-03-05 12:25:29 | -1 3 | 2008-11-01 07:35:33 | 1 4 | 2008-05-24 01:18:37 | -1 5 | 2008-05-17 02:29:11 | -1 6 | 2008-08-15 02:08:13 | 1 7 | 2008-11-15 09:38:15 | 1 8 | 2008-11-09 05:07:30 | 1 9 | 2008-09-09 08:03:36 | 1 10 | 2008-06-17 09:44:54 | -1 (10 rows) ``` # Função TIMESTAMP\$1CMP\$1TIMESTAMPTZ TIMESTAMP\$1CMP\$1TIMESTAMPTZ compara o valor de uma expressão de timestamp à uma expressão de timestamp com fuso horário. Se os valores do carimbo de data/hora e do carimbo de data/hora com fuso horário forem idênticos, a função retornará `0`. Se o carimbo de data/hora for maior cronologicamente, a função retornará `1`. Se o carimbo de data/hora com fuso horário for maior, a função retornará `–1`. ## Sintaxe ``` TIMESTAMP_CMP_TIMESTAMPTZ(timestamp, timestamptz) ``` ## Argumentos *timestamp* Uma coluna de tipo de dados `TIMESTAMP` ou uma expressão que é avaliada implicitamente como um tipo `TIMESTAMP`. *timestamptz* Uma coluna de tipo de dados `TIMESTAMPTZ` ou uma expressão que é avaliada implicitamente como um tipo `TIMESTAMPTZ`. ## Tipo de retorno INTEGER ## Exemplos O exemplo a seguir compara os carimbos de data/hora a carimbos de data/hora com fusos horários e mostra os resultados da comparação. ``` SELECT TIMESTAMP_CMP_TIMESTAMPTZ('2008-01-24 06:43:29', '2008-01-24 06:43:29+00'), TIMESTAMP_CMP_TIMESTAMPTZ('2008-01-24 06:43:29', '2008-02-18 02:36:48+00'), TIMESTAMP_CMP_TIMESTAMPTZ('2008-02-18 02:36:48', '2008-01-24 06:43:29+00'); timestamp_cmp_timestamptz | timestamp_cmp_timestamptz | timestamp_cmp_timestamptz ---------------------------+---------------------------+-------------------------- 0 | -1 | 1 ``` # Função TIMESTAMPTZ\$1CMP TIMESTAMPTZ\$1CMP compara o valor de dois timestamps com valores de fuso horário e retorna um número inteiro. Se os carimbos de data/hora forem idênticos, a função retornará `0`. Se o primeiro carimbo de data/hora for maior cronologicamente, a função retornará `1`. Se o segundo carimbo de data/hora for maior, a função retornará `–1`. ## Sintaxe ``` TIMESTAMPTZ_CMP(timestamptz1, timestamptz2) ``` ## Argumentos *timestamptz1* Uma coluna de tipo de dados `TIMESTAMPTZ` ou uma expressão que é avaliada implicitamente como um tipo `TIMESTAMPTZ`. *timestamptz2* Uma coluna de tipo de dados `TIMESTAMPTZ` ou uma expressão que é avaliada implicitamente como um tipo `TIMESTAMPTZ`. ## Tipo de retorno INTEGER ## Exemplos O exemplo a seguir compara os carimbos de data/hora com fusos horários e mostra os resultados da comparação. ``` SELECT TIMESTAMPTZ_CMP('2008-01-24 06:43:29+00', '2008-01-24 06:43:29+00'), TIMESTAMPTZ_CMP('2008-01-24 06:43:29+00', '2008-02-18 02:36:48+00'), TIMESTAMPTZ_CMP('2008-02-18 02:36:48+00', '2008-01-24 06:43:29+00'); timestamptz_cmp | timestamptz_cmp | timestamptz_cmp -----------------+-----------------+---------------- 0 | -1 | 1 ``` # Função TIMESTAMPTZ\$1CMP\$1DATE TIMESTAMPTZ\$1CMP\$1DATE compara o valor de um timestamp e uma data. Se os valores de carimbo de data/hora e data forem idênticos, a função retornará `0`. Se o carimbo de data/hora for maior cronologicamente, a função retornará `1`. Se a data for maior, a função retornará `–1`. ## Sintaxe ``` TIMESTAMPTZ_CMP_DATE(timestamptz, date) ``` ## Argumentos *timestamptz* Uma coluna de tipo de dados `TIMESTAMPTZ` ou uma expressão que é avaliada implicitamente como um tipo `TIMESTAMPTZ`. *date* Uma coluna de tipo de dados `DATE` ou uma expressão que é avaliada implicitamente como um tipo `DATE`. ## Tipo de retorno INTEGER ## Exemplos O exemplo a seguir compara LISTTIME como um carimbo de data/hora com fuso horário e a data `2008-06-18`. Ofertas feitas após esta data retornam `1`; ofertas feitas antes desta data retornam `-1`. ``` select listid, CAST(listtime as timestamptz) as tstz, timestamp_cmp_date(tstz, '2008-06-18') from listing order by 1, 2, 3 limit 10; listid | tstz | timestamptz_cmp_date --------+------------------------+---------------------- 1 | 2008-01-24 06:43:29+00 | -1 2 | 2008-03-05 12:25:29+00 | -1 3 | 2008-11-01 07:35:33+00 | 1 4 | 2008-05-24 01:18:37+00 | -1 5 | 2008-05-17 02:29:11+00 | -1 6 | 2008-08-15 02:08:13+00 | 1 7 | 2008-11-15 09:38:15+00 | 1 8 | 2008-11-09 05:07:30+00 | 1 9 | 2008-09-09 08:03:36+00 | 1 10 | 2008-06-17 09:44:54+00 | -1 (10 rows) ``` # Função TIMESTAMPTZ\$1CMP\$1TIMESTAMP TIMESTAMPTZ\$1CMP\$1TIMESTAMP compara o valor de uma expressão de timestamp com fuso horário à uma expressão de timestamp. Se os valores do carimbo de data/hora com fuso horário e do carimbo de data/hora forem idênticos, a função retornará `0`. Se o carimbo de data/hora com fuso horário for maior cronologicamente, a função retornará `1`. Se o carimbo de data/hora for maior, a função retornará `–1`. ## Sintaxe ``` TIMESTAMPTZ_CMP_TIMESTAMP(timestamptz, timestamp) ``` ## Argumentos *timestamptz* Uma coluna de tipo de dados `TIMESTAMPTZ` ou uma expressão que é avaliada implicitamente como um tipo `TIMESTAMPTZ`. *timestamp* Uma coluna de tipo de dados `TIMESTAMP` ou uma expressão que é avaliada implicitamente como um tipo `TIMESTAMP`. ## Tipo de retorno INTEGER ## Exemplos O exemplo a seguir compara os carimbos de data/hora com fusos horários a carimbos de data/hora e mostra os resultados da comparação. ``` SELECT TIMESTAMPTZ_CMP_TIMESTAMP('2008-01-24 06:43:29+00', '2008-01-24 06:43:29'), TIMESTAMPTZ_CMP_TIMESTAMP('2008-01-24 06:43:29+00', '2008-02-18 02:36:48'), TIMESTAMPTZ_CMP_TIMESTAMP('2008-02-18 02:36:48+00', '2008-01-24 06:43:29'); timestamptz_cmp_timestamp | timestamptz_cmp_timestamp | timestamptz_cmp_timestamp ---------------------------+---------------------------+--------------------------- 0 | -1 | 1 ``` # Função TIMEZONE TIMEZONE retorna um timestamp para o valor de fuso horário e de timestamp especificados. Para obter informações e exemplos sobre como definir o fuso horário, consulte [timezone](r_timezone_config.md). Para obter informações e exemplos sobre como converter o fuso horário, consulte [CONVERT\$1TIMEZONE](CONVERT_TIMEZONE.md). ## Sintaxe ``` TIMEZONE('timezone', { timestamp | timestamptz }) ``` ## Argumentos *timezone* O fuso horário para o valor de retorno. O fuso horário pode ser especificado como um nome de fuso horário (como **'Africa/Kampala'** ou **'Singapore'**) ou como uma abreviação de fuso horário (como **'UTC'** ou **'PDT'**). Para visualizar uma lista de nomes de fusos horários compatíveis, execute o comando a seguir. ``` select pg_timezone_names(); ``` Para visualizar uma lista de abreviações de fusos horários compatíveis, execute o comando a seguir. ``` select pg_timezone_abbrevs(); ``` Observe que o Amazon Redshift usa o [banco de dados de fuso horário IANA](https://www.iana.org/time-zones) como fonte autorizada de especificação de fuso horário. Para ter mais informações e exemplos, consulte [Observações quanto ao uso de fuso horário](CONVERT_TIMEZONE.md#CONVERT_TIMEZONE-usage-notes). *timestamp* \$1 *timestamptz* Uma expressão que resulta em um tipo TIMESTAMP ou TIMESTAMPTZ ou um valor que pode implicitamente ser convertido em um carimbo de data/hora com fuso horário. ## Tipo de retorno TIMESTAMPTZ quando usado com uma expressão TIMESTAMP. TIMESTAMP quando usado com uma expressão TIMESTAMPTZ. ## Exemplos O seguinte retorna um carimbo de data/hora para o fuso horário UTC usando o carimbo de data/hora `2008-06-17 09:44:54` do fuso horário PST: ``` SELECT TIMEZONE('PST', '2008-06-17 09:44:54'); timezone ----------------------- 2008-06-17 17:44:54+00 ``` O seguinte retorna um carimbo de data/hora para o fuso horário PST usando o carimbo de data/hora com fuso horário UTC `2008-06-17 09:44:54+00`: ``` SELECT TIMEZONE('PST', timestamptz('2008-06-17 09:44:54+00')); timezone ----------------------- 2008-06-17 01:44:54 ``` # Função TO\$1TIMESTAMP TO\$1TIMESTAMP converte uma string de TIMESTAMP em TIMESTAMPTZ. Para obter uma lista de funções adicionais de data e hora para o Amazon Redshift, consulte [Perfis de data e hora](Date_functions_header.md). ## Sintaxe ``` to_timestamp(timestamp, format) ``` ``` to_timestamp (timestamp, format, is_strict) ``` ## Argumentos *timestamp* Uma string que representa um valor de timestamp no formato especificado por *format*. Se esse argumento for deixado vazio, o valor padrão de timestamp será `0001-01-01 00:00:00`. *formato* Um literal de string que define o formato do valor de *timestamp*. Formatos que incluem um fuso horário (**TZ**, **tz** ou **OF**) não têm suporte como entrada. Para os formatos de timestamp válidos, consulte [Strings de formato datetime](r_FORMAT_strings.md). *is\$1strict* Um valor booleano opcional que especifica se um erro será retornado se um valor de timestamp de entrada estiver fora do intervalo. Quando *is\$1strict* for definido como TRUE, um erro será retornado se houver um valor fora do intervalo. Quando *is\$1strict* estiver definido como FALSE, que é o padrão, então os valores de estouro são aceitos. ## Tipo de retorno TIMESTAMPTZ ## Exemplos O exemplo a seguir mostra como usar a função TO\$1TIMESTAMP para converter uma string TIMESTAMP em TIMESTAMPTZ. ``` select sysdate, to_timestamp(sysdate, 'YYYY-MM-DD HH24:MI:SS') as second; timestamp | second -------------------------- ---------------------- 2021-04-05 19:27:53.281812 | 2021-04-05 19:27:53+00 ``` É possível enviar parte de uma data com TO\$1TIMESTAMP. As partes restantes da data são definidas como valores padrão. A hora é incluída na saída: ``` SELECT TO_TIMESTAMP('2017','YYYY'); to_timestamp -------------------------- 2017-01-01 00:00:00+00 ``` A seguinte instrução SQL converte a string “2011-12-18 24:38:15” para um TIMESTAMPTZ. O resultado é um TIMESTAMPTZ que cai no dia seguinte porque o número de horas é superior a 24 horas: ``` SELECT TO_TIMESTAMP('2011-12-18 24:38:15', 'YYYY-MM-DD HH24:MI:SS'); to_timestamp ---------------------- 2011-12-19 00:38:15+00 ``` A seguinte instrução SQL converte a string “2011-12-18 24:38:15” para um TIMESTAMPTZ. O resultado é um erro porque o valor de hora no timestamp é superior a 24 horas: ``` SELECT TO_TIMESTAMP('2011-12-18 24:38:15', 'YYYY-MM-DD HH24:MI:SS', TRUE); ERROR: date/time field time value out of range: 24:38:15.0 ``` # Função TRUNC Trunca um `TIMESTAMP` e retorna um `DATE`. Essa função também pode truncar um número. Para obter mais informações, consulte [Função TRUNC](r_TRUNC.md). ## Sintaxe ``` TRUNC(timestamp) ``` ## Argumentos *timestamp* Uma coluna de tipo de dados `TIMESTAMP` ou uma expressão que é avaliada implicitamente como um tipo `TIMESTAMP`. Para retornar um valor de carimbo de data/hora com `00:00:00` como a hora, converta o resultado da função em um `TIMESTAMP`. ## Tipo de retorno DATE ## Exemplos O exemplo a seguir retorna a parte da data do resultado da função SYSDATE (que retorna um timestamp). ``` SELECT SYSDATE; +----------------------------+ | timestamp | +----------------------------+ | 2011-07-21 10:32:38.248109 | +----------------------------+ SELECT TRUNC(SYSDATE); +------------+ | trunc | +------------+ | 2011-07-21 | +------------+ ``` O exemplo a seguir aplica a função TRUNC a uma coluna `TIMESTAMP`. O tipo de retorno é uma data. ``` SELECT TRUNC(starttime) FROM event ORDER BY eventid LIMIT 1; +------------+ | trunc | +------------+ | 2008-01-25 | +------------+ ``` O exemplo a seguir retorna um valor de carimbo de data/hora com `00:00:00` como a hora ao converter o resultado da função TRUNC em um `TIMESTAMP`. ``` SELECT CAST((TRUNC(SYSDATE)) AS TIMESTAMP); +---------------------+ | trunc | +---------------------+ | 2011-07-21 00:00:00 | +---------------------+ ``` # Partes da data para funções de data ou de timestamp A tabela a seguir identifica os nomes e abreviações da parte da data e da hora que são aceitos como argumentos para as seguintes funções: + DATEADD + DATEDIFF + DATE\$1PART + EXTRACT [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_Dateparts_for_datetime_functions.html) ## Variações nos resultados com segundos, milissegundos e microssegundos Pequenas diferenças nos resultados de consultas ocorrem quando diferentes funções de data especificam segundos, milissegundos ou microssegundos como partes da data: + A função EXTRACT retorna números inteiros somente para a parte da data especificada, ignorando partes de data de níveis superiores e inferiores. Se a parte da data especificada é segundos, os milissegundos e os microssegundos não são incluídos no resultados. Se a parte da data especificada é milissegundos, segundos e microssegundos não são incluídos. Se a parte da data especificada é microssegundos, segundos e milissegundos não são incluídos. + A função DATE\$1PART retorna a parte completa de segundos do timestamp, independente da parte de data especificada, retornando um valor decimal ou um número inteiro conforme necessário. Por exemplo, compare os resultados das consultas a seguir: ``` create table seconds(micro timestamp); insert into seconds values('2009-09-21 11:10:03.189717'); select extract(sec from micro) from seconds; date_part ----------- 3 select date_part(sec, micro) from seconds; pgdate_part ------------- 3.189717 ``` ## Observações de CENTURY, EPOCH, DECADE e MIL CENTURY ou CENTURIES O Amazon Redshift interpreta um CENTURY para começar com o ano *\$1\$1\$11* e terminar com o ano `###0`: ``` select extract (century from timestamp '2000-12-16 12:21:13'); date_part ----------- 20 select extract (century from timestamp '2001-12-16 12:21:13'); date_part ----------- 21 ``` EPOCH A implementação do Amazon Redshift de EPOCH é relativa a 1970-01-01 00:00:00.000000 independente do fuso horário onde o cluster reside. Você pode precisar deslocar os resultados pela diferença em horas dependendo do fuso horário onde o cluster está localizado. O exemplo a seguir faz o seguinte: 1. Cria uma tabela chamada EVENT\$1EXAMPLE com base na tabela EVENT. Este comando CREATE AS usa a função DATE\$1PART para criar uma coluna de data (chamada PGDATE\$1PART por padrão) para armazenar o valor de epoch para cada evento. 1. Seleciona a coluna e o tipo de dados de EVENT\$1EXAMPLE a partir de PG\$1TABLE\$1DEF. 1. Seleciona EVENTNAME, STARTTIME e PGDATE\$1PART a partir da tabela EVENT\$1EXAMPLE para visualizar os diferentes formatos de data e hora. 1. Seleciona EVENTNAME e STARTTIME a partir da tabela EVENT EXAMPLE na forma atual. Converte valores de epoch em PGDATE\$1PART usando um intervalo de 1 segundo para um timestamp sem fuso horário e retorna os resultados em uma coluna chamada CONVERTED\$1TIMESTAMP. ``` create table event_example as select eventname, starttime, date_part(epoch, starttime) from event; select "column", type from pg_table_def where tablename='event_example'; column | type ---------------+----------------------------- eventname | character varying(200) starttime | timestamp without time zone pgdate_part | double precision (3 rows) ``` ``` select eventname, starttime, pgdate_part from event_example; eventname | starttime | pgdate_part ----------------------+---------------------+------------- Mamma Mia! | 2008-01-01 20:00:00 | 1199217600 Spring Awakening | 2008-01-01 15:00:00 | 1199199600 Nas | 2008-01-01 14:30:00 | 1199197800 Hannah Montana | 2008-01-01 19:30:00 | 1199215800 K.D. Lang | 2008-01-01 15:00:00 | 1199199600 Spamalot | 2008-01-02 20:00:00 | 1199304000 Macbeth | 2008-01-02 15:00:00 | 1199286000 The Cherry Orchard | 2008-01-02 14:30:00 | 1199284200 Macbeth | 2008-01-02 19:30:00 | 1199302200 Demi Lovato | 2008-01-02 19:30:00 | 1199302200 select eventname, starttime, timestamp with time zone 'epoch' + pgdate_part * interval '1 second' AS converted_timestamp from event_example; eventname | starttime | converted_timestamp ----------------------+---------------------+--------------------- Mamma Mia! | 2008-01-01 20:00:00 | 2008-01-01 20:00:00 Spring Awakening | 2008-01-01 15:00:00 | 2008-01-01 15:00:00 Nas | 2008-01-01 14:30:00 | 2008-01-01 14:30:00 Hannah Montana | 2008-01-01 19:30:00 | 2008-01-01 19:30:00 K.D. Lang | 2008-01-01 15:00:00 | 2008-01-01 15:00:00 Spamalot | 2008-01-02 20:00:00 | 2008-01-02 20:00:00 Macbeth | 2008-01-02 15:00:00 | 2008-01-02 15:00:00 The Cherry Orchard | 2008-01-02 14:30:00 | 2008-01-02 14:30:00 Macbeth | 2008-01-02 19:30:00 | 2008-01-02 19:30:00 Demi Lovato | 2008-01-02 19:30:00 | 2008-01-02 19:30:00 ... ``` DECADE ou DECADES O Amazon Redshift interpreta DECADE or DECADES DATEPART com base no calendário comum. Por exemplo, como o calendário comum começa a partir do ano 1, a primeira década (década 1) é 0001-01-01 a 0009-12-31 e a segunda década (década 2) é 0010-01-01 a 0019-12-31. Por exemplo, a década 201 vai de 2000-01-01 a 2009-12-31: ``` select extract(decade from timestamp '1999-02-16 20:38:40'); date_part ----------- 200 select extract(decade from timestamp '2000-02-16 20:38:40'); date_part ----------- 201 select extract(decade from timestamp '2010-02-16 20:38:40'); date_part ----------- 202 ``` MIL ou MILS O Amazon Redshift interpreta que um MIL começa no primeiro dia do ano *\$1001* e termina no último dia do ano `#000`: ``` select extract (mil from timestamp '2000-12-16 12:21:13'); date_part ----------- 2 select extract (mil from timestamp '2001-12-16 12:21:13'); date_part ----------- 3 ```