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 .

Operadores e funções

Com o Amazon Redshift, é possível realizar operações de analytics avançada em grandes conjuntos de dados que usam dados SUPER por meio de operadores e funções. Os operadores e funções para dados SUPER são constructos de SQL que permitem análise e manipulação complexas de dados semiestruturados armazenados em tabelas do Amazon Redshift.

As seções a seguir abordarão a sintaxe, os exemplos e as práticas recomendadas para usar operadores e funções em dados SUPER no Amazon Redshift e aproveitar todo o potencial de seus dados semiestruturados.

Operadores aritméticos

Os valores SUPER dão suporte a todos os operadores aritméticos básicos +, -, *,/,% usando a digitação dinâmica. O tipo resultante da operação permanece como SUPER. Para todos os operadores, exceto para o operador binário +, os operandos de entrada devem ser números. Caso contrário, o Amazon Redshift retorna nulo. A distinção entre valores decimais e de ponto flutuante é mantida quando o Amazon Redshift executa esses operadores e o tipo dinâmico não é alterado. No entanto, alterações de escala decimal quando você usa multiplicações e divisões. Os estouros aritméticos ainda causam erros de consulta, eles não são alterados para nulo. Operador binário + executa adição se as entradas são números ou concatenação se as entradas são string. Se um operando é uma string e o outro operando é um número, o resultado é nulo. Operadores de prefixo unário + e - retorna null se o valor SUPER não for um número, como mostrado no seguinte exemplo:

SELECT (c_orders[0]. o_orderkey + 0.5) * c_orders[0]. o_orderkey / 10 AS math FROM customer_orders_lineitem;
            math
----------------------------
 1757958232200.1500
(1 row)

A digitação dinâmica permite que os valores decimais em SUPER tenham escalas diferentes. O Amazon Redshift trata valores decimais como se fossem tipos estáticos diferentes e permite todas as operações matemáticas. O Amazon Redshift calcula a escala resultante dinamicamente com base nas escalas dos operandos. Se um dos operandos for um número de ponto flutuante, o Amazon Redshift promoverá o outro operando para um número de ponto flutuante e gerará o resultado como um número de ponto flutuante.

Funções aritméticas

O Amazon Redshift oferece suporte às seguintes funções aritméticas para colunas SUPER. Eles retornam null se a entrada não for um número:

O seguinte exemplo usa funções aritméticas para consultar dados:

SELECT x, FLOOR(x), CEIL(x), ROUND(x)
FROM (
    SELECT (c_orders[0]. o_orderkey + 0.5) * c_orders[0].o_orderkey / 10 AS x
    FROM customer_orders_lineitem
    );

         x          |     floor     |     ceil      |     round
--------------------+---------------+---------------+---------------
 1389636795898.0500  | 1389636795898  | 1389636795899  | 1389636795898

A função ABS mantém a escala da entrada decimal enquanto FLOOR, CEIL. O ROUND elimina a escala do decimal de entrada.

Funções de array

O Amazon Redshift dá suporte às seguintes funções utilitárias e de composição de matriz:

Você pode construir arrays SUPER a partir de valores nos tipos de dados do Amazon Redshift usando a função ARRAY, incluindo outros valores SUPER. O seguinte exemplo usa a função variádica ARRAY:

SELECT ARRAY(1, c.c_custkey, NULL, c.c_name, 'abc') FROM customer_orders_lineitem c; 
                               array
 -------------------------------------------------------
[1,8401,null,""Customer#000008401"",""abc""]
[1,9452,null,""Customer#000009452"",""abc""]
[1,9451,null,""Customer#000009451"",""abc""]
[1,8251,null,""Customer#000008251"",""abc""]
[1,5851,null,""Customer#000005851"",""abc""] 
(5 rows)

O seguinte exemplo usa concatenação de array com a função ARRAY_CONCAT:

SELECT ARRAY_CONCAT(JSON_PARSE('[10001,10002]'),JSON_PARSE('[10003,10004]'));

             array_concat
------------------------------------
 [10001,10002,10003,10004]
(1 row)

O seguinte exemplo usa manipulação de array com a função SUBARRAY que retorna um subconjunto do array de entrada.

SELECT SUBARRAY(ARRAY('a', 'b', 'c', 'd', 'e', 'f'), 2, 3);

   subarray
---------------
 ["c","d","e"]
(1 row))

O seguinte exemplo mescla vários níveis de arrays em um único array usando ARRAY_FLATTEN:

SELECT x, ARRAY_FLATTEN(x) FROM (SELECT ARRAY(1, ARRAY(2, ARRAY(3, ARRAY()))) AS x);

     x           | array_flatten
 ----------------+---------------
 [1,[2,[3,[]]]]  | [1,2,3]
(1 row)

As funções de array ARRAY_CONCAT e ARRAY_FLATTEN usam regras de digitação dinâmica. Eles retornam um nulo em vez de um erro se a entrada não for um array. A função GET_ARRAY_LENGTH retorna o comprimento de um array SUPER dado um objeto ou caminho de array.

SELECT c_name
FROM customer_orders_lineitem
WHERE GET_ARRAY_LENGTH(c_orders) = (
    SELECT MAX(GET_ARRAY_LENGTH(c_orders))
    FROM customer_orders_lineitem
    );

O exemplo a seguir divide uma string em um array de strings usando SPLIT_TO_ARRAY. A função usa um delimitador como um parâmetro opcional. Se nenhum delimitador estiver ausente, o padrão será uma vírgula.

SELECT SPLIT_TO_ARRAY('12|345|6789', '|');

   split_to_array
---------------------
 ["12","345","6789"]
(1 row)

Comportamento do agrupamento

Com SUPER, você pode definir o agrupamento de uma coluna com CREATE TABLE, acessar o agrupamento padrão definido com CREATE DATABASE e definir o agrupamento de uma expressão com a função COLLATE.

A configuração de agrupamento se aplica a todos os operadores de comparação e valores de string armazenados em SUPER, sejam eles valores de string, strings dentro de matrizes SUPER ou valores de um objeto SUPER. Para objetos SUPER, o comportamento do agrupamento se aplica somente aos valores e não aos atributos. Por exemplo, uma comparação de valores que têm o agrupamento sem distinção entre maiúsculas e minúsculas de {"attribute": "a"} = {"attribute": "A"} exibe true, enquanto {"attribute": "a"} = {"ATTRIBUTE": "a"} exibe false.

Funções de informação

As colunas de dados SUPER suportam funções de inspeção que retornam o tipo dinâmico e outras informações de tipo sobre o valor SUPER. A função escalar JSON_TYPEOF retorna um VARCHAR com valores booleanos, number, string, object, array ou null, dependendo do tipo dinâmico do valor SUPER. O Amazon Redshift oferece suporte às seguintes funções booleanas para colunas de dados SUPER:

Para obter mais informações sobre funções de informações do tipo SUPER, consulte Funções de informação de tipo SUPER.

Funções de string

Para usar funções de string com literais de string no tipo de dados SUPER, você deve converter o literal de string em tipo de string antes de aplicar as funções. As funções exibirão null se a entrada não for um literal de string.

Funções de string agora comportam até 16 milhões de bytes.

O exemplo a seguir usa SUBSTRING para extrair a versão prévia de uma string com 5 milhões de bytes de tamanho armazenada em um objeto SUPER JSON.

CREATE TABLE customer_data (
   customer_id INT,
   profile SUPER
);

INSERT INTO customer_data VALUES (
   1,
   JSON_PARSE('{"name": "John Doe", "description": "' || REPEAT('A', 5000000) || '"}')
);

SELECT 
   customer_id,
   profile.name::VARCHAR AS name,
   SUBSTRING(profile.description::VARCHAR, 1, 50) AS description_preview
FROM customer_data;

 customer_id | name     | description_preview
-------------+----------+----------------------------------------------------
         1 | John Doe | AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
   

O seguinte exemplo demonstra as funções LEFT, RIGHT e CONCAT em literais de string de uma matriz SUPER:

CREATE TABLE documents (
   doc_id INT,
   chapters SUPER
);

INSERT INTO documents VALUES (
   1,
   JSON_PARSE('["' || REPEAT('hello', 400000) || '", "' || REPEAT('world', 600000) || '"]')
);

SELECT 
   doc_id,
   LEFT(chapters[0]::VARCHAR, 20) AS chapter1_start,
   RIGHT(chapters[1]::VARCHAR, 20) AS chapter2_end,
   LEN(CONCAT(chapters[0]::VARCHAR, chapters[1]::VARCHAR)) AS concat_size
FROM documents;

 doc_id |    chapter1_start    |     chapter2_end     | concat_size 
--------+----------------------+----------------------+-------------
      1 | hellohellohellohello | worldworldworldworld |     5000000
   

O seguinte exemplo armazena uma string autônoma em SUPER:

CREATE TABLE text_storage (
   text_id INT,
   content SUPER
);

INSERT INTO text_storage VALUES 
   (1, REPEAT('A', 8000000)),
   (2, REPEAT('B', 16000000));

SELECT 
   text_id,
   LEN(content::VARCHAR) AS content_length
FROM text_storage;

 text_id | content_length
---------+----------------
      1 |        8000000
      2 |       16000000