Amazon Redshift dejará de admitir la creación de nuevas UDF de Python a partir del parche 198. Las UDF de Python existentes seguirán funcionando hasta el 30 de junio de 2026. Para obtener más información, consulte la publicación del blog.

Operadores y funciones

Con Amazon Redshift, puede realizar análisis avanzados en conjuntos de datos de gran tamaño utilizando datos SUPER mediante operadores y funciones. Los operadores y las funciones de los datos SUPER son constructos de SQL que permiten el análisis y la manipulación complejos de los datos semiestructurados almacenados en las tablas de Amazon Redshift.

En las siguientes secciones se describen la sintaxis, los ejemplos y las prácticas recomendadas para utilizar operadores y funciones para los datos SUPER en Amazon Redshift a fin de aprovechar todo el potencial de los datos semiestructurados.

Operadores aritméticos

Los valores SUPER admiten todos los operadores aritméticos básicos +, -, *, /, % utilizando la escritura dinámica. El tipo resultante de la operación sigue siendo SUPER. Para todos los operadores, excepto para el operador binario +, los operandos de entrada deben ser números. De lo contrario, Amazon Redshift devolverá un valor nulo. La distinción entre valores decimales y de coma flotante se conserva cuando Amazon Redshift ejecuta estos operadores y el tipo dinámico no cambia. Sin embargo, la escala decimal cambia cuando se utilizan multiplicaciones y divisiones. Los desbordamientos aritméticos siguen causando errores de consulta; no se cambian a valores nulos. El operador binario + lleva a cabo la adición si las entradas son números o la concatenación si las entradas son cadenas. Si un operando es una cadena y el otro operando es un número, el resultado será nulo. Los operadores de prefijo unario + y - devuelven valores nulos si el valor SUPER no es un número, como se muestra en el siguiente ejemplo:

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)

La escritura dinámica permite que los valores decimales en SUPER tengan diferentes escalas. Amazon Redshift trata los valores decimales como si fueran diferentes tipos estáticos y permite todas las operaciones matemáticas. Amazon Redshift calcula la escala resultante de forma dinámica en función de las escalas de los operandos. Si uno de los operandos es un número de coma flotante, Amazon Redshift promueve el otro operando a un número de coma flotante y genera el resultado como un número de coma flotante.

Funciones aritméticas

Amazon Redshift admite las siguientes funciones aritméticas para las columnas SUPER. Ellas devolverán un valor nulo si la entrada no es un número:

En el siguiente ejemplo, se utilizan funciones aritméticas para consultar datos:

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

La función ABS conserva la escala del decimal de entrada durante las funciones FLOOR, CEIL. La función ROUND elimina la escala del decimal de entrada.

Funciones de matriz

Amazon Redshift admite las siguientes funciones de composición de matrices y utilidades:

Puede construir matrices SUPER a partir de valores de los tipos de datos de Amazon Redshift mediante la función ARRAY, incluidos otros valores SUPER. En el siguiente ejemplo, se utiliza la función 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)

En el siguiente ejemplo, se utiliza la concatenación de matrices con la función ARRAY_CONCAT:

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

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

En el siguiente ejemplo, se utiliza la manipulación de matrices con la función SUBARRAY, que devuelve un subconjunto de la matriz de entrada.

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

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

En el siguiente ejemplo, se fusionan varios niveles de matrices en una sola matriz con 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)

Las funciones de matriz ARRAY_CONCAT y ARRAY_FLATTEN utilizan reglas de escritura dinámica. Si la entrada no es una matriz, devuelven un valor nulo en lugar de un error. La función GET_ARRAY_LENGTH devuelve la longitud de una matriz SUPER dada una ruta de objeto o matriz.

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

En el siguiente ejemplo, se divide una cadena en una matriz de cadenas usando SPLIT_TO_ARRAY. La función utiliza un delimitador como parámetro opcional. Si ningún delimitador está ausente, entonces el valor predeterminado es la coma.

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

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

Comportamiento de intercalación

Con SUPER, puede establecer la intercalación de una columna con CREATE TABLE, tomar el conjunto de intercalación predeterminado con CREATE DATABASE y establecer la intercalación de una expresión con la función COLLATE.

La configuración de intercalación se aplica a todos los operadores de comparación y valores de cadena almacenados en SUPER, ya sean valores de cadena, cadenas dentro de matrices SUPER o valores de un objeto SUPER. En el caso de los objetos SUPER, el comportamiento de intercalación solo se aplica a los valores y no a los atributos. Por ejemplo, una comparación de valores en los que la intercalación de no distingue mayúsculas de minúsculas de {"attribute": "a"} = {"attribute": "A"} devuelve true, mientras que {"attribute": "a"} = {"ATTRIBUTE": "a"} devuelve false.

Funciones de información

Las columnas de datos SUPER admiten funciones de inspección que devuelven el tipo dinámico y otra información del tipo relativa al valor SUPER. El ejemplo más común es la función escalar JSON_TYPEOF que devuelve un VARCHAR con valores booleanos, de números, de cadenas, de objetos, de matrices o nulos, dependiendo del tipo dinámico del valor SUPER. Amazon Redshift admite las siguientes funciones booleanas para las columnas de datos SUPER:

Para obtener más información acerca de las funciones de información de tipo SUPER, consulte Funciones de información acerca del tipo SUPER.

Funciones de cadena

Para utilizar funciones de cadena con literales de cadena en el tipo de datos SUPER, debe convertir el literal de cadena en un tipo de cadena antes de aplicar las funciones. Las funciones devolverán un valor nulo si la entrada no es un literal de cadena.

Funciones de cadena ahora admiten hasta 16 000 000 bytes.

El ejemplo siguiente usa SUBSTRING para extraer la vista previa de una cadena con un tamaño de 5 000 000 de bytes almacenada en un 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
   

El ejemplo siguiente muestra las funciones LEFT, RIGHT y CONCAT en literales de cadena de una 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
   

El ejemplo siguiente almacena una cadena independiente en 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