Operadores e funções
O Amazon Redshift fornece o seguinte suporte de função de operadores e funções SUPER.
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:
FLOOR. Para ter mais informações, consulte Função FLOOR.
CEIL e CEILING Para ter mais informações, consulte Função CEILING (ou CEIL).
ROUND. Para ter mais informações, consulte Função ROUND.
TRUNC. Para ter mais informações, consulte Função TRUNC.
ABS. Para ter mais informações, consulte Função ABS.
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 suporta a seguinte composição de array e array de funções de utilitário, array_concat, subarray, array_flatten, get_array_length e split_to_array.
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)