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/). # 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 \$1, -, \$1,/,% 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 \$1, 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 \$1 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 \$1 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: + FLOOR. Para obter mais informações, consulte [Função FLOOR](r_FLOOR.md). + CEIL e CEILING Para obter mais informações, consulte [Função CEILING (ou CEIL)](r_CEILING_FLOOR.md). + ROUND. Para obter mais informações, consulte [Função ROUND](r_ROUND.md). + TRUNC. Para obter mais informações, consulte [Função TRUNC](r_TRUNC.md). + ABS. Para obter mais informações, consulte [Função ABS](r_ABS.md). 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: + ARRAY. Para obter mais informações, consulte [Função ARRAY](r_array.md). + ARRAY\$1CONCAT. Para obter mais informações, consulte [Função ARRAY\$1CONCAT](r_array_concat.md). + ARRAY\$1CONTAINS. Para obter mais informações, consulte [Função ARRAY\$1CONTAINS](array_contains.md). + ARRAY\$1DISTINCT. Para obter mais informações, consulte [Função ARRAY\$1DISTINCT](array_distinct.md). + ARRAY\$1EXCEPT. Para obter mais informações, consulte [Função ARRAY\$1EXCEPT](array_except.md). + ARRAY\$1FLATTEN. Para obter mais informações, consulte [Função ARRAY\$1FLATTEN](array_flatten.md). + ARRAY\$1INTERSECTION. Para obter mais informações, consulte [Função ARRAY\$1INTERSECTION](array_intersection.md). + ARRAY\$1POSITION. Para obter mais informações, consulte [Função ARRAY\$1POSITION](array_position.md). + ARRAY\$1POSITIONS. Para obter mais informações, consulte [Função ARRAY\$1POSITIONS](array_positions.md). + ARRAY\$1SORT. Para obter mais informações, consulte [Função ARRAY\$1SORT](array_sort.md). + ARRAY\$1UNION. Para obter mais informações, consulte [Função ARRAY\$1UNION](array_union.md). + ARRAYS\$1OVERLAP. Para obter mais informações, consulte [Função ARRAYS\$1OVERLAP](arrays_overlap.md). + GET\$1ARRAY\$1LENGTH. Para obter mais informações, consulte [Função GET\$1ARRAY\$1LENGTH](get_array_length.md). + SPLIT\$1TO\$1ARRAY. Para obter mais informações, consulte [Função SPLIT\$1TO\$1ARRAY](split_to_array.md). + SUBARRAY. Para obter mais informações, consulte [Função SUBARRAY](r_subarray.md). 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\$1CONCAT: ``` 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\$1FLATTEN: ``` 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\$1CONCAT e ARRAY\$1FLATTEN 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\$1ARRAY\$1LENGTH 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\$1TO\$1ARRAY. 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](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_TABLE_NEW.html), acessar o agrupamento padrão definido com [CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html) e definir o agrupamento de uma expressão com a [função COLLATE](https://docs.aws.amazon.com/redshift/latest/dg/r_COLLATE.html). 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\$1TYPEOF 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: + [Função IS\$1ARRAY](r_is_array.md) + [Função IS\$1BIGINT](r_is_bigint.md) + [Função IS\$1CHAR](r_is_char.md) + [Função IS\$1DECIMAL](r_is_decimal.md) + [Função IS\$1FLOAT](r_is_float.md) + [Função IS\$1INTEGER](r_is_integer.md) + [Função IS\$1OBJECT](r_is_object.md) + [Função IS\$1SCALAR](r_is_scalar.md) + [Função IS\$1SMALLINT](r_is_smallint.md) + [Função IS\$1VARCHAR](r_is_varchar.md) Para obter mais informações sobre funções de informações do tipo SUPER, consulte [Funções de informação de tipo SUPER](c_Type_Info_Functions.md). ## Funções de objetos Veja a seguir as funções de objeto do SQL compatíveis com o Amazon Redshift para criar e operar em objetos do tipo SUPER: + [Função GET\$1NUMBER\$1ATTRIBUTES](get_number_attributes.md) + [Função LOWER\$1ATTRIBUTE\$1NAMES](r_lower_attribute_names.md) + [Função OBJECT](r_object_function.md) + [Função OBJECT\$1TRANSFORM](r_object_transform_function.md) + [Função UPPER\$1ATTRIBUTE\$1NAMES](r_upper_attribute_names.md) Para ter mais informações sobre funções de objeto, consulte [Funções de objetos](Object_Functions.md). ## 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](String_functions_header.md) 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 ```