Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Crea una tabella in Amazon Keyspaces
In questa sezione, crei una tabella utilizzando la console o `cqlsh` il. AWS CLI
Una tabella è il luogo in cui i dati vengono organizzati e archiviati. La chiave primaria della tabella determina il modo in cui i dati vengono partizionati nella tabella. La chiave primaria è composta da una chiave di partizione richiesta e da una o più colonne di clustering opzionali. I valori combinati che compongono la chiave primaria devono essere univoci per tutti i dati della tabella. Per ulteriori informazioni sulle tabelle, consulta i seguenti argomenti:
+ Progettazione delle chiavi di partizione: [Come utilizzare le chiavi di partizione in modo efficace in Amazon Keyspaces](bp-partition-key-design.md)
+ Lavorare con le tabelle: [Verifica lo stato di creazione della tabella in Amazon Keyspaces](tables-create.md)
+ Istruzioni DDL nel riferimento al linguaggio CQL: [Tabelle](cql.ddl.table.md)
+ Gestione delle risorse delle tabelle: [Gestione delle risorse serverless in Amazon Keyspaces (per Apache Cassandra)](serverless_resource_management.md)
+ Monitoraggio dell'utilizzo delle risorse della tabella: [Monitoraggio di Amazon Keyspaces con Amazon CloudWatch](monitoring-cloudwatch.md)
+ [Quote per Amazon Keyspaces (per Apache Cassandra)](quotas.md)
Quando si crea una tabella, si specifica quanto segue:
+ Nome della tabella.
+ Il nome e il tipo di dati di ogni colonna della tabella.
+ La chiave primaria per la tabella.
+ **Chiave di partizione**: obbligatoria
+ **Colonne di raggruppamento: facoltativo**
Utilizzare la procedura seguente per creare una tabella con le colonne, i tipi di dati, le chiavi di partizione e le colonne di clustering specificati.
## Utilizzo della console
La procedura seguente crea la tabella `book_awards` con queste colonne e questi tipi di dati.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Per creare una tabella utilizzando la console**
1. [Accedi a e apri Console di gestione AWS la console Amazon Keyspaces a casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. Nel riquadro di navigazione, scegli **Keyspaces**.
1. Scegli `catalog` come spazio chiave in cui vuoi creare questa tabella.
1. Scegliere **Create table (Crea tabella)**.
1. Nella casella **Nome tabella**, inserisci **book\$1awards** un nome per la tua tabella.
**Vincoli relativi al nome:**
+ Il nome non può essere vuoto.
+ Caratteri consentiti: caratteri alfanumerici e trattino basso (). `_`
+ La lunghezza massima è di 48 caratteri.
1. Nella sezione **Colonne**, ripeti i passaggi seguenti per ogni colonna che desideri aggiungere a questa tabella.
Aggiungi le colonne e i tipi di dati seguenti.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
1. **Nome**: inserisci un nome per la colonna.
**Vincoli relativi al nome:**
+ Il nome non può essere vuoto.
+ Caratteri consentiti: caratteri alfanumerici e trattino basso (). `_`
+ La lunghezza massima è di 48 caratteri.
1. **Tipo**: nell'elenco dei tipi di dati, scegli il tipo di dati per questa colonna.
1. Per aggiungere un'altra colonna, scegli **Aggiungi colonna**.
1. Scegli `award` e `year` immetti le chiavi di partizione in **Partition** Key. È necessaria una chiave di partizione per ogni tabella. Una chiave di partizione può essere composta da una o più colonne.
1. Aggiungi `category` e `rank` come colonne di **clustering.** Le colonne di clustering sono opzionali e determinano l'ordinamento all'interno di ciascuna partizione.
1. Per aggiungere una colonna di clustering, scegli **Aggiungi** colonna di clustering.
1. **Nell'elenco **Colonna**, scegli la categoria.** Nell'elenco **Ordine**, scegliete **ASC** per ordinare in ordine crescente i valori di questa colonna. (Scegliete **DESC** per l'ordine decrescente).
1. **Quindi seleziona **Aggiungi colonna di raggruppamento** e scegli classifica.**
1. Nella sezione **Impostazioni della tabella**, scegli **Impostazioni predefinite**.
1. Scegliere **Create table (Crea tabella)**.
1. Verifica che la tabella sia stata creata.
1. Nel pannello di navigazione, seleziona **Tabelle**.
1. Verifica che la tua tabella sia nell'elenco delle tabelle.
1. Scegli il nome del tuo tavolo.
1. Verifica che tutte le colonne e i tipi di dati siano corretti.
**Nota**
Le colonne potrebbero non essere elencate nello stesso ordine in cui le hai aggiunte alla tabella.
## Usare CQL
Questa procedura crea una tabella con le seguenti colonne e tipi di dati utilizzando CQL. `award`Le colonne `year` e sono chiavi di partizione con `category` e `rank` come colonne di clustering, insieme costituiscono la chiave primaria della tabella.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Per creare una tabella utilizzando CQL**
1. Apri AWS CloudShell e connettiti ad Amazon Keyspaces utilizzando il seguente comando. Assicurati di eseguire l'aggiornamento *us-east-1* con la tua regione.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
L'output di quel comando dovrebbe essere simile a questo.
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
```
1. Al prompt del keyspace (`cqlsh:keyspace_name>`), create la tabella inserendo il seguente codice nella finestra di comando.
```
CREATE TABLE catalog.book_awards (
year int,
award text,
rank int,
category text,
book_title text,
author text,
publisher text,
PRIMARY KEY ((year, award), category, rank)
);
```
**Nota**
`ASC`è l'ordine di clustering predefinito. È inoltre possibile specificare `DESC` l'ordine decrescente.
Nota che `year` e `award` sono colonne chiave di partizione. Quindi, `category` e `rank` sono le colonne di raggruppamento ordinate in ordine crescente (). `ASC` Insieme, queste colonne costituiscono la chiave principale della tabella.
1. Verifica che la tabella sia stata creata.
```
SELECT * from system_schema.tables WHERE keyspace_name='catalog.book_awards' ;
```
L'output dovrebbe essere simile a questo.
```
keyspace_name | table_name | bloom_filter_fp_chance | caching | cdc | comment | compaction | compression | crc_check_chance | dclocal_read_repair_chance | default_time_to_live | extensions | flags | gc_grace_seconds | id | max_index_interval | memtable_flush_period_in_ms | min_index_interval | read_repair_chance | speculative_retry
---------------+------------+------------------------+---------+-----+---------+------------+-------------+------------------+----------------------------+----------------------+------------+-------+------------------+----+--------------------+-----------------------------+--------------------+--------------------+-------------------
(0 rows)
```
1. Verifica la struttura della tabella.
```
SELECT * FROM system_schema.columns WHERE keyspace_name = 'catalog' AND table_name = 'book_awards';
```
L'output di questa istruzione dovrebbe essere simile a quello di questo esempio.
```
keyspace_name | table_name | column_name | clustering_order | column_name_bytes | kind | position | type
---------------+-------------+-------------+------------------+------------------------+---------------+----------+------
catalog | book_awards | year | none | 0x79656172 | partition_key | 0 | int
catalog | book_awards | award | none | 0x6177617264 | partition_key | 1 | text
catalog | book_awards | category | asc | 0x63617465676f7279 | clustering | 0 | text
catalog | book_awards | rank | asc | 0x72616e6b | clustering | 1 | int
catalog | book_awards | author | none | 0x617574686f72 | regular | -1 | text
catalog | book_awards | book_title | none | 0x626f6f6b5f7469746c65 | regular | -1 | text
catalog | book_awards | publisher | none | 0x7075626c6973686572 | regular | -1 | text
(7 rows)
```
Verifica che tutte le colonne e i tipi di dati siano quelli previsti. L'ordine delle colonne potrebbe essere diverso da quello dell'`CREATE`istruzione.
## Usando il AWS CLI
Questa procedura crea una tabella con le colonne e i tipi di dati seguenti utilizzando AWS CLI. Le `award` colonne `year` and costituiscono la chiave di partizione con `category` e `rank` come colonne di clustering.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Per creare una tabella utilizzando il AWS CLI**
Il comando seguente crea una tabella con il nome *book\$1awards*. La chiave di partizione della tabella è costituita dalle colonne `year` `award` e la chiave di clustering è costituita dalle colonne `category` ed `rank` entrambe le colonne di clustering utilizzano l'ordinamento crescente. (Per facilitare la leggibilità, il `schema-definition` comando table create in questa sezione è suddiviso in righe separate.)
1. È possibile creare la tabella utilizzando la seguente istruzione.
```
aws keyspaces create-table --keyspace-name 'catalog' \
--table-name 'book_awards' \
--schema-definition 'allColumns=[{name=year,type=int},{name=award,type=text},{name=rank,type=int},
{name=category,type=text}, {name=author,type=text},{name=book_title,type=text},{name=publisher,type=text}],
partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]'
```
Questo comando produce l'output seguente.
```
{
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards"
}
```
1. Per confermare i metadati e le proprietà della tabella, è possibile utilizzare il seguente comando.
```
aws keyspaces get-table --keyspace-name 'catalog' --table-name 'book_awards'
```
Questo comando restituisce il seguente output.
```
{
"keyspaceName": "catalog",
"tableName": "book_awards",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards",
"creationTimestamp": "2024-07-11T15:12:55.571000+00:00",
"status": "ACTIVE",
"schemaDefinition": {
"allColumns": [
{
"name": "year",
"type": "int"
},
{
"name": "award",
"type": "text"
},
{
"name": "category",
"type": "text"
},
{
"name": "rank",
"type": "int"
},
{
"name": "author",
"type": "text"
},
{
"name": "book_title",
"type": "text"
},
{
"name": "publisher",
"type": "text"
}
],
"partitionKeys": [
{
"name": "year"
},
{
"name": "award"
}
],
"clusteringKeys": [
{
"name": "category",
"orderBy": "ASC"
},
{
"name": "rank",
"orderBy": "ASC"
}
],
"staticColumns": []
},
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": "2024-07-11T15:12:55.571000+00:00"
},
"encryptionSpecification": {
"type": "AWS_OWNED_KMS_KEY"
},
"pointInTimeRecovery": {
"status": "DISABLED"
},
"defaultTimeToLive": 0,
"comment": {
"message": ""
},
"replicaSpecifications": []
}
```
Per eseguire operazioni CRUD (creazione, lettura, aggiornamento ed eliminazione) sui dati della tabella, procedi a. [Crea, leggi, aggiorna ed elimina dati (CRUD) utilizzando CQL in Amazon Keyspaces](getting-started.dml.md)