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à.
# Guida introduttiva ad Amazon Keyspaces (per Apache Cassandra)
Se non conosci Apache Cassandra e Amazon Keyspaces, questo tutorial ti guida nell'installazione dei programmi e degli strumenti necessari per utilizzare Amazon Keyspaces con successo. Imparerai come creare uno spazio chiave e una tabella utilizzando Cassandra Query Language (CQL), the o the (). Console di gestione AWS AWS Command Line Interface AWS CLI Utilizza quindi Cassandra Query Language (CQL) per eseguire operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD) sui dati nella tabella Amazon Keyspaces.
Questo tutorial illustra i seguenti passaggi.
+ **Prerequisiti**: prima di iniziare il tutorial, segui le istruzioni di AWS configurazione per registrarti AWS e creare un utente IAM con accesso ad Amazon Keyspaces. Quindi configuri e. `cqhsh-expansion` AWS CloudShell In alternativa, puoi usare il AWS CLI per creare risorse in Amazon Keyspaces.
+ **Passaggio 1: Crea uno spazio di chiavi e una tabella**: in questa sezione, creerai uno spazio di chiavi denominato «catalog» e al suo interno una tabella denominata «book\$1awards». Specificherai le colonne, i tipi di dati, la chiave di partizione e la colonna di clustering della tabella utilizzando CQL o. Console di gestione AWS AWS CLI
+ **Passaggio 2: Esegui le operazioni CRUD**: qui utilizzerai l'`cqlsh-expansion`in CloudShell per inserire, leggere, aggiornare ed eliminare i dati nella tabella «book\$1awards». Imparerai come utilizzare varie istruzioni CQL come SELECT, INSERT, UPDATE e DELETE e come esercitarti a filtrare e modificare i dati.
+ **Passaggio 3: Pulisci le risorse**: per evitare di incorrere in addebiti per le risorse non utilizzate, questa sezione ti guida nell'eliminazione della tabella «book\$1awards» e dello spazio chiave «catalog» utilizzando la console, CQL o il. AWS CLI
Per i tutorial sulla connessione programmatica ad Amazon Keyspaces utilizzando diversi driver client Apache Cassandra, consulta. [Utilizzo di un driver client Cassandra per accedere ad Amazon Keyspaces a livello di codice](programmatic.drivers.md) Per esempi di codice che utilizzano metodi diversi AWS SDKs, consulta [Esempi di codice per l'utilizzo di Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/latest/devguide/service_code_examples.html). AWS SDKs
**Topics**
+ [Prerequisiti e considerazioni del tutorial](getting-started.before-you-begin.md)
+ [Crea uno spazio chiave in Amazon Keyspaces](getting-started.keyspaces.md)
+ [Verifica lo stato di creazione del keyspace in Amazon Keyspaces](keyspaces-create.md)
+ [Crea una tabella in Amazon Keyspaces](getting-started.tables.md)
+ [Verifica lo stato di creazione della tabella in Amazon Keyspaces](tables-create.md)
+ [Crea, leggi, aggiorna ed elimina dati (CRUD) utilizzando CQL in Amazon Keyspaces](getting-started.dml.md)
+ [Eliminare una tabella in Amazon Keyspaces](getting-started.clean-up.table.md)
+ [Eliminare un keyspace in Amazon Keyspaces](getting-started.clean-up.keyspace.md)
# Prerequisiti e considerazioni del tutorial
Prima di iniziare a usare Amazon Keyspaces, segui le istruzioni di AWS configurazione riportate in. [Accesso ad Amazon Keyspaces (per Apache Cassandra)](accessing.md) Questi passaggi includono la registrazione AWS e la creazione di un utente AWS Identity and Access Management (IAM) con accesso ad Amazon Keyspaces.
Per completare tutti i passaggi del tutorial, devi `cqlsh` installarlo. Puoi seguire le istruzioni di configurazione all'indirizzo[Utilizzo `cqlsh` per connettersi ad Amazon Keyspaces](programmatic.cqlsh.md).
Per accedere ad Amazon Keyspaces utilizzando `cqlsh` o AWS CLI, consigliamo di utilizzare. AWS CloudShell CloudShellè una shell preautenticata basata su browser che puoi avviare direttamente da. Console di gestione AWS Puoi eseguire comandi AWS Command Line Interface (AWS CLI) su Amazon Keyspaces usando la tua shell preferita (Bash PowerShell o Z shell). Per utilizzarlo`cqlsh`, devi installare. `cqlsh-expansion` Per le istruzioni di `cqlsh-expansion` installazione, vedere[Utilizzo di `cqlsh-expansion` per connettersi ad Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh). Per ulteriori informazioni su CloudShell see[Utilizzo AWS CloudShell per accedere ad Amazon Keyspaces](using-aws-with-cloudshell.md).
Per utilizzare l'opzione AWS CLI per creare, visualizzare ed eliminare risorse in Amazon Keyspaces, segui le istruzioni di configurazione disponibili all'indirizzo. [Scaricamento e configurazione di AWS CLI](access.cli.md#access.cli.installcli)
Dopo aver completato i passaggi preliminari, procedi a. [Crea uno spazio chiave in Amazon Keyspaces](getting-started.keyspaces.md)
# Crea uno spazio chiave in Amazon Keyspaces
In questa sezione, crei uno spazio di chiavi utilizzando la `cqlsh` console o. AWS CLI
**Nota**
Prima di iniziare, assicuratevi di aver configurato tutti i [prerequisiti del tutorial](getting-started.before-you-begin.md).
Un *keyspace* raggruppa le tabelle correlate che sono rilevanti per una o più applicazioni. Un keyspace contiene una o più tabelle e definisce la strategia di replica per tutte le tabelle che contiene. Per ulteriori informazioni sugli spazi chiave, consultate i seguenti argomenti:
+ Istruzioni DDL (Data Definition Language) nel riferimento al linguaggio CQL: [Keyspaces](cql.ddl.keyspace.md)
+ [Quote per Amazon Keyspaces (per Apache Cassandra)](quotas.md)
In questo tutorial creiamo uno spazio chiave a regione singola e la strategia di replica dello spazio chiave è. `SingleRegionStrategy` Utilizzando`SingleRegionStrategy`, Amazon Keyspaces replica i dati su tre [zone di disponibilità](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/) in una. Regione AWS Per informazioni su come creare spazi chiave multiregionali, consulta. [Crea uno spazio chiave multiregionale in Amazon Keyspaces](keyspaces-mrr-create.md)
## Utilizzo della console
**Per creare uno spazio chiave 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 **Crea spazio chiave**.
1. Nella casella **Nome keyspace**, immetti **catalog** come nome per il tuo keyspace.
**Vincoli relativi al nome:**
+ Il nome non può essere vuoto.
+ Caratteri consentiti: caratteri alfanumerici e trattino basso (). `_`
+ La lunghezza massima è di 48 caratteri.
1. Sotto **Regioni AWS**, conferma che la **replica a regione singola è la** strategia di replica per il keyspace.
1. **Per creare lo spazio chiave, scegli Crea spazio chiave.**
1. Verifica che lo spazio chiave sia `catalog` stato creato effettuando le seguenti operazioni:
1. Nel riquadro di navigazione, scegli **Keyspaces**.
1. Individua il tuo spazio chiave `catalog` nell'elenco degli spazi chiave.
## Usare CQL
La procedura seguente crea uno spazio chiave utilizzando CQL.
**Per creare uno spazio chiave 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. Crea il tuo keyspace usando il seguente comando CQL.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
`SingleRegionStrategy`utilizza un fattore di replica pari a tre e replica i dati in tre zone di AWS disponibilità della propria regione.
**Nota**
Amazon Keyspaces imposta per impostazione predefinita tutti gli input in lettere minuscole, a meno che non vengano racchiusi tra virgolette.
1. Verifica che il tuo keyspace sia stato creato.
```
SELECT * from system_schema.keyspaces;
```
L'output di questo comando dovrebbe essere simile a questo.
```
cqlsh> SELECT * from system_schema.keyspaces;
keyspace_name | durable_writes | replication
-------------------------+----------------+-------------------------------------------------------------------------------------
system_schema | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_schema_mcs | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_multiregion_info | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
catalog | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
(5 rows)
```
## Usando il AWS CLI
La procedura seguente crea uno spazio chiave utilizzando. AWS CLI
**Per creare uno spazio chiave utilizzando il AWS CLI**
1. Per confermare che l'ambiente è configurato, è possibile eseguire il seguente comando in CloudShell.
```
aws keyspaces help
```
1. Create il vostro keyspace utilizzando la seguente AWS CLI istruzione.
```
aws keyspaces create-keyspace --keyspace-name 'catalog'
```
1. Verifica che il tuo keyspace sia stato creato con la seguente dichiarazione AWS CLI
```
aws keyspaces get-keyspace --keyspace-name 'catalog'
```
L'output di questo comando dovrebbe essere simile a quello di questo esempio.
```
{
"keyspaceName": "catalog",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/",
"replicationStrategy": "SINGLE_REGION"
}
```
# Verifica lo stato di creazione del keyspace in Amazon Keyspaces
Amazon Keyspaces esegue operazioni DDL (Data Definition Language), come la creazione e l'eliminazione di keyspace, in modo asincrono.
Puoi monitorare lo stato di creazione di nuovi keyspace in Console di gestione AWS, che indica quando uno spazio chiave è in sospeso o attivo. È inoltre possibile monitorare lo stato di creazione di un nuovo keyspace a livello di codice utilizzando lo spazio chiave. `system_schema_mcs` Uno spazio chiave diventa visibile nella `system_schema_mcs` `keyspaces` tabella quando è pronto per l'uso.
Il modello di progettazione consigliato per verificare quando un nuovo keyspace è pronto per l'uso consiste nel polling della `system_schema_mcs` `keyspaces` tabella Amazon Keyspaces (system\$1schema\$1mcs.\$1). Per un elenco di istruzioni DDL per gli spazi chiave, consulta la sezione nella guida di riferimento al linguaggio CQL. [Keyspaces](cql.ddl.keyspace.md)
La seguente query mostra se un keyspace è stato creato con successo.
```
SELECT * FROM system_schema_mcs.keyspaces WHERE keyspace_name = 'mykeyspace';
```
Per uno spazio chiave che è stato creato correttamente, l'output della query è simile al seguente.
```
keyspace_name | durable_writes | replication
--------------+-----------------+--------------
mykeyspace | true |{...} 1 item
```
# 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)
# Verifica lo stato di creazione della tabella in Amazon Keyspaces
Amazon Keyspaces esegue operazioni DDL (Data Definition Language), come la creazione e l'eliminazione di tabelle, in modo asincrono. Puoi monitorare lo stato di creazione di nuove tabelle in Console di gestione AWS, che indica quando una tabella è in sospeso o attiva. È inoltre possibile monitorare lo stato di creazione di una nuova tabella a livello di codice utilizzando la tabella dello schema di sistema.
Una tabella mostra come attiva nello schema di sistema quando è pronta per l'uso. Il modello di progettazione consigliato per verificare quando una nuova tabella è pronta per l'uso consiste nel polling delle tabelle `system_schema_mcs.*` dello schema del sistema Amazon Keyspaces (). Per un elenco di istruzioni DDL per le tabelle, consulta la [Tabelle](cql.ddl.table.md) sezione nella guida di riferimento al linguaggio CQL.
La seguente query mostra lo stato di una tabella.
```
SELECT keyspace_name, table_name, status FROM system_schema_mcs.tables WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
Per una tabella ancora in fase di creazione e in sospeso, l'output della query è simile al seguente.
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | CREATING
```
Per una tabella che è stata creata correttamente ed è attiva, l'output della query è simile al seguente.
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | ACTIVE
```
# Crea, leggi, aggiorna ed elimina dati (CRUD) utilizzando CQL in Amazon Keyspaces
In questa fase del tutorial, imparerai come inserire, leggere, aggiornare ed eliminare dati in una tabella Amazon Keyspaces utilizzando istruzioni CQL Data Manipulation Language (DML). In Amazon Keyspaces, puoi creare solo istruzioni DML in linguaggio CQL. In questo tutorial, ti eserciterai a eseguire istruzioni DML usando with in the`cqlsh-expansion`. [AWS CloudShell](using-aws-with-cloudshell.md) Console di gestione AWS
+ **Inserimento di dati**: questa sezione tratta l'inserimento di record singoli o multipli in una tabella utilizzando l'istruzione. `INSERT` Imparerai come caricare dati da un file CSV e verificare gli inserimenti corretti utilizzando le query. `SELECT`
+ **Lettura dei dati**: qui esaminerai diverse varianti dell'`SELECT`istruzione per recuperare i dati da una tabella. Gli argomenti includono la selezione di tutti i dati, la selezione di colonne specifiche, il filtraggio delle righe in base alle condizioni utilizzando la `WHERE` clausola e la comprensione di condizioni semplici e composte.
+ **Aggiornamento dei dati**: in questa sezione imparerai come modificare i dati esistenti in una tabella utilizzando l'`UPDATE`istruzione. Ti eserciterai ad aggiornare colonne singole e multiple comprendendo al contempo le restrizioni relative all'aggiornamento delle colonne chiave primarie.
+ **Eliminazione dei dati**: l'ultima sezione riguarda l'eliminazione dei dati da una tabella utilizzando l'`DELETE`istruzione. Imparerai come eliminare celle specifiche, intere righe e le implicazioni dell'eliminazione dei dati rispetto all'eliminazione dell'intera tabella o dello spazio chiave.
Nel corso del tutorial, troverai esempi, suggerimenti e opportunità per esercitarti a scrivere le tue query CQL per vari scenari.
**Topics**
+ [Inserimento e caricamento di dati in una tabella Amazon Keyspaces](getting-started.dml.create.md)
+ [Leggi i dati da una tabella utilizzando l'`SELECT`istruzione CQL in Amazon Keyspaces](getting-started.dml.read.md)
+ [Aggiorna i dati in una tabella Amazon Keyspaces utilizzando CQL](getting-started.dml.update.md)
+ [Eliminare i dati da una tabella utilizzando l'istruzione CQL `DELETE`](getting-started.dml.delete.md)
# Inserimento e caricamento di dati in una tabella Amazon Keyspaces
Per creare dati nella `book_awards` tabella, usa l'`INSERT`istruzione per aggiungere una singola riga.
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. Prima di poter scrivere dati sulla tabella Amazon Keyspaces utilizzando cqlsh, devi impostare la consistenza di scrittura per la sessione cqlsh corrente su. `LOCAL_QUORUM` Per ulteriori informazioni sui livelli di coerenza supportati, consulta. [Livelli di coerenza di scrittura](consistency.md#WriteConsistency) Si noti che questo passaggio non è necessario se si utilizza l'editor CQL in. Console di gestione AWS
```
CONSISTENCY LOCAL_QUORUM;
```
1. Per inserire un singolo record, eseguite il seguente comando nell'editor CQL.
```
INSERT INTO catalog.book_awards (award, year, category, rank, author, book_title, publisher)
VALUES ('Wolf', 2023, 'Fiction',3,'Shirley Rodriguez','Mountain', 'AnyPublisher') ;
```
1. Verifica che i dati siano stati aggiunti correttamente alla tabella eseguendo il comando seguente.
```
SELECT * FROM catalog.book_awards;
```
L'output della dichiarazione dovrebbe essere simile al seguente.
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+-------------------+------------+--------------
2023 | Wolf | Fiction | 3 | Shirley Rodriguez | Mountain | AnyPublisher
(1 rows)
```
**Per inserire più record da un file usando cqlsh**
1. [Scaricate il file CSV di esempio (`keyspaces_sample_table.csv`) contenuto nel file di archivio samplemigration.zip.](samples/samplemigration.zip) Decomprimi l'archivio e prendi nota del percorso verso. `keyspaces_sample_table.csv`
![\[Schermata di un file CSV che mostra l'output della tabella dopo l'importazione del file csv.\]](http://docs.aws.amazon.com/it_it/keyspaces/latest/devguide/images/keyspaces-awards.png)
1. Apri AWS CloudShell Console di gestione AWS 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
```
1. Al `cqlsh` prompt (`cqlsh>`), specificate uno spazio chiave.
```
USE catalog ;
```
1. Imposta la coerenza di scrittura su. `LOCAL_QUORUM` Per ulteriori informazioni sui livelli di coerenza supportati, consulta[Livelli di coerenza di scrittura](consistency.md#WriteConsistency).
```
CONSISTENCY LOCAL_QUORUM;
```
1. Nella sezione AWS CloudShell **Azioni** in alto a destra dello schermo, quindi scegli **Carica file per caricare il file** csv scaricato in precedenza. Prendi nota del percorso del file.
1. Al prompt del keyspace (`cqlsh:catalog>`), eseguite la seguente istruzione.
```
COPY book_awards (award, year, category, rank, author, book_title, publisher) FROM '/home/cloudshell-user/keyspaces_sample_table.csv' WITH header=TRUE ;
```
L'output dell'istruzione dovrebbe essere simile a questo.
```
cqlsh:catalog> COPY book_awards (award, year, category, rank, author, book_title, publisher) FROM '/home/cloudshell-user/keyspaces_sample_table.csv' WITH delimiter=',' AND header=TRUE ;
cqlsh current consistency level is LOCAL_QUORUM.
Reading options from /home/cloudshell-user/.cassandra/cqlshrc:[copy]: {'numprocesses': '16', 'maxattempts': '1000'}
Reading options from /home/cloudshell-user/.cassandra/cqlshrc:[copy-from]: {'ingestrate': '1500', 'maxparseerrors': '1000', 'maxinserterrors': '-1', 'maxbatchsize': '10', 'minbatchsize': '1', 'chunksize': '30'}
Reading options from the command line: {'delimiter': ',', 'header': 'TRUE'}
Using 16 child processes
Starting copy of catalog.book_awards with columns [award, year, category, rank, author, book_title, publisher].
OSError: handle is closed 0 rows/s; Avg. rate: 0 rows/s
Processed: 9 rows; Rate: 0 rows/s; Avg. rate: 0 rows/s
9 rows imported from 1 files in 0 day, 0 hour, 0 minute, and 26.706 seconds (0 skipped).
```
1. Verifica che i dati siano stati aggiunti correttamente alla tabella eseguendo la seguente query.
```
SELECT * FROM book_awards ;
```
Vedrai il seguente output.
```
year | award | category | rank | author | book_title | publisher
------+------------------+-------------+------+--------------------+-----------------------+---------------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | Example Books
2020 | Wolf | Non-Fiction | 2 | Ana Carolina Silva | Science Today | SomePublisher
2020 | Wolf | Non-Fiction | 3 | Shirley Rodriguez | The Future of Sea Ice | AnyPublisher
2020 | Kwesi Manu Prize | Fiction | 1 | Akua Mansa | Where did you go? | SomePublisher
2020 | Kwesi Manu Prize | Fiction | 2 | John Stiles | Yesterday | Example Books
2020 | Kwesi Manu Prize | Fiction | 3 | Nikki Wolf | Moving to the Chateau | AnyPublisher
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | Long Summer | SomePublisher
2020 | Richard Roe | Fiction | 2 | Arnav Desai | The Key | Example Books
2020 | Richard Roe | Fiction | 3 | Mateo Jackson | Inside the Whale | AnyPublisher
(9 rows)
```
Per ulteriori informazioni sull'utilizzo `cqlsh COPY` per caricare dati da file csv in una tabella Amazon Keyspaces, consulta. [Tutorial: Caricamento di dati in Amazon Keyspaces utilizzando cqlsh](bulk-upload.md)
# Leggi i dati da una tabella utilizzando l'`SELECT`istruzione CQL in Amazon Keyspaces
Nella [Inserimento e caricamento di dati in una tabella Amazon Keyspaces](getting-started.dml.create.md) sezione, hai utilizzato l'`SELECT`istruzione per verificare di aver aggiunto correttamente i dati alla tabella. In questa sezione, si perfeziona l'uso `SELECT` per visualizzare colonne specifiche e solo le righe che soddisfano criteri specifici.
La forma generale della `SELECT` dichiarazione è la seguente.
```
SELECT column_list FROM table_name [WHERE condition [ALLOW FILTERING]] ;
```
**Topics**
+ [Seleziona tutti i dati nella tua tabella](#getting-started.dml.read.all)
+ [Seleziona un sottoinsieme di colonne](#getting-started.dml.read.columns)
+ [Seleziona un sottoinsieme di righe](#getting-started.dml.read.rows)
## Seleziona tutti i dati nella tua tabella
La forma più semplice dell'`SELECT`istruzione restituisce tutti i dati della tabella.
**Importante**
In un ambiente di produzione, in genere non è consigliabile eseguire questo comando, poiché restituisce tutti i dati della tabella.
**Per selezionare tutti i dati della tabella**
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
```
1. Esegui la seguente query.
```
SELECT * FROM catalog.book_awards ;
```
Usa il carattere jolly (`*`) per `column_list` selezionare tutte le colonne. L'output dell'istruzione è simile all'esempio seguente.
```
year | award | category | rank | author | book_title | publisher
------+------------------+-------------+------+--------------------+-----------------------+---------------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | AnyPublisher
2020 | Wolf | Non-Fiction | 2 | Ana Carolina Silva | Science Today | SomePublisher
2020 | Wolf | Non-Fiction | 3 | Shirley Rodriguez | The Future of Sea Ice | AnyPublisher
2020 | Kwesi Manu Prize | Fiction | 1 | Akua Mansa | Where did you go? | SomePublisher
2020 | Kwesi Manu Prize | Fiction | 2 | John Stiles | Yesterday | Example Books
2020 | Kwesi Manu Prize | Fiction | 3 | Nikki Wolf | Moving to the Chateau | AnyPublisher
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | Long Summer | SomePublisher
2020 | Richard Roe | Fiction | 2 | Arnav Desai | The Key | Example Books
2020 | Richard Roe | Fiction | 3 | Mateo Jackson | Inside the Whale | AnyPublisher
```
## Seleziona un sottoinsieme di colonne
**Per eseguire una query per un sottoinsieme di colonne**
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
```
1. Per recuperare solo le `year` colonne`award`, e`category`, esegui la seguente query.
```
SELECT award, category, year FROM catalog.book_awards ;
```
L'output contiene solo le colonne specificate nell'ordine elencato nell'`SELECT`istruzione.
```
award | category | year
------------------+-------------+------
Wolf | Non-Fiction | 2020
Wolf | Non-Fiction | 2020
Wolf | Non-Fiction | 2020
Kwesi Manu Prize | Fiction | 2020
Kwesi Manu Prize | Fiction | 2020
Kwesi Manu Prize | Fiction | 2020
Richard Roe | Fiction | 2020
Richard Roe | Fiction | 2020
Richard Roe | Fiction | 2020
```
## Seleziona un sottoinsieme di righe
Quando si esegue una query su un set di dati di grandi dimensioni, è possibile che si desiderino solo record che soddisfino determinati criteri. A tale scopo, puoi aggiungere una `WHERE` clausola alla fine della nostra dichiarazione. `SELECT`
**Per eseguire una ricerca su un sottoinsieme di righe**
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
```
1. Per recuperare solo i record relativi ai premi di un determinato anno, esegui la seguente query.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Wolf' ;
```
L'`SELECT`istruzione precedente restituisce l'output seguente.
```
year | award | category | rank | author | book_title | publisher
------+-------+-------------+------+--------------------+-----------------------+---------------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | AnyPublisher
2020 | Wolf | Non-Fiction | 2 | Ana Carolina Silva | Science Today | SomePublisher
2020 | Wolf | Non-Fiction | 3 | Shirley Rodriguez | The Future of Sea Ice | AnyPublisher
```
### Comprensione della clausola `WHERE`
La `WHERE` clausola viene utilizzata per filtrare i dati e restituire solo i dati che soddisfano i criteri specificati. I criteri specificati possono essere una condizione semplice o una condizione composta.
**Come utilizzare le condizioni in una `WHERE` clausola**
+ Una condizione semplice: una singola colonna.
```
WHERE column_name=value
```
È possibile utilizzare una condizione semplice in una `WHERE` clausola se viene soddisfatta una delle seguenti condizioni:
+ La colonna è l'unica colonna chiave di partizione della tabella.
+ Si aggiunge `ALLOW FILTERING` dopo la condizione nella `WHERE` clausola.
Tieni presente che l'utilizzo `ALLOW FILTERING` può comportare prestazioni incoerenti, specialmente con tabelle di grandi dimensioni e multipartizionate.
+ Una condizione composta: più condizioni semplici collegate da. `AND`
```
WHERE column_name1=value1 AND column_name2=value2 AND column_name3=value3...
```
È possibile utilizzare condizioni composte in una `WHERE` clausola se viene soddisfatta una delle seguenti condizioni:
+ Le colonne che è possibile utilizzare nella `WHERE` clausola devono includere tutte o un sottoinsieme delle colonne nella chiave di partizione della tabella. Se si desidera utilizzare solo un sottoinsieme delle colonne della `WHERE` clausola, è necessario includere un insieme contiguo di colonne chiave di partizione da sinistra a destra, a partire dalla colonna principale della chiave di partizione. Ad esempio, se le colonne della chiave di partizione sono `year``month`, e `award` allora è possibile utilizzare le seguenti colonne nella clausola: `WHERE`
+ `year`
+ `year`E `month`
+ `year`E `month` E `award`
+ Si aggiunge `ALLOW FILTERING` dopo la condizione composta nella `WHERE` clausola, come nell'esempio seguente.
```
SELECT * FROM my_table WHERE col1=5 AND col2='Bob' ALLOW FILTERING ;
```
Tieni presente che l'utilizzo `ALLOW FILTERING` può comportare prestazioni incoerenti, specialmente con tabelle di grandi dimensioni e multipartizionate.
### Provalo
Crea le tue query CQL per trovare quanto segue dalla tua `book_awards` tabella:
+ Trova i vincitori dei premi Wolf 2020 e mostra i titoli e gli autori dei libri, ordinati per classifica.
+ Mostra i vincitori del primo premio di tutti i premi del 2020 e mostra i titoli dei libri e i nomi dei premi.
# Aggiorna i dati in una tabella Amazon Keyspaces utilizzando CQL
Per aggiornare i dati nella tua `book_awards` tabella, usa l'`UPDATE`istruzione.
La forma generale della `UPDATE` dichiarazione è la seguente.
```
UPDATE table_name SET column_name=new_value WHERE primary_key=value ;
```
**Suggerimento**
È possibile aggiornare più colonne utilizzando un elenco di valori `column_names` e separati da virgole, come nell'esempio seguente.
```
UPDATE my_table SET col1='new_value_1', col2='new_value2' WHERE col3='1' ;
```
Se la chiave primaria è composta da più colonne, tutte le colonne della chiave primaria e i relativi valori devono essere inclusi nella clausola. `WHERE`
Non è possibile aggiornare alcuna colonna nella chiave primaria perché ciò modificherebbe la chiave primaria del record.
**Per aggiornare una singola cella**
Usando la tua `book_awards` tabella, cambia il nome di un editore che ha vinto i Wolf Awards di saggistica nel 2020.
```
UPDATE book_awards SET publisher='new Books' WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
Verifica che l'editore lo sia adesso`new Books`.
```
SELECT * FROM book_awards WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
L'istruzione dovrebbe restituire il seguente risultato.
```
year | award | category | rank | author | book_title | publisher
------+-------+-------------+------+-------------+------------------+-----------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | new Books
```
## Provalo
**Avanzato:** il vincitore della fiction «Kwezi Manu Prize» del 2020 ha cambiato nome. Aggiorna questo record per cambiare il nome in. `'Akua Mansa-House'`
# Eliminare i dati da una tabella utilizzando l'istruzione CQL `DELETE`
Per eliminare i dati nella `book_awards` tabella, usa l'`DELETE`istruzione.
È possibile eliminare i dati da una riga o da una partizione. Fai attenzione quando elimini i dati, poiché le eliminazioni sono irreversibili.
L'eliminazione di una o tutte le righe da una tabella non elimina la tabella. In questo modo puoi ripopolarla con i dati. L'eliminazione di una tabella comporta l'eliminazione della tabella e di tutti i dati in essa contenuti. Per utilizzare nuovamente la tabella, è necessario ricrearla e aggiungervi dati. L'eliminazione di uno spazio chiave elimina lo spazio chiave e tutte le tabelle al suo interno. Per utilizzare lo spazio chiave e le tabelle, è necessario ricrearli e quindi popolarli con i dati. Puoi utilizzare il ripristino di Amazon Keyspaces Point-in-time (PITR) per ripristinare le tabelle eliminate; per ulteriori informazioni, consulta. [Backup e ripristino dei dati con point-in-time ripristino per Amazon Keyspaces](PointInTimeRecovery.md) Per informazioni su come ripristinare una tabella eliminata con PITR abilitato, consulta. [Ripristina una tabella eliminata utilizzando Amazon Keyspaces PITR](restoredeleted.md)
## Eliminare le celle
L'eliminazione di una colonna da una riga rimuove i dati dalla cella specificata. Quando si visualizza la colonna utilizzando un'`SELECT`istruzione, i dati vengono visualizzati come*null*, sebbene in quella posizione non sia memorizzato un valore nullo.
La sintassi generale per eliminare una o più colonne specifiche è la seguente.
```
DELETE column_name1[, column_name2...] FROM table_name WHERE condition ;
```
Nella tua `book_awards` tabella, puoi vedere che il titolo del libro che ha vinto il primo premio del premio «Richard Roe» 2020 è «Long Summer». Immagina che questo titolo sia stato richiamato e che tu debba eliminare i dati da questa cella.
**Per eliminare una cella specifica**
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
```
1. Esegui la seguente `DELETE` interrogazione.
```
DELETE book_title FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. Verifica che la richiesta di eliminazione sia stata effettuata come previsto.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
L'output di questa dichiarazione è simile al seguente.
```
year | award | category | rank | author | book_title | publisher
------+-------------+----------+------+-------------------+------------+---------------
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | null | SomePublisher
```
## Eliminazione di righe
Potrebbe esserci un momento in cui è necessario eliminare un'intera riga, ad esempio per soddisfare una richiesta di cancellazione dei dati. La sintassi generale per l'eliminazione di una riga è la seguente.
```
DELETE FROM table_name WHERE condition ;
```
**Per eliminare una riga**
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
```
1. Esegui la seguente `DELETE` interrogazione.
```
DELETE FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. Verificate che l'eliminazione sia stata effettuata come previsto.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
L'output di questa istruzione è simile al seguente dopo l'eliminazione della riga.
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+--------+------------+-----------
(0 rows)
```
Puoi eliminare automaticamente i dati scaduti dalla tua tabella utilizzando Amazon Keyspaces Time to Live, per ulteriori informazioni, consulta. [Fai scadere i dati con Time to Live (TTL) per Amazon Keyspaces (per Apache Cassandra)](TTL.md)
# Eliminare una tabella in Amazon Keyspaces
Per evitare che ti vengano addebitati costi per tabelle e dati che non ti servono, elimina tutte le tabelle che non utilizzi. Quando elimini una tabella, la tabella e i relativi dati vengono eliminati e non ti vengono più addebitati costi per tali tabelle. Tuttavia, lo spazio delle chiavi rimane. Quando si elimina uno spazio chiave, lo spazio chiave e tutte le relative tabelle vengono eliminati e si interrompe l'addebito per tali spazi.
È possibile eliminare una tabella utilizzando la console, CQL o. AWS CLI Quando si elimina una tabella, la tabella e tutti i relativi dati vengono eliminati.
## Utilizzo della console
La procedura seguente elimina una tabella e tutti i relativi dati utilizzando il Console di gestione AWS.
**Per eliminare 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 pannello di navigazione, seleziona **Tabelle**.
1. Scegli la casella a sinistra del nome di ogni tabella che desideri eliminare.
1. Scegli **Elimina**.
1. **Nella schermata Elimina tabella**, inserisci **Delete** la casella. Quindi, scegli **Elimina tabella**.
1. Per verificare che la tabella sia stata eliminata, scegli **Tabelle** nel riquadro di navigazione e conferma che la `book_awards` tabella non è più elencata.
## Usare CQL
La procedura seguente elimina una tabella e tutti i relativi dati utilizzando CQL.
**Per eliminare 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
```
1. Elimina la tabella inserendo la seguente dichiarazione.
```
DROP TABLE IF EXISTS catalog.book_awards ;
```
1. Verifica che la tabella sia stata eliminata.
```
SELECT * FROM system_schema.tables WHERE keyspace_name = 'catalog' ;
```
L'output dovrebbe assomigliare a questo. Nota che questa operazione potrebbe richiedere del tempo, quindi esegui nuovamente l'istruzione dopo un minuto se non vedi questo risultato.
```
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)
```
## Usando il AWS CLI
La procedura seguente elimina una tabella e tutti i relativi dati utilizzando. AWS CLI
**Per eliminare una tabella utilizzando il AWS CLI**
1. Aprire CloudShell
1. Elimina la tabella con la seguente dichiarazione.
```
aws keyspaces delete-table --keyspace-name 'catalog' --table-name 'book_awards'
```
1. Per verificare che la tabella sia stata eliminata, puoi elencare tutte le tabelle in un keyspace.
```
aws keyspaces list-tables --keyspace-name 'catalog'
```
Vedrai il seguente output. Tieni presente che questa operazione asincrona può richiedere del tempo. Esegui nuovamente il comando dopo qualche istante per confermare che la tabella è stata eliminata.
```
{
"tables": []
}
```
# Eliminare un keyspace in Amazon Keyspaces
Per evitare che ti vengano addebitati costi per gli spazi chiave, elimina tutti i keyspace che non stai utilizzando. Quando elimini uno spazio chiave, lo spazio chiave e tutte le relative tabelle vengono eliminati e non ti vengono più addebitati costi per tali spazi.
È possibile eliminare uno spazio chiave utilizzando la console, CQL o. AWS CLI
## Utilizzo della console
La procedura seguente elimina uno spazio chiave e tutte le relative tabelle e dati utilizzando la console.
**Per eliminare uno spazio chiave 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 la casella a sinistra del nome di ogni keyspace che desideri eliminare.
1. Scegli **Elimina**.
1. Nella schermata **Elimina spazio chiave**, inserisci **Delete** nella casella. Quindi, scegli **Elimina spazio chiave**.
1. Per verificare che il keyspace sia `catalog` stato eliminato, scegli **Keyspaces** nel riquadro di navigazione e conferma che non è più elencato. Poiché ne hai eliminato lo spazio chiave, anche la `book_awards` tabella in **Tabelle** non dovrebbe essere elencata.
## Usare CQL
La procedura seguente elimina uno spazio di chiavi e tutte le relative tabelle e dati utilizzando CQL.
**Per eliminare uno spazio chiave 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
```
1. Elimina il tuo keyspace inserendo la seguente dichiarazione.
```
DROP KEYSPACE IF EXISTS catalog ;
```
1. Verifica che il tuo keyspace sia stato eliminato.
```
SELECT * from system_schema.keyspaces ;
```
Il tuo keyspace non dovrebbe essere elencato. Nota che, poiché si tratta di un'operazione asincrona, può verificarsi un ritardo prima che il keyspace venga eliminato. Dopo l'eliminazione del keyspace, l'output dell'istruzione dovrebbe avere il seguente aspetto.
```
keyspace_name | durable_writes | replication
-------------------------+----------------+-------------------------------------------------------------------------------------
system_schema | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_schema_mcs | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_multiregion_info | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
(4 rows)
```
## Usando il AWS CLI
La procedura seguente elimina un keyspace e tutte le relative tabelle e dati utilizzando. AWS CLI
**Per eliminare uno spazio chiave utilizzando AWS CLI**
1. Aprire AWS CloudShell
1. Elimina il tuo keyspace inserendo la seguente dichiarazione.
```
aws keyspaces delete-keyspace --keyspace-name 'catalog'
```
1. Verifica che il tuo keyspace sia stato eliminato.
```
aws keyspaces list-keyspaces
```
L'output di questa istruzione dovrebbe essere simile a questo ed elencare solo gli spazi chiave di sistema. Nota che, poiché si tratta di un'operazione asincrona, può verificarsi un ritardo prima che il keyspace venga eliminato.
```
{
"keyspaces": [
{
"keyspaceName": "system_schema",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system_schema/",
"replicationStrategy": "SINGLE_REGION"
},
{
"keyspaceName": "system_schema_mcs",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system_schema_mcs/",
"replicationStrategy": "SINGLE_REGION"
},
{
"keyspaceName": "system",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system/",
"replicationStrategy": "SINGLE_REGION"
},
{
"keyspaceName": "system_multiregion_info",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system_multiregion_info/",
"replicationStrategy": "SINGLE_REGION"
}
]
}
```