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/). # 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: **Topics** + [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) # Função GET\$1NUMBER\$1ATTRIBUTES Exibe a contagem de pares de chave-valor existentes no nível raiz de um objeto de dicionário. ## Sintaxe ``` GET_NUMBER_ATTRIBUTES( super_expression ) ``` ## Argumentos *super\$1expression* Uma expressão SUPER em forma de dicionário. ## Tipo de retorno A função GET\$1NUMBER\$1ATTRIBUTES exibe um tipo INT. ## Observação Essa função conta somente atributos diretos e não inclui pares em dicionários aninhados. ## Exemplo O exemplo a seguir mostra a função GET\$1NUMBER\$1ATTRIBUTES. ``` SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": 2, "c": 3}')); get_number_attributes ----------------------- 3 (1 row) ``` A função GET\$1NUMBER\$1ATTRIBUTES opera somente no primeiro nível do dicionário. ``` SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": {"c": 3}}')); get_number_attributes ----------------------- 2 (1 row) ``` # Função LOWER\$1ATTRIBUTE\$1NAMES Converte todos os nomes de atributos aplicáveis em um valor SUPER em minúsculas, usando a mesma rotina de conversão de maiúsculas e minúsculas de [Função LOWER](r_LOWER.md). LOWER\$1ATTRIBUTE\$1NAMES aceita caracteres UTF-8 multibyte, até o máximo de quatro bytes por caractere. Para converter nomes de atributos SUPER em maiúsculas, use [Função UPPER\$1ATTRIBUTE\$1NAMES](r_upper_attribute_names.md). ## Sintaxe ``` LOWER_ATTRIBUTE_NAMES( super_expression ) ``` ## Argumentos *super\$1expression* Uma expressão SUPER. ## Tipo de retorno `SUPER` ## Observações de uso No Amazon Redshift, os identificadores de coluna tradicionalmente não diferenciam maiúsculas de minúsculas e são convertidos em minúsculas. Se você ingerir dados de formatos de dados que diferenciam maiúsculas e minúsculas, como JSON, os dados poderão conter nomes de atributos com maiúsculas e minúsculas. Considere o exemplo a seguir. ``` CREATE TABLE t1 (s) AS SELECT JSON_PARSE('{"AttributeName": "Value"}'); SELECT s.AttributeName FROM t1; attributename ------------- NULL SELECT s."AttributeName" FROM t1; attributename ------------- NULL ``` O Amazon Redshift exibe NULL para as duas consultas. Para consultar `AttributeName`, use LOWER\$1ATTRIBUTE\$1NAMES para converter os nomes dos atributos dos dados em minúsculas. Considere o exemplo a seguir. ``` 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" ``` Uma opção relacionada para trabalhar com nomes de atributos de objetos com maiúsculas e minúsculas é a opção de configuração `enable_case_sensitive_super_attribute`, que permite ao Amazon Redshift reconhecer maiúsculas e minúsculas em nomes de atributos SUPER. Essa pode ser uma solução alternativa ao uso de LOWER\$1ATTRIBUTE\$1NAMES. Para ter mais informações sobre `enable_case_sensitive_super_attribute`, acesse [enable\$1case\$1sensitive\$1super\$1attribute](r_enable_case_sensitive_super_attribute.md). ## Exemplos **Converter nomes de atributos SUPER em minúsculas** O exemplo a seguir usa LOWER\$1ATTRIBUTE\$1NAMES para converter os nomes dos atributos de todos os valores SUPER em uma tabela. ``` -- 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 como LOWER\$1ATTRIBUTE\$1NAMES funciona. + Valores NULL e valores SUPER escalares, como `"A"`, permanecem inalterados. + Em um objeto SUPER, todos os nomes de atributos são alterados para minúsculas, mas valores de atributos como `"B"` permanecem inalterados. + LOWER\$1ATTRIBUTE\$1NAMES aplica-se recursivamente a qualquer objeto SUPER aninhado dentro de uma matriz SUPER ou dentro de outro objeto. **Usar LOWER\$1ATTRIBUTE\$1NAMES em um objeto SUPER com nomes de atributos duplicados** Se um objeto SUPER contiver atributos cujos nomes sejam diferentes apenas em termos de maiúsculas e minúsculas, LOWER\$1ATTRIBUTE\$1NAMES gerará um erro. Considere o exemplo a seguir. ``` SELECT LOWER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}')); error: Invalid input code: 8001 context: SUPER value has duplicate attributes after case conversion. ``` # Função OBJECT Cria um objeto do tipo de dados SUPER. ## Sintaxe ``` OBJECT ( [ key1, value1 ], [ key2, value2 ...] ) ``` ## Argumentos *key1, key2* Expressões avaliadas em strings do tipo VARCHAR. *value1, value2* Expressões de qualquer tipo de dado do Amazon Redshift, exceto os tipos de data e hora, já que o Amazon Redshift não transmite os tipos de data e hora para o tipo de dados SUPER. Para obter mais informações sobre tipos de data e hora, consulte [Tipos de datetime](r_Datetime_types.md). As expressões `value` em um objeto não precisam ser do mesmo tipo de dados. ## Tipo de retorno `SUPER` ## Exemplo ``` -- 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 ``` # Função OBJECT\$1TRANSFORM Transforma um objeto SUPER. ## Sintaxe ``` OBJECT_TRANSFORM( input [KEEP path1, ...] [SET path1, value1, ..., ... ] ) ``` ## Argumentos *input* Uma expressão resolvida em um objeto do tipo SUPER. *KEEP* Todos os valores *path* especificados nessa cláusula são mantidos e transportados para o objeto de saída. A cláusula é opcional. *path1*, *path2*... Literais de string constantes, no formato de componentes de caminho com aspas duplas delimitados por pontos finais. Por exemplo, `'"a"."b"."c"'` não é um valor de caminho válido. Isso se aplica ao parâmetro path nas cláusulas KEEP e SET. *SET* Pares *path* e *value* para modificar um caminho existente ou adicionar um novo caminho, além de definir o valor desse caminho no objeto de saída. A cláusula é opcional. *value1*, *value2*... Expressões resolvidas como valores do tipo SUPER. Os tipos numérico, de texto e booliano podem ser resolvidos como SUPER. ## Tipo de retorno `SUPER` ## Observações de uso OBJECT\$1TRANSFORM retorna um objeto do tipo SUPER contendo os valores do caminho de *entrada* que foram especificados em KEEP e os pares de *caminho* e *valor* que foram especificados em SET. Se KEEP e SET estiverem vazios, OBJECT\$1TRANSFORM vai retornar *entrada*. Se a *entrada* não for um *objeto* do tipo SUPER, OBJECT\$1TRANSFORM retornará a *entrada*, independentemente de eventuais valores KEEP ou SET. ## Exemplo O exemplo a seguir transforma um objeto SUPER em outro 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" } ``` # Função UPPER\$1ATTRIBUTE\$1NAMES Converte todos os nomes de atributos aplicáveis em um valor SUPER em maiúsculas, usando a mesma rotina de conversão de maiúsculas e minúsculas de [Função UPPER](r_UPPER.md). UPPER\$1ATTRIBUTE\$1NAMES é compatível com caracteres UTF-8 multibyte, até o máximo de quatro bytes por caractere. Para converter nomes de atributos SUPER em minúsculas, use [Função LOWER\$1ATTRIBUTE\$1NAMES](r_lower_attribute_names.md). ## Sintaxe ``` UPPER_ATTRIBUTE_NAMES( super_expression ) ``` ## Argumentos *super\$1expression* Uma expressão SUPER. ## Tipo de retorno `SUPER` ## Exemplos **Converter nomes de atributos SUPER em maiúsculas** O exemplo a seguir usa UPPER\$1ATTRIBUTE\$1NAMES para converter os nomes dos atributos de todos os valores SUPER em uma tabela. ``` -- 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 como UPPER\$1ATTRIBUTE\$1NAMES funciona. + Valores NULL e valores SUPER escalares, como `"a"`, permanecem inalterados. + Em um objeto SUPER, todos os nomes de atributos são alterados para maiúsculas, mas valores de atributos como `"b"` permanecem inalterados. + UPPER\$1ATTRIBUTE\$1NAMES aplica-se recursivamente a qualquer objeto SUPER aninhado dentro de uma matriz SUPER ou dentro de outro objeto. **Usar UPPER\$1ATTRIBUTE\$1NAMES em um objeto SUPER com nomes de atributos duplicados** Se um objeto SUPER contiver atributos cujos nomes sejam diferentes apenas em termos de maiúsculas e minúsculas, UPPER\$1ATTRIBUTE\$1NAMES gerará um erro. Considere o exemplo a seguir. ``` SELECT UPPER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}')); error: Invalid input code: 8001 context: SUPER value has duplicate attributes after case conversion. ```