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](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). # Funciones de objeto A continuación, se presentan las funciones de objeto SQL que Amazon Redshift admite para operar en objetos tipo SUPER y crearlos: **Topics** + [Función GET\$1NUMBER\$1ATTRIBUTES](get_number_attributes.md) + [Función LOWER\$1ATTRIBUTE\$1NAMES](r_lower_attribute_names.md) + [Función OBJECT](r_object_function.md) + [Función OBJECT\$1TRANSFORM](r_object_transform_function.md) + [Función UPPER\$1ATTRIBUTE\$1NAMES](r_upper_attribute_names.md) # Función GET\$1NUMBER\$1ATTRIBUTES Devuelve un recuento del número de pares clave-valor que existen en el nivel raíz de un objeto diccionario. ## Sintaxis ``` GET_NUMBER_ATTRIBUTES( super_expression ) ``` ## Argumentos *super\$1expression* Una expresión SUPER en forma de diccionario. ## Tipo de retorno La función GET\$1NUMBER\$1ATTRIBUTES devuelve un tipo INT. ## Nota Esta función solo cuenta los atributos directos y no incluye pares en los diccionarios anidados. ## Ejemplo En el siguiente ejemplo se muestra la función GET\$1NUMBER\$1ATTRIBUTES. ``` SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": 2, "c": 3}')); get_number_attributes ----------------------- 3 (1 row) ``` La función GET\$1NUMBER\$1ATTRIBUTES solo funciona en el primer nivel del diccionario. ``` SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": {"c": 3}}')); get_number_attributes ----------------------- 2 (1 row) ``` # Función LOWER\$1ATTRIBUTE\$1NAMES Convierte todos los nombres de atributos aplicables de un valor SUPER a minúsculas, con la misma rutina de conversión de mayúsculas y minúsculas que [Función LOWER](r_LOWER.md). LOWER\$1ATTRIBUTE\$1NAMES admite caracteres multibyte UTF-8 de hasta un máximo de cuatro bytes por carácter. Para convertir los nombres del atributo SUPER a mayúsculas, use [Función UPPER\$1ATTRIBUTE\$1NAMES](r_upper_attribute_names.md). ## Sintaxis ``` LOWER_ATTRIBUTE_NAMES( super_expression ) ``` ## Argumentos *super\$1expression* Una expresión SUPER. ## Tipo de retorno `SUPER` ## Notas de uso En Amazon Redshift, los identificadores de columna tradicionalmente no distinguen entre mayúsculas y minúsculas y se convierten a minúsculas. Si ingiere datos de formatos de datos que distinguen mayúsculas de minúsculas, como JSON, es posible que los datos contengan nombres de atributos con mayúsculas y minúsculas. Considere el siguiente ejemplo. ``` CREATE TABLE t1 (s) AS SELECT JSON_PARSE('{"AttributeName": "Value"}'); SELECT s.AttributeName FROM t1; attributename ------------- NULL SELECT s."AttributeName" FROM t1; attributename ------------- NULL ``` Amazon Redshift devuelve un valor NULL para ambas consultas. Para realizar consultas de `AttributeName`, utilice LOWER\$1ATTRIBUTE\$1NAMES para convertir los nombres de los atributos de los datos a minúsculas. Considere el siguiente ejemplo. ``` CREATE TABLE t2 (s) AS SELECT LOWER_ATTRIBUTE_NAMES(s) FROM t1; SELECT s.attributename FROM t2; attributename ------------- "Value" SELECT s.AttributeName FROM t2; attributename ------------- "Value" SELECT s."attributename" FROM t2; attributename ------------- "Value" SELECT s."AttributeName" FROM t2; attributename ------------- "Value" ``` Una opción relacionada para trabajar con nombres de atributos de objetos en mayúsculas y minúsculas es la opción de configuración `enable_case_sensitive_super_attribute`, que permite a Amazon Redshift reconocer mayúsculas y minúsculas en los nombres de atributo SUPER. Esta puede ser una solución alternativa al uso de LOWER\$1ATTRIBUTE\$1NAMES. Para obtener más información sobre `enable_case_sensitive_super_attribute`, diríjase a [enable\$1case\$1sensitive\$1super\$1attribute](r_enable_case_sensitive_super_attribute.md). ## Ejemplos **Conversión de los nombres de los atributos SUPER a minúsculas** En el siguiente ejemplo, se utiliza LOWER\$1ATTRIBUTE\$1NAMES para convertir los nombres de los atributos de todos los valores SUPER de una tabla. ``` -- Create a table and insert several SUPER values. CREATE TABLE t (i INT, s SUPER); INSERT INTO t VALUES (1, NULL), (2, 'A'::SUPER), (3, JSON_PARSE('{"AttributeName": "B"}')), (4, JSON_PARSE( '[{"Subobject": {"C": "C"}, "Subarray": [{"D": "D"}, "E"] }]')); -- Convert all attribute names to lowercase. UPDATE t SET s = LOWER_ATTRIBUTE_NAMES(s); SELECT i, s FROM t ORDER BY i; i | s ---+-------------------------------------------------- 1 | NULL 2 | "A" 3 | {"attributename":"B"} 4 | [{"subobject":{"c":"C"},"subarray":[{"d":"D"}, "E"]}] ``` Observe cómo funciona LOWER\$1ATTRIBUTE\$1NAMES. + Los valores NULL y los valores escalares SUPER como `"A"` permanecen inalterados. + En un objeto SUPER, todos los nombres de los atributos se cambian a minúsculas, pero los valores de los atributos, como `"B"`, permanecen inalterados. + LOWER\$1ATTRIBUTE\$1NAMES se aplica de forma recursiva a cualquier objeto SUPER que esté anidado dentro de una matriz SUPER o dentro de otro objeto. **Uso de LOWER\$1ATTRIBUTE\$1NAMES en un objeto SUPER con nombres de atributos duplicados** Si un objeto SUPER contiene atributos cuyos nombres solo difieren en las mayúsculas y minúsculas, LOWER\$1ATTRIBUTE\$1NAMES generará un error. Considere el siguiente ejemplo. ``` SELECT LOWER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}')); error: Invalid input code: 8001 context: SUPER value has duplicate attributes after case conversion. ``` # Función OBJECT Crea un objeto del tipo de datos SUPER. ## Sintaxis ``` OBJECT ( [ key1, value1 ], [ key2, value2 ...] ) ``` ## Argumentos *key1, key2* Expresiones que se evalúan como cadenas de tipo VARCHAR. *value1, value2* Expresiones de cualquier tipo de datos de Amazon Redshift, excepto los datetime, ya que Amazon Redshift no convierte los tipos de datetime al tipo de datos SUPER. Para obtener más información sobre los tipos de datetime, consulte [Tipos de fecha y hora](r_Datetime_types.md). Las expresiones `value` en un objeto no tienen que ser del mismo tipo de datos. ## Tipo de retorno `SUPER` ## Ejemplo ``` -- Creates an empty object. select object(); object -------- {} (1 row) -- Creates objects with different keys and values. select object('a', 1, 'b', true, 'c', 3.14); object --------------------------- {"a":1,"b":true,"c":3.14} (1 row) select object('a', object('aa', 1), 'b', array(2,3), 'c', json_parse('{}')); object --------------------------------- {"a":{"aa":1},"b":[2,3],"c":{}} (1 row) -- Creates objects using columns from a table. create table bar (k varchar, v super); insert into bar values ('k1', json_parse('[1]')), ('k2', json_parse('{}')); select object(k, v) from bar; object ------------ {"k1":[1]} {"k2":{}} (2 rows) -- Errors out because DATE type values can't be converted to SUPER type. select object('k', '2008-12-31'::date); ERROR: OBJECT could not convert type date to super ``` # Función OBJECT\$1TRANSFORM Transforma un objeto SUPER. ## Sintaxis ``` OBJECT_TRANSFORM( input [KEEP path1, ...] [SET path1, value1, ..., ... ] ) ``` ## Argumentos *Entrada de* Expresión que se convierte en un objeto de tipo SUPER. *KEEP* Todos los valores de *path* especificados en esta cláusula se conservan y se trasladan al objeto de salida. Esta cláusula es opcional. *path1*, *path2*, ... Literales de cadena constantes, en formato de componentes de ruta entre comillas dobles delimitados por puntos. Por ejemplo, `'"a"."b"."c"'` es un valor válido. Esto se aplica al parámetro path de las cláusulas KEEP y SET. *SET* Pares de *path* y *value* para modificar una ruta existente o añadir una nueva y establecer el valor de esa ruta en el objeto de salida. Esta cláusula es opcional. *value1*, *value2*, ... Expresiones que se resuelven en valores de tipo SUPER. Tenga en cuenta que los tipos numérico, de texto y booleano se pueden resolver en SUPER. ## Tipo de retorno `SUPER` ## Notas de uso OBJECT\$1TRANSFORM devuelve un objeto de tipo SUPER que contiene los valores de ruta *input* que se han especificado en KEEP y los pares de *path* y *value* que se han especificado en SET. Si tanto KEEP como SET están vacíos, OBJECT\$1TRANSFORM devuelve *input*. Si *input* no es un *object* de tipo SUPER, OBJECT\$1TRANSFORM devuelve *input*, independientemente de los valores KEEP o SET. ## Ejemplo En el siguiente ejemplo se transforma un objeto SUPER en otro objeto SUPER. ``` CREATE TABLE employees ( col_person SUPER ); INSERT INTO employees VALUES ( json_parse(' { "name": { "first": "John", "last": "Doe" }, "age": 25, "ssn": "111-22-3333", "company": "Company Inc.", "country": "U.S." } ') ), ( json_parse(' { "name": { "first": "Jane", "last": "Appleseed" }, "age": 34, "ssn": "444-55-7777", "company": "Organization Org.", "country": "Ukraine" } ') ) ; SELECT OBJECT_TRANSFORM( col_person KEEP '"name"."first"', '"age"', '"company"', '"country"' SET '"name"."first"', UPPER(col_person.name.first::TEXT), '"age"', col_person.age + 5, '"company"', 'Amazon' ) AS col_person_transformed FROM employees; --This result is formatted for ease of reading. col_person_transformed ------------------------------------------------------------- { "name": { "first": "JOHN" }, "age": 30, "company": "Amazon", "country": "U.S." } { "name": { "first": "JANE" }, "age": 39, "company": "Amazon", "country": "Ukraine" } ``` # Función UPPER\$1ATTRIBUTE\$1NAMES Convierte todos los nombres de los atributos aplicables de un valor SUPER a mayúsculas, con la misma rutina de conversión de mayúsculas y minúsculas que [Función UPPER](r_UPPER.md). UPPER\$1ATTRIBUTE\$1NAMES admite caracteres multibyte UTF-8 de hasta un máximo de cuatro bytes por carácter. Para convertir los nombres del atributo SUPER a minúsculas, use [Función LOWER\$1ATTRIBUTE\$1NAMES](r_lower_attribute_names.md). ## Sintaxis ``` UPPER_ATTRIBUTE_NAMES( super_expression ) ``` ## Argumentos *super\$1expression* Una expresión SUPER. ## Tipo de retorno `SUPER` ## Ejemplos **Conversión de los nombres del atributo SUPER a mayúsculas** En el siguiente ejemplo, se utiliza UPPER\$1ATTRIBUTE\$1NAMES para convertir los nombres de los atributos de todos los valores SUPER de una tabla. ``` -- Create a table and insert several SUPER values. CREATE TABLE t (i INT, s SUPER); INSERT INTO t VALUES (1, NULL), (2, 'a'::SUPER), (3, JSON_PARSE('{"AttributeName": "b"}')), (4, JSON_PARSE( '[{"Subobject": {"c": "c"}, "Subarray": [{"d": "d"}, "e"] }]')); -- Convert all attribute names to uppercase. UPDATE t SET s = UPPER_ATTRIBUTE_NAMES(s); SELECT i, s FROM t ORDER BY i; i | s ---+-------------------------------------------------- 1 | NULL 2 | "a" 3 | {"ATTRIBUTENAME":"B"} 4 | [{"SUBOBJECT":{"C":"c"},"SUBARRAY":[{"D":"d"}, "e"]}] ``` Observe cómo funciona UPPER\$1ATTRIBUTE\$1NAMES. + Los valores NULL y los valores escalares SUPER como `"a"` permanecen inalterados. + En un objeto SUPER, todos los nombres de los atributos se cambian a mayúsculas, pero los valores de los atributos, como `"b"`, permanecen inalterados. + UPPER\$1ATTRIBUTE\$1NAMES se aplica de forma recursiva a cualquier objeto SUPER que esté anidado dentro de una matriz SUPER o dentro de otro objeto. **Uso de UPPER\$1ATTRIBUTE\$1NAMES en un objeto SUPER con nombres de atributos duplicados** Si un objeto SUPER contiene atributos cuyos nombres solo difieren en mayúsculas y minúsculas, UPPER\$1ATTRIBUTE\$1NAMES generará un error. Considere el siguiente ejemplo. ``` SELECT UPPER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}')); error: Invalid input code: 8001 context: SUPER value has duplicate attributes after case conversion. ```