Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Types définis par l'utilisateur (UDTs) dans Amazon Keyspaces
Un type défini par l'utilisateur (UDT) est un regroupement de champs et de types de données que vous pouvez utiliser pour définir une seule colonne dans Amazon Keyspaces. Les types de données valides pour UDTs sont tous les types de données Cassandra pris en charge, y compris les collections et les autres UDTs que vous avez déjà créées dans le même keyspace. Pour plus d'informations sur les types de données Cassandra pris en charge, consultez[Support des types de données Cassandra](cassandra-apis.md#cassandra-data-type).
Vous pouvez utiliser des types définis par l'utilisateur (UDTs) dans Amazon Keyspaces pour organiser les données de manière plus efficace. Par exemple, vous pouvez créer UDTs avec des collections imbriquées, ce qui vous permet d'implémenter une modélisation de données plus complexe dans vos applications. Vous pouvez également utiliser le mot clé frozen pour définir UDTs.
UDTs sont liés à un espace de touches et disponibles pour toutes les tables et UDTs dans le même espace de touches. Vous pouvez créer des espaces UDTs clés à région unique ou multirégionale.
Vous pouvez créer de nouvelles tables ou modifier des tables existantes et ajouter de nouvelles colonnes utilisant un UDT. Pour créer un UDT avec un UDT imbriqué, l'UDT imbriqué doit être figé.
Pour connaître le nombre de valeurs UDTs prises en charge par espace de touches, les niveaux d'imbrication pris en charge et les autres valeurs par défaut et quotas associés UDTs, voir. [Quotas et valeurs par défaut pour les types définis par l'utilisateur (UDTs) dans Amazon Keyspaces](quotas.md#quotas-udts)
Pour plus d'informations sur le calcul de la taille codée de UDTs, voir[Estimer la taille codée des valeurs de données en fonction du type de données](calculating-row-size.md#calculating-row-size-data-types).
Pour plus d'informations sur la syntaxe CQL, consultez[Types définis par l'utilisateur () UDTs](cql.ddl.type.md).
Pour en savoir plus sur la restauration instantanée UDTs et à un moment donné, consultez[Restauration PITR de tables avec des types définis par l'utilisateur () UDTs](PointInTimeRecovery_HowItWorks.md#howitworks_backup_udt).
**Topics**
+ [Configuration des autorisations](configure-udt-permissions.md)
+ [Création d'un UDT](keyspaces-create-udt.md)
+ [Afficher UDTs](keyspaces-view-udt.md)
+ [Supprimer un UDT](keyspaces-delete-udt.md)
# Configurer les autorisations pour travailler avec des types définis par l'utilisateur (UDTs) dans Amazon Keyspaces
Comme les tables, UDTs elles sont liées à un espace de touches spécifique. Mais contrairement aux tables, vous ne pouvez pas définir d'autorisations directement pour UDTs. UDTs ne sont pas considérées comme des ressources dans AWS et ne possèdent aucun identifiant unique au format Amazon Resource Name (ARN). Pour donner à un IAM principal les autorisations nécessaires pour effectuer des actions spécifiques sur un UDT, vous devez définir des autorisations pour l'espace de touches auquel l'UDT est lié. Pour travailler UDTs dans des espaces clés multirégionaux, des autorisations supplémentaires sont requises.
Pour pouvoir créer, afficher ou supprimer, le principal UDTs, par exemple un utilisateur ou un rôle IAM, a besoin des mêmes autorisations que celles requises pour effectuer la même action sur l'espace clé auquel l'UDT est lié.
Pour plus d'informations sur Gestion des identités et des accès AWS, voir[Gestion des identités et des accès AWS pour Amazon Keyspaces](security-iam.md).
## Autorisations pour créer un UDT
Pour créer un UDT dans un espace clé à région unique, le principal a besoin d'`Create`autorisations pour l'espace clé.
La politique IAM suivante en est un exemple.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "cassandra:Create",
"Resource": [
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/"
]
}
]
}
```
Pour créer un UDT dans un espace clé multirégional, en plus des autorisations, le principal doit également disposer d'`Create`autorisations pour effectuer l'action dans l'espace de touches `CreateMultiRegionResource` spécifié.
La politique IAM suivante en est un exemple.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [ "cassandra:Create", "cassandra:CreateMultiRegionResource" ],
"Resource": [
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/"
]
}
]
}
```
## Autorisations pour afficher un UDT
Pour afficher ou répertorier UDTs dans un espace clé à région unique, le principal doit disposer d'autorisations de lecture pour l'espace clé du système. Pour de plus amples informations, veuillez consulter [`system_schema_mcs`](working-with-keyspaces.md#keyspace_system_schema_mcs).
La politique IAM suivante en est un exemple.
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":"cassandra:Select",
"Resource":[
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*"
]
}
]
}
```
Pour afficher ou UDTs répertorier un espace clé multirégional, le principal a besoin d'autorisations pour les actions `SELECT` et `SelectMultiRegionResource` pour l'espace clé du système. Pour de plus amples informations, veuillez consulter [`system_multiregion_info`](working-with-keyspaces.md#keyspace_system_multiregion_info).
La politique IAM suivante en est un exemple.
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action": ["cassandra:Select", "cassandra:SelectMultiRegionResource"],
"Resource":[
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*"
]
}
]
}
```
## Autorisations pour supprimer un UDT
Pour supprimer un UDT d'un espace de touches à région unique, le principal a besoin d'autorisations pour effectuer l'`Drop`action pour l'espace de touches spécifié.
La politique IAM suivante en est un exemple.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "cassandra:Drop",
"Resource": [
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/"
]
}
]
}
```
Pour supprimer un UDT d'un espace de touches multirégional, le principal a besoin d'autorisations pour l'`Drop`action et pour l'action pour l'`DropMultiRegionResource`espace de touches spécifié.
La politique IAM suivante en est un exemple.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [ "cassandra:Drop", "cassandra:DropMultiRegionResource" ],
"Resource": [
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/"
]
}
]
}
```
# Création d'un type défini par l'utilisateur (UDT) dans Amazon Keyspaces
Pour créer un UDT dans un espace de touches à région unique, vous pouvez utiliser l'`CREATE TYPE`instruction dans CQL, la `create-type` commande associée à, ou la console AWS CLI.
Les noms UDT doivent contenir 48 caractères ou moins, doivent commencer par un caractère alphabétique et ne peuvent contenir que des caractères alphanumériques et des traits de soulignement. Amazon Keyspaces convertit automatiquement les majuscules en minuscules.
Vous pouvez également déclarer un nom UDT entre guillemets doubles. Lorsque vous déclarez un nom UDT entre guillemets doubles, Amazon Keyspaces préserve les majuscules et autorise les caractères spéciaux.
Vous pouvez également utiliser des guillemets doubles dans le nom lorsque vous créez l’UDT, mais vous devez échapper chaque guillemet double par un guillemet double supplémentaire.
La table suivante présente des exemples de noms UDT autorisés. La première colonne indique comment saisir le nom lorsque vous créez le type et la deuxième indique comment Amazon Keyspaces formate le nom en interne. Amazon Keyspaces s’attend à ce que le nom formaté pour des opérations ressemble à `GetType`.
| Nom saisi | Nom formaté | Remarque |
| --- | --- | --- |
| MY\$1UDT | my\$1udt | Sans guillemets doubles, Amazon Keyspaces convertit tous les caractères majuscules en minuscules. |
| "MY\$1UDT" | MY\$1UDT | Avec les guillemets doubles, Amazon Keyspaces respecte les majuscules et supprime les guillemets doubles du nom formaté. |
| "1234" | 1234 | Avec des guillemets doubles, le nom peut commencer par un chiffre, et Amazon Keyspaces supprime les guillemets doubles du nom formaté. |
| "Special\$1Ch@r@cters<>\$1\$1" | Special\$1Ch@r@cters<>\$1\$1 | Avec les guillemets doubles, le nom peut contenir des caractères spéciaux, et Amazon Keyspaces supprime les guillemets doubles du nom formaté. |
| "nested""""""quotes" | nested"""quotes | Amazon Keyspaces supprime les guillemets doubles extérieurs et les guillemets doubles d’échappement du nom formaté. |
------
#### [ Console ]
**Créez un type défini par l'utilisateur (UDT) avec la console Amazon Keyspaces**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le volet de navigation, choisissez **Keyspaces**, puis choisissez un keyspace dans la liste.
1. Cliquez sur l'onglet **UDTs**.
1. Choisissez **Create UDT**
1. Sous **Détails de l'UDT**, entrez le nom de l'UDT. Dans **les champs UDT**, vous définissez le schéma de l'UDT.
1. Pour terminer, choisissez **Create UDT.**
------
#### [ Cassandra Query Language (CQL) ]
**Création d'un type défini par l'utilisateur (UDT) avec CQL**
Dans cet exemple, nous créons une nouvelle version du tableau des récompenses littéraires utilisé dans[Création d'un tableau dans Amazon Keyspaces](getting-started.tables.md). Dans ce tableau, nous enregistrons toutes les récompenses qu'un auteur reçoit pour un livre donné. Nous en créons deux UDTs qui sont imbriqués et contiennent des informations sur le livre primé.
1. Créez un keyspace avec le nom`catalog`.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
1. Créez le premier type. Ce type stocke les codes *BISAC*, qui sont utilisés pour définir le genre des livres. Un code BISAC se compose d'un code alphanumérique et d'un maximum de quatre domaines thématiques.
```
CREATE TYPE catalog.bisac (
bisac_code text,
subject1 text,
subject2 text,
subject3 text,
subject4 text
);
```
1. Créez un deuxième type de prix du livre utilisant le premier UDT. L'UDT imbriqué doit être gelé.
```
CREATE TYPE catalog.book (
award_title text,
book_title text,
publication_date date,
page_count int,
ISBN text,
genre FROZEN
);
```
1. Créez un tableau avec une colonne pour le nom de l'auteur et utilisez un type de liste pour les prix du livre. Notez que l'UDT utilisé dans la liste doit être figé.
```
CREATE TABLE catalog.authors (
author_name text PRIMARY KEY,
awards list >
);
```
1. Dans cette étape, nous insérons une ligne de données dans le nouveau tableau.
```
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. Dans la dernière étape, nous lisons les données du tableau.
```
SELECT * FROM catalog.authors;
```
Le résultat de la commande doit ressembler à ceci.
```
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)
```
Pour plus d'informations sur la syntaxe CQL, consultez[CREATE TYPE](cql.ddl.type.md#cql.ddl.type.create).
------
#### [ CLI ]
**Créez un type défini par l'utilisateur (UDT) avec le AWS CLI**
1. Pour créer un type, vous pouvez utiliser la syntaxe suivante.
```
aws keyspaces create-type
--keyspace-name 'my_keyspace'
--type-name 'my_udt'
--field-definitions
'[
{"name" : "field1", "type" : "int"},
{"name" : "field2", "type" : "text"}
]'
```
1. Le résultat de cette commande ressemble à celui de cet exemple. Notez que cela `typeName` renvoie le nom formaté de l'UDT.
```
{
"keyspaceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/",
"typeName": "my_udt"
}
```
------
# Afficher les types définis par l'utilisateur (UDTs) dans Amazon Keyspaces
Pour tout afficher ou répertorier UDTs dans un espace de touches à région unique, vous pouvez interroger la table `system_schema_mcs.types` dans l'espace de touches du système à l'aide d'une instruction dans CQL, ou utiliser `list-type` les commandes `get-type` et avec le ou la console AWS CLI.
Quelle que soit l'option, le principal IAM a besoin d'autorisations de lecture sur l'espace de touches du système. Pour de plus amples informations, veuillez consulter [Configurer les autorisations pour travailler avec des types définis par l'utilisateur (UDTs) dans Amazon Keyspaces](configure-udt-permissions.md).
------
#### [ Console ]
**Afficher les types définis par l'utilisateur (UDT) avec la console Amazon Keyspaces**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le volet de navigation, choisissez **Keyspaces**, puis choisissez un keyspace dans la liste.
1. Choisissez l'**UDTs**onglet pour consulter la liste de tous les éléments présents UDTs dans l'espace clavier.
1. **Pour examiner un UDT en détail, choisissez-en un dans la liste.**
1. Dans l'onglet **Schéma**, vous pouvez consulter le schéma. Dans l'onglet **Utilisé dans**, vous pouvez voir si cet UDT est utilisé dans des tables ou autres UDTs. Notez que vous ne pouvez supprimer UDTs que ceux qui ne sont pas utilisés par des tables ou par d'autres UDTs.
------
#### [ Cassandra Query Language (CQL) ]
**Afficher les types définis par l'utilisateur (UDTs) d'un espace de touches à région unique avec CQL**
1. Pour voir les types disponibles dans un espace de touches donné, vous pouvez utiliser l'instruction suivante.
```
SELECT type_name
FROM system_schema_mcs.types
WHERE keyspace_name = 'my_keyspace';
```
1. Pour afficher les détails d'un type spécifique, vous pouvez utiliser l'instruction suivante.
```
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. Vous pouvez répertorier tout UDTs ce qui existe dans le compte en utilisant`DESC TYPE`.
```
DESC TYPES;
Keyspace my_keyspace
---------------------------
my_udt1 my_udt2
Keyspace my_keyspace2
---------------------------
my_udt1
```
1. Vous pouvez tout répertorier UDTs dans l'espace de touches actuellement sélectionné en utilisant`DESC TYPE`.
```
USE my_keyspace;
my_keyspace DESC TYPES;
my_udt1 my_udt2
```
1. Pour tout répertorier UDTs dans un espace de touches multirégional, vous pouvez interroger la table système `types` dans l'`system_multiregion_info`espace de touches. La requête suivante en est un exemple.
```
SELECT keyspace_name, type_name, region, status FROM system_multiregion_info.types WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
Le résultat de cette commande ressemble à ceci.
```
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 ]
**Affichez les types définis par l'utilisateur (UDTs) avec le AWS CLI**
1. Pour répertorier les types disponibles dans un espace de touches, vous pouvez utiliser la `list-types` commande.
```
aws keyspaces list-types
--keyspace-name 'my_keyspace'
```
Le résultat de cette commande ressemble à celui de cet exemple.
```
{
"types": [
"my_udt",
"parent_udt"
]
}
```
1. Pour afficher les détails d'un type donné, vous pouvez utiliser la `get-type` commande.
```
aws keyspaces get-type
--type-name 'my_udt'
--keyspace-name 'my_keyspace'
```
Le résultat de cette commande ressemble à celui de cet exemple.
```
{
"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/"
}
```
------
# Supprimer un type défini par l'utilisateur (UDT) dans Amazon Keyspaces
Pour supprimer un UDT dans un espace de touches, vous pouvez utiliser l'`DROP TYPE`instruction dans CQL, la `delete-type` commande associée à AWS CLI, ou la console.
------
#### [ Console ]
**Supprimer un type défini par l'utilisateur (UDT) avec la console Amazon Keyspaces**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le volet de navigation, choisissez **Keyspaces**, puis choisissez un keyspace dans la liste.
1. Cliquez sur l'onglet **UDTs**.
1. Choisissez l'UDT que vous souhaitez supprimer. Sur **Used in**, vous pouvez confirmer que le type que vous souhaitez supprimer n'est pas actuellement utilisé par une table ou un autre UDT.
1. Choisissez **Supprimer** au-dessus du **résumé**.
1. Tapez `Delete` dans la boîte de dialogue qui apparaît, puis choisissez **Supprimer l'UDT.**
------
#### [ Cassandra Query Language (CQL) ]
**Supprimer un type défini par l'utilisateur (UDT) avec CQL**
+ Pour supprimer un type, vous pouvez utiliser l'instruction suivante.
```
DROP TYPE my_keyspace.my_udt;
```
Pour plus d'informations sur la syntaxe CQL, consultez[DROP TYPE](cql.ddl.type.md#cql.ddl.type.drop).
------
#### [ CLI ]
**Supprimez un type défini par l'utilisateur (UDT) avec le AWS CLI**
1. Pour supprimer un type, vous pouvez utiliser la commande suivante.
```
aws keyspaces delete-type
--keyspace-name 'my_keyspace'
--type-name 'my_udt'
```
1. Le résultat de la commande ressemble à celui de cet exemple.
```
{
"keyspaceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/",
"typeName": "my_udt"
}
```
------