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, 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)