Categorias:

Funções de conversão , Funções de data e hora

TO_DATE , DATE

Converte uma expressão de entrada em uma data:

  • Para uma expressão de cadeia de caracteres, o resultado da conversão da cadeia de caracteres em uma data.

  • Para uma expressão de carimbo de data/hora, a data do carimbo de data/hora.

  • Para uma expressão de variante:

    • Se a variante contém uma cadeia de caracteres, é realizada uma conversão da cadeia de caracteres.

    • Se a variante contiver uma data, o valor da data é preservado como está.

    • Se a variante contiver um valor nulo JSON, a saída será NULL.

  • Para a entrada NULL, a saída será NULL.

Para todos os outros valores, é gerado um erro de conversão.

Consulte também:

TRY_TO_DATE

Sintaxe

TO_DATE( <string_expr> [, <format> ] )
TO_DATE( <timestamp_expr> )
TO_DATE( '<integer>' )
TO_DATE( <variant_expr> )

DATE( <string_expr> [, <format> ] )
DATE( <timestamp_expr> )
DATE( '<integer>' )
DATE( <variant_expr> )
Copy

Argumentos

Obrigatório:

Uma das opções:

timestamp_expr

Uma expressão TIMESTAMP. A parte de DATE do TIMESTAMP é extraída.

string_expr

Cadeia de caracteres da qual extrair uma data, por exemplo ‘31-01-2019’.

'integer'

Uma expressão que avalia como uma cadeia de caracteres contendo um número inteiro, por exemplo ‘15000000’. Dependendo da magnitude da cadeia de caracteres, ela pode ser interpretada como segundos, milissegundos, microssegundos ou nanossegundos. Para obter mais detalhes, consulte as Notas de uso abaixo.

Nota

O uso de números inteiros cotados como entradas é obsoleto.

variant_expr

Uma expressão do tipo VARIANT. O VARIANT deve conter um DATE, ou uma cadeia de caracteres que contenha um INTEGER. (TO_DATE retorna um erro se tiver passado um VARIANT contendo um carimbo de data/hora).

O VARIANT deve conter um dos seguintes:

  • Uma cadeia de caracteres da qual se pode extrair uma data.

  • Uma data.

  • Uma cadeia de caracteres contendo um número inteiro de segundos ou milissegundos.

Embora TO_DATE aceite um valor TIMESTAMP, não aceita um TIMESTAMP dentro de um VARIANT.

Opcional:

format

Especificador do formato de data para string_expr ou AUTO, que especifica que o Snowflake deve detectar automaticamente o formato a ser utilizado. Para obter mais informações, consulte Formatos de data e hora em funções de conversão.

O valor padrão é o valor atual do parâmetro de sessão DATE_INPUT_FORMAT (geralmente AUTO).

Retornos

O tipo de dados do valor retornado é DATE.

Notas de uso

  • Se o formato do parâmetro de entrada for uma cadeia de caracteres que contenha um número inteiro:

    • Depois que a cadeia de caracteres é convertida em um inteiro, o inteiro é tratado como um número de segundos, milissegundos, microssegundos ou nanossegundos após o início da época Unix (1970-01-01 00:00:00.000000000 UTC).

      • Se o número inteiro for inferior a 31536000000 (o número de milissegundos em um ano), então o valor é tratado como um número de segundos.

      • Se o valor for maior ou igual a 31536000000 e menor que 31536000000000, então o valor é tratado como milissegundos.

      • Se o valor for maior ou igual a 31536000000000 e menor que 31536000000000000, então o valor é tratado como microssegundos.

      • Se o valor for maior ou igual a 31536000000000000, então o valor é tratado como nanossegundos.

      Nota

      Aviso de descontinuação: Versões futuras do Snowflake podem interpretar automaticamente valores inteiros de cadeia de caracteres como segundos, em vez de milissegundos, microssegundos ou nanossegundos. O Snowflake recomenda chamar TO_DATE, TO_TIME ou TO_TIMESTAMP com cadeias de caracteres que contenham inteiros somente quando esses inteiros devam ser interpretados como segundos.

    • Se mais de uma linha for avaliada (por exemplo, se a entrada for o nome da coluna de uma tabela que contém mais de uma linha), cada valor será examinado independentemente para determinar se o valor representa segundos, milissegundos, microssegundos ou nanossegundos.

Exemplos

Os exemplos seguintes mostram como utilizar a função TO_DATE().

SELECT TO_DATE('2013-05-17'), DATE('2013-05-17');
+-----------------------+--------------------+
| TO_DATE('2013-05-17') | DATE('2013-05-17') |
|-----------------------+--------------------|
| 2013-05-17            | 2013-05-17         |
+-----------------------+--------------------+
Copy
SELECT TO_DATE('2012.07.23', 'YYYY.MM.DD'), DATE('2012.07.23', 'YYYY.MM.DD');
+-------------------------------------+----------------------------------+
| TO_DATE('2012.07.23', 'YYYY.MM.DD') | DATE('2012.07.23', 'YYYY.MM.DD') |
|-------------------------------------+----------------------------------|
| 2012-07-23                          | 2012-07-23                       |
+-------------------------------------+----------------------------------+
Copy
SELECT TO_DATE('1999-01-02', 'AUTO'), DATE('1999-01-02', 'AUTO');
+-------------------------------+----------------------------+
| TO_DATE('1999-01-02', 'AUTO') | DATE('1999-01-02', 'AUTO') |
|-------------------------------+----------------------------|
| 1999-01-02                    | 1999-01-02                 |
+-------------------------------+----------------------------+
Copy
SELECT TO_DATE('02/14/2014', 'MM/DD/YYYY'), DATE('02/14/2014', 'MM/DD/YYYY');
+-------------------------------------+----------------------------------+
| TO_DATE('02/14/2014', 'MM/DD/YYYY') | DATE('02/14/2014', 'MM/DD/YYYY') |
|-------------------------------------+----------------------------------|
| 2014-02-14                          | 2014-02-14                       |
+-------------------------------------+----------------------------------+
Copy

Quando a entrada é uma cadeia de caracteres que contém um número inteiro, a magnitude desse número inteiro afeta se ele é interpretado como segundos, milissegundos etc. O exemplo a seguir mostra como a função escolhe as unidades a usar (segundos, milissegundos, microssegundos ou nanossegundos) com base na magnitude do valor:

Criar e carregar a tabela:

CREATE TABLE demo1 (
    description VARCHAR,
    value VARCHAR -- yes, string rather than bigint
    );

INSERT INTO demo1 (description, value) VALUES
   ('Seconds',      '31536000'),
   ('Milliseconds', '31536000000'),
   ('Microseconds', '31536000000000'),
   ('Nanoseconds',  '31536000000000000')
   ;
Copy

Passe as cadeias de caracteres para a função:

SELECT
       description,
       value,
       TO_TIMESTAMP(value),
       TO_DATE(value)
    FROM demo1
    ORDER BY value
    ;
+--------------+-------------------+-------------------------+----------------+
| DESCRIPTION  | VALUE             | TO_TIMESTAMP(VALUE)     | TO_DATE(VALUE) |
|--------------+-------------------+-------------------------+----------------|
| Seconds      | 31536000          | 1971-01-01 00:00:00.000 | 1971-01-01     |
| Milliseconds | 31536000000       | 1971-01-01 00:00:00.000 | 1971-01-01     |
| Microseconds | 31536000000000    | 1971-01-01 00:00:00.000 | 1971-01-01     |
| Nanoseconds  | 31536000000000000 | 1971-01-01 00:00:00.000 | 1971-01-01     |
+--------------+-------------------+-------------------------+----------------+
Copy