As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Tipos definidos pelo usuário (UDTs) no Amazon Keyspaces Um tipo definido pelo usuário (UDT) é um agrupamento de campos e tipos de dados que você pode usar para definir uma única coluna no Amazon Keyspaces. Os tipos de dados válidos para UDTs são todos os tipos de dados do Cassandra compatíveis, incluindo coleções e outros UDTs que você já criou no mesmo espaço chave. Para obter mais informações sobre os tipos de dados do Cassandra compatíveis, consulte. [Suporte ao tipo de dados do Cassandra](cassandra-apis.md#cassandra-data-type) Você pode usar tipos definidos pelo usuário (UDTs) no Amazon Keyspaces para organizar os dados de uma forma mais eficiente. Por exemplo, você pode criar UDTs com coleções aninhadas, o que permite implementar uma modelagem de dados mais complexa em seus aplicativos. Você também pode usar a palavra-chave frozen para definir UDTs. UDTs estão vinculados a um espaço de chave e estão disponíveis para todas as tabelas e UDTs no mesmo espaço de chave. Você pode criar UDTs em espaços de chave de região única e multirregião. Você pode criar novas tabelas ou alterar tabelas existentes e adicionar novas colunas que usam um UDT. Para criar uma UDT com uma UDT aninhada, a UDT aninhada precisa ser congelada. Para analisar quantos UDTs são suportados por espaço de chave, níveis de aninhamento suportados e outros valores e cotas padrão relacionados a UDTs, consulte. [Cotas e valores padrão para tipos definidos pelo usuário (UDTs) no Amazon Keyspaces](quotas.md#quotas-udts) Para obter informações sobre como calcular o tamanho codificado de UDTs, consulte[Estime o tamanho codificado dos valores de dados com base no tipo de dados](calculating-row-size.md#calculating-row-size-data-types). Para obter mais informações sobre sintaxe de CQL, consulte [Tipos definidos pelo usuário () UDTs](cql.ddl.type.md). Para saber mais sobre restauração pontual UDTs e restauração pontual, consulte. [Restauração PITR de tabelas com tipos definidos pelo usuário () UDTs](PointInTimeRecovery_HowItWorks.md#howitworks_backup_udt) **Topics** + [Configurar permissões do](configure-udt-permissions.md) + [Crie um UDT](keyspaces-create-udt.md) + [Visualizar UDTs](keyspaces-view-udt.md) + [Excluir um UDT](keyspaces-delete-udt.md) # Configure permissões para trabalhar com tipos definidos pelo usuário (UDTs) no Amazon Keyspaces Como as tabelas, UDTs estão vinculadas a um espaço de teclas específico. Mas, diferentemente das tabelas, você não pode definir permissões diretamente para UDTs. UDTs não são considerados recursos AWS e não têm identificadores exclusivos no formato de um nome de recurso da Amazon (ARN). Em vez disso, para dar a um IAM permissões principais para realizar ações específicas em um UDT, você precisa definir permissões para o keyspace ao qual o UDT está vinculado. Para trabalhar com espaços UDTs de chave multirregionais, são necessárias permissões adicionais. Para poder criar, visualizar ou excluir, o principal UDTs, por exemplo, um usuário ou uma função do IAM, precisa das mesmas permissões necessárias para realizar a mesma ação no espaço de teclas ao qual o UDT está vinculado. Para obter mais informações sobre AWS Identity and Access Management, consulte[AWS Identity and Access Management para Amazon Keyspaces](security-iam.md). ## Permissões para criar um UDT Para criar um UDT em um espaço de chave de região única, o principal precisa de `Create` permissões para o espaço de chave. A política do IAM a seguir é um exemplo disso. ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "cassandra:Create", "Resource": [ "arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/" ] } ] } ``` Para criar um UDT em um espaço de chave multirregional, além das `Create` permissões, o diretor também precisa de permissões para a ação no espaço de chave `CreateMultiRegionResource` especificado. A política do IAM a seguir é um exemplo disso. ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "cassandra:Create", "cassandra:CreateMultiRegionResource" ], "Resource": [ "arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/" ] } ] } ``` ## Permissões para visualizar um UDT Para visualizar ou listar UDTs em um espaço de chave de região única, o principal precisa de permissões de leitura para o espaço de teclas do sistema. Para obter mais informações, consulte [`system_schema_mcs`](working-with-keyspaces.md#keyspace_system_schema_mcs). A política do IAM a seguir é um exemplo disso. ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":"cassandra:Select", "Resource":[ "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*" ] } ] } ``` Para visualizar ou listar UDTs um espaço de chave multirregional, o principal precisa de permissões para as ações `SELECT` e `SelectMultiRegionResource` para o espaço de teclas do sistema. Para obter mais informações, consulte [`system_multiregion_info`](working-with-keyspaces.md#keyspace_system_multiregion_info). A política do IAM a seguir é um exemplo disso. ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action": ["cassandra:Select", "cassandra:SelectMultiRegionResource"], "Resource":[ "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*" ] } ] } ``` ## Permissões para excluir um UDT Para excluir um UDT de um espaço de chave de região única, o principal precisa de permissões para a `Drop` ação no espaço de chave especificado. A política do IAM a seguir é um exemplo disso. ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "cassandra:Drop", "Resource": [ "arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/" ] } ] } ``` Para excluir um UDT de um espaço de chave multirregional, o principal precisa de permissões para a `Drop` ação e para a `DropMultiRegionResource` ação do espaço de chave especificado. A política do IAM a seguir é um exemplo disso. ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "cassandra:Drop", "cassandra:DropMultiRegionResource" ], "Resource": [ "arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/" ] } ] } ``` # Crie um tipo definido pelo usuário (UDT) no Amazon Keyspaces Para criar um UDT em um keyspace de região única, você pode usar a `CREATE TYPE` instrução na CQL, o `create-type` comando com o ou o console AWS CLI. Os nomes de UDTs devem conter 48 caracteres ou menos, devem começar com um caractere alfabético e só podem conter caracteres alfanuméricos e sublinhados. O Amazon Keyspaces converte automaticamente caracteres maiúsculos em minúsculos. Também é possível declarar um nome de UDT entre aspas duplas. Quando um nome de UDT é declarado entre aspas duplas, o Amazon Keyspaces preserva maiúsculas e permite caracteres especiais. Você também pode usar aspas duplas como parte do nome ao criar o UDT, mas deve realiza o escape de cada caractere de aspas duplas com um caractere adicional de aspas duplas. A tabela a seguir mostra exemplos de nomes de UDT permitidos. A primeira coluna mostra como inserir o nome quando se cria o tipo, e a segunda coluna mostra como o Amazon Keyspaces formata o nome internamente. O Amazon Keyspaces espera o nome formatado para operações, como `GetType`. | Nome inserido | Nome formatado | Observação | | --- | --- | --- | | MY\$1UDT | my\$1udt | Sem aspas duplas, o Amazon Keyspaces converte todos os caracteres maiúsculos em minúsculos. | | "MY\$1UDT" | MY\$1UDT | Com aspas duplas, o Amazon Keyspaces respeita os caracteres maiúsculos e remove as aspas duplas do nome formatado. | | "1234" | 1234 | Com aspas duplas, o nome pode começar com um número, e o Amazon Keyspaces remove as aspas duplas do nome formatado. | | "Special\$1Ch@r@cters<>\$1\$1" | Special\$1Ch@r@cters<>\$1\$1 | Com aspas duplas, o nome pode conter caracteres especiais, e o Amazon Keyspaces remove as aspas duplas do nome formatado. | | "nested""""""quotes" | nested"""quotes | O Amazon Keyspaces remove as aspas duplas externas e as aspas duplas de escape do nome formatado. | ------ #### [ Console ] **Crie um tipo definido pelo usuário (UDT) com o console Amazon Keyspaces** 1. [Faça login no Console de gerenciamento da AWS e abra o console do Amazon Keyspaces em casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home) 1. No painel de navegação, escolha **Keyspaces** e, em seguida, escolha um keyspace na lista. 1. Escolha a guia **UDTs**. 1. Escolha **Criar UDT** 1. Em **Detalhes do UDT**, insira o nome do UDT. Em **campos do UDT**, você define o esquema do UDT. 1. Para finalizar, escolha **Criar UDT.** ------ #### [ Cassandra Query Language (CQL) ] **Crie um tipo definido pelo usuário (UDT) com CQL** Neste exemplo, criamos uma nova versão da tabela de prêmios de livros usada em[Crie uma tabela no Amazon Keyspaces.](getting-started.tables.md). Nesta tabela, armazenamos todos os prêmios que um autor recebe por um determinado livro. Criamos dois UDTs que estão aninhados e contêm informações sobre o livro que recebeu um prêmio. 1. Crie um keyspace com o nome`catalog`. ``` CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'}; ``` 1. Crie o primeiro tipo. Esse tipo armazena códigos *BISAC*, que são usados para definir o gênero dos livros. Um código BISAC consiste em um código alfanumérico e até quatro áreas temáticas. ``` CREATE TYPE catalog.bisac ( bisac_code text, subject1 text, subject2 text, subject3 text, subject4 text ); ``` 1. Crie um segundo tipo para prêmios de livros que use o primeiro UDT. O UDT aninhado deve ser congelado. ``` CREATE TYPE catalog.book ( award_title text, book_title text, publication_date date, page_count int, ISBN text, genre FROZEN ); ``` 1. Crie uma tabela com uma coluna para o nome do autor e use um tipo de lista para os prêmios do livro. Observe que o UDT usado na lista precisa ser congelado. ``` CREATE TABLE catalog.authors ( author_name text PRIMARY KEY, awards list > ); ``` 1. Nesta etapa, inserimos uma linha de dados na nova tabela. ``` CONSISTENCY LOCAL_QUORUM; ``` ``` INSERT INTO catalog.authors (author_name, awards) VALUES ( 'John Stiles' , [{ award_title: 'Wolf', book_title: 'Yesterday', publication_date: '2020-10-10', page_count: 345, ISBN: '026204630X', genre: { bisac_code:'FIC014090', subject1: 'FICTION', subject2: 'Historical', subject3: '20th Century', subject4: 'Post-World War II'} }, {award_title: 'Richard Roe', book_title: 'Who ate the cake?', publication_date: '2019-05-13', page_count: 193, ISBN: '9780262046305', genre: { bisac_code:'FIC022130', subject1: 'FICTION', subject2: 'Mystery & Detective', subject3: 'Cozy', subject4: 'Culinary'} }] ); ``` 1. Na última etapa, lemos os dados da tabela. ``` SELECT * FROM catalog.authors; ``` A saída do comando deve ter essa aparência. ``` author_name | awards -------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- John Stiles | [{award_title: 'Wolf', book_title: 'Yesterday', publication_date: 2020-10-10, page_count: 345, isbn: '026204630X', genre: {bisac_code: 'FIC014090', subject1: 'FICTION', subject2: 'Historical', subject3: '20th Century', subject4: 'Post-World War II'}}, {award_title: 'Richard Roe', book_title: 'Who ate the cake?', publication_date: 2019-05-13, page_count: 193, isbn: '9780262046305', genre: {bisac_code: 'FIC022130', subject1: 'FICTION', subject2: 'Mystery & Detective', subject3: 'Cozy', subject4: 'Culinary'}}] (1 rows) ``` Para obter mais informações sobre sintaxe de CQL, consulte [CREATE TYPE](cql.ddl.type.md#cql.ddl.type.create). ------ #### [ CLI ] **Crie um tipo definido pelo usuário (UDT) com o AWS CLI** 1. Para criar um tipo, você pode usar a seguinte sintaxe. ``` aws keyspaces create-type --keyspace-name 'my_keyspace' --type-name 'my_udt' --field-definitions '[ {"name" : "field1", "type" : "int"}, {"name" : "field2", "type" : "text"} ]' ``` 1. A saída desse comando é semelhante a este exemplo. Observe que `typeName` retorna o nome formatado do UDT. ``` { "keyspaceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/", "typeName": "my_udt" } ``` ------ # Visualize tipos definidos pelo usuário (UDTs) no Amazon Keyspaces Para visualizar ou listar tudo UDTs em um espaço de chave de região única, você pode consultar a tabela `system_schema_mcs.types` no espaço de chaves do sistema usando uma instrução em CQL ou usar os `list-type` comandos `get-type` e com o console AWS CLI. Para qualquer uma das opções, o diretor do IAM precisa de permissões de leitura no espaço de chaves do sistema. Para obter mais informações, consulte [Configure permissões para trabalhar com tipos definidos pelo usuário (UDTs) no Amazon Keyspaces](configure-udt-permissions.md). ------ #### [ Console ] **Visualize tipos definidos pelo usuário (UDT) com o console Amazon Keyspaces** 1. [Faça login no Console de gerenciamento da AWS e abra o console do Amazon Keyspaces em casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home) 1. No painel de navegação, escolha **Keyspaces** e, em seguida, escolha um keyspace na lista. 1. Escolha a **UDTs**guia para revisar a lista de todos UDTs no espaço de teclas. 1. Para revisar um UDT em detalhes, escolha um **UDT** na lista. 1. Na guia **Esquema**, você pode revisar o esquema. Na guia **Usado em**, você pode ver se esse UDT é usado em tabelas ou outras UDTs. Observe que você só pode excluir os UDTs que não estão sendo usados por tabelas ou outras UDTs. ------ #### [ Cassandra Query Language (CQL) ] **Visualize os tipos definidos pelo usuário (UDTs) de um keyspace de região única com CQL** 1. Para ver os tipos que estão disponíveis em um determinado espaço de teclas, você pode usar a seguinte declaração. ``` SELECT type_name FROM system_schema_mcs.types WHERE keyspace_name = 'my_keyspace'; ``` 1. Para ver os detalhes sobre um tipo específico, você pode usar a seguinte declaração. ``` SELECT keyspace_name, type_name, field_names, field_types, max_nesting_depth, last_modified_timestamp, status, direct_referring_tables, direct_parent_types FROM system_schema_mcs.types WHERE keyspace_name = 'my_keyspace' AND type_name = 'my_udt'; ``` 1. Você pode listar tudo o UDTs que existe na conta usando`DESC TYPE`. ``` DESC TYPES; Keyspace my_keyspace --------------------------- my_udt1 my_udt2 Keyspace my_keyspace2 --------------------------- my_udt1 ``` 1. Você pode listar tudo UDTs no espaço de teclas selecionado atualmente usando`DESC TYPE`. ``` USE my_keyspace; my_keyspace DESC TYPES; my_udt1 my_udt2 ``` 1. Para listar tudo UDTs em um espaço de chave multirregional, você pode consultar a tabela do sistema `types` no `system_multiregion_info` espaço de chaves. A consulta a seguir é um exemplo disso. ``` SELECT keyspace_name, type_name, region, status FROM system_multiregion_info.types WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable'; ``` A saída desse comando é semelhante a essa. ``` keyspace_name | table_name | region | status mykeyspace | mytable | us-east-1 | ACTIVE mykeyspace | mytable | ap-southeast-1 | ACTIVE mykeyspace | mytable | eu-west-1 | ACTIVE ``` ------ #### [ CLI ] **Exibir tipos definidos pelo usuário (UDTs) com o AWS CLI** 1. Para listar os tipos disponíveis em um keyspace, você pode usar o `list-types` comando. ``` aws keyspaces list-types --keyspace-name 'my_keyspace' ``` A saída desse comando é semelhante a este exemplo. ``` { "types": [ "my_udt", "parent_udt" ] } ``` 1. Para ver os detalhes sobre um determinado tipo, você pode usar o `get-type` comando. ``` aws keyspaces get-type --type-name 'my_udt' --keyspace-name 'my_keyspace' ``` A saída desse comando é semelhante a este exemplo. ``` { "keyspaceName": "my_keyspace", "typeName": "my_udt", "fieldDefinitions": [ { "name": "a", "type": "int" }, { "name": "b", "type": "text" } ], "lastModifiedTimestamp": 1721328225776, "maxNestingDepth": 3 "status": "ACTIVE", "directReferringTables": [], "directParentTypes": [ "parent_udt" ], "keyspaceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/" } ``` ------ # Excluir um tipo definido pelo usuário (UDT) no Amazon Keyspaces Para excluir um UDT em um keyspace, você pode usar a `DROP TYPE` instrução em CQL, o `delete-type` comando com o. ou o AWS CLI console. ------ #### [ Console ] **Exclua um tipo definido pelo usuário (UDT) com o console Amazon Keyspaces** 1. [Faça login no Console de gerenciamento da AWS e abra o console do Amazon Keyspaces em casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home) 1. No painel de navegação, escolha **Keyspaces** e, em seguida, escolha um keyspace na lista. 1. Escolha a guia **UDTs**. 1. Escolha o UDT que você deseja excluir. **Em Usado em**, você pode confirmar que o tipo que você deseja excluir não é usado atualmente por uma tabela ou outro UDT. 1. Escolha **Excluir** acima do **Resumo**. 1. Digite `Delete` na caixa de diálogo exibida e escolha **Excluir UDT.** ------ #### [ Cassandra Query Language (CQL) ] **Exclua um tipo definido pelo usuário (UDT) com CQL** + Para excluir um tipo, você pode usar a seguinte declaração. ``` DROP TYPE my_keyspace.my_udt; ``` Para obter mais informações sobre sintaxe de CQL, consulte [DROP TYPE](cql.ddl.type.md#cql.ddl.type.drop). ------ #### [ CLI ] **Exclua um tipo definido pelo usuário (UDT) com o AWS CLI** 1. Para excluir um tipo, você pode usar o comando a seguir. ``` aws keyspaces delete-type --keyspace-name 'my_keyspace' --type-name 'my_udt' ``` 1. A saída do comando é semelhante a este exemplo. ``` { "keyspaceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/", "typeName": "my_udt" } ``` ------