Utilizzo delle query in Amazon Keyspaces

Questa sezione fornisce un'introduzione all'utilizzo delle query in Amazon Keyspaces (per Apache Cassandra). Le istruzioni CQL disponibili per interrogare, trasformare e gestire i dati sonoSELECT,, e. INSERT UPDATE DELETE Negli argomenti seguenti vengono descritte alcune delle opzioni più complesse disponibili quando si lavora con le query. Per la sintassi completa del linguaggio con esempi, vedere. Istruzioni DML (linguaggio di manipolazione dei dati) in Amazon Keyspaces

Utilizzo dell'INoperatore con l'SELECTistruzione in Amazon Keyspaces

SELEZIONA IN

È possibile interrogare i dati dalle tabelle utilizzando l'SELECTistruzione, che legge una o più colonne per una o più righe in una tabella e restituisce un set di risultati contenente le righe corrispondenti alla richiesta. Un'SELECTistruzione contiene un'istruzione select_clause che determina quali colonne leggere e restituire nel set di risultati. La clausola può contenere istruzioni per trasformare i dati prima di restituirli. La WHERE clausola facoltativa specifica quali righe devono essere interrogate ed è composta da relazioni sulle colonne che fanno parte della chiave primaria. Amazon Keyspaces supporta la IN parola chiave nella clausola. WHERE Questa sezione utilizza esempi per mostrare come Amazon Keyspaces elabora SELECT le istruzioni con la IN parola chiave.

Questo esempio dimostra come Amazon Keyspaces suddivide SELECT l'istruzione con IN la parola chiave in sottoquery. In questo esempio utilizziamo una tabella con il nome. my_keyspace.customers La tabella ha una colonna chiave primariadepartment_id, due colonne sales_region_id di clustering e e una colonna che contiene il nome del cliente nella customer_name colonna. sales_representative_id

SELECT * FROM my_keyspace.customers;

         department_id | sales_region_id | sales_representative_id | customer_name
        ---------------+-----------------+-------------------------+--------------
          0            |        0        |            0            |    a
          0            |        0        |            1            |    b
          0            |        1        |            0            |    c
          0            |        1        |            1            |    d
          1            |        0        |            0            |    e
          1            |        0        |            1            |    f
          1            |        1        |            0            |    g
          1            |        1        |            1            |    h

Utilizzando questa tabella, è possibile eseguire la seguente SELECT istruzione per trovare i clienti nei reparti e nelle aree di vendita a cui si è interessati con la IN parola chiave contenuta nella WHERE clausola. La seguente dichiarazione ne è un esempio.

SELECT * FROM my_keyspace.customers WHERE department_id IN (0, 1) AND sales_region_id IN (0, 1);

Amazon Keyspaces divide questa dichiarazione in quattro sottoquery, come illustrato nell'output seguente.

SELECT * FROM my_keyspace.customers WHERE department_id = 0 AND sales_region_id = 0;

 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  0            |        0        |           0             |    a
  0            |        0        |           1             |    b

SELECT * FROM my_keyspace.customers WHERE department_id = 0 AND sales_region_id = 1;

 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  0            |        1        |          0              |    c
  0            |        1        |          1              |    d

SELECT * FROM my_keyspace.customers WHERE department_id = 1 AND sales_region_id = 0;

 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  1            |        0        |          0              |    e
  1            |        0        |          1              |    f

SELECT * FROM my_keyspace.customers WHERE department_id = 1 AND sales_region_id = 1;

 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  1            |        1        |           0             |    g
  1            |        1        |           1             |    h

Quando viene utilizzata la IN parola chiave, Amazon Keyspaces impagina automaticamente i risultati in uno dei seguenti casi:

• Dopo l'elaborazione di ogni decima sottoquery.

• Dopo aver elaborato 1 MB di IO logico.

• Se hai configurato aPAGE SIZE, Amazon Keyspaces impagina dopo aver letto il numero di query da elaborare in base al set. PAGE SIZE

• Quando usi la LIMIT parola chiave per ridurre il numero di righe restituite, Amazon Keyspaces impagina dopo aver letto il numero di query da elaborare in base al set. LIMIT

La tabella seguente viene utilizzata per illustrare questo aspetto con un esempio.

Per ulteriori informazioni sull'impaginazione, vedere. Risultati di impaginazione in Amazon Keyspaces

SELECT * FROM my_keyspace.customers;

         department_id | sales_region_id | sales_representative_id | customer_name
        ---------------+-----------------+-------------------------+--------------
          2            |        0        |          0              |    g
          2            |        1        |          1              |    h
          2            |        2        |          2              |    i
          0            |        0        |          0              |    a
          0            |        1        |          1              |    b
          0            |        2        |          2              |    c
          1            |        0        |          0              |    d
          1            |        1        |          1              |    e
          1            |        2        |          2              |    f
          3            |        0        |          0              |    j
          3            |        1        |          1              |    k
          3            |        2        |          2              |    l

È possibile eseguire la seguente istruzione in questa tabella per vedere come funziona l'impaginazione.

SELECT * FROM my_keyspace.customers WHERE department_id IN (0, 1, 2, 3) AND sales_region_id IN (0, 1, 2) AND sales_representative_id IN (0, 1);

Amazon Keyspaces elabora questa dichiarazione come 24 sottoquery, poiché la cardinalità del prodotto cartesiano di tutti i IN termini contenuti in questa query è 24.

 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  0            |        0        |          0              |    a
  0            |        1        |          1              |    b
  1            |        0        |          0              |    d
  1            |        1        |          1              |    e

---MORE---
 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  2            |        0        |          0              |    g
  2            |        1        |          1              |    h
  3            |        0        |          0              |    j

---MORE---
 department_id | sales_region_id | sales_representative_id | customer_name
---------------+-----------------+-------------------------+--------------
  3            |        1        |          1              |    k

Questo esempio mostra come utilizzare la ORDER BY clausola in un'istruzione con la parola chiave. SELECT IN

SELECT * FROM my_keyspace.customers WHERE department_id IN (3, 2, 1) ORDER BY sales_region_id DESC;
        
         department_id | sales_region_id | sales_representative_id | customer_name
        ---------------+-----------------+-------------------------+--------------
          3            |        2        |          2              |    l
          3            |        1        |          1              |    k
          3            |        0        |          0              |    j
          2            |        2        |          2              |    i
          2            |        1        |          1              |    h
          2            |        0        |          0              |    g
          1            |        2        |          2              |    f
          1            |        1        |          1              |    e
          1            |        0        |          0              |    d

Le sottoquery vengono elaborate nell'ordine in cui le colonne della chiave di partizione e della chiave di clustering vengono presentate nella query. Nell'esempio seguente, le sottoquery per il valore della chiave di partizione» 2 «vengono elaborate per prime, seguite dalle sottoquery per il valore della chiave di partizione» 3 «e» 1». I risultati di una determinata sottoquery vengono ordinati in base alla clausola di ordinamento della query, se presente, o all'ordine di clustering della tabella definito durante la creazione della tabella.

SELECT * FROM my_keyspace.customers WHERE department_id IN (2, 3, 1) ORDER BY sales_region_id DESC;

         department_id | sales_region_id | sales_representative_id | customer_name
        ---------------+-----------------+-------------------------+--------------
          2            |        2        |          2              |    i
          2            |        1        |          1              |    h
          2            |        0        |          0              |    g
          3            |        2        |          2              |    l
          3            |        1        |          1              |    k
          3            |        0        |          0              |    j
          1            |        2        |          2              |    f
          1            |        1        |          1              |    e
          1            |        0        |          0              |    d

Ordinazione dei risultati in Amazon Keyspaces

La ORDER BY clausola specifica l'ordinamento dei risultati restituiti in un'istruzione. SELECT L'istruzione accetta un elenco di nomi di colonna come argomenti e per ogni colonna è possibile specificare l'ordinamento dei dati. È possibile specificare solo colonne di raggruppamento nelle clausole di ordinamento, le colonne non raggruppate non sono consentite.

Le due opzioni di ordinamento disponibili per i risultati restituiti sono l'ordinamento crescente e l'ASCordinamento decrescente. DESC

SELECT * FROM my_keyspace.my_table ORDER BY (col1 ASC, col2 DESC, col3 ASC);

         col1 | col2 | col3  
        ------+------+------
          0   |  6   |  a   
          1   |  5   |  b   
          2   |  4   |  c   
          3   |  3   |  d   
          4   |  2   |  e   
          5   |  1   |  f   
          6   |  0   |  g

SELECT * FROM my_keyspace.my_table ORDER BY (col1 DESC, col2 ASC, col3 DESC);

         col1 | col2 | col3  
        ------+------+------
          6   |  0   |  g   
          5   |  1   |  f   
          4   |  2   |  e   
          3   |  3   |  d   
          2   |  4   |  c   
          1   |  5   |  b   
          0   |  6   |  a

Se non si specifica il criterio di ordinamento nell'istruzione di query, viene utilizzato l'ordinamento predefinito della colonna di clustering.

I possibili criteri di ordinamento che è possibile utilizzare in una clausola di ordinamento dipendono dall'ordinamento assegnato a ciascuna colonna di raggruppamento al momento della creazione della tabella. I risultati delle query possono essere ordinati solo nell'ordine definito per tutte le colonne di clustering al momento della creazione della tabella o nell'ordine inverso del criterio di ordinamento definito. Non sono consentite altre combinazioni possibili.

Ad esempio, se la tabella CLUSTERING ORDER è (col1 ASC, col2 DESC, col3 ASC), i parametri validi per ORDER BY sono (col1 ASC, col2 DESC, col3 ASC) o (col1 DESC, col2 ASC, col3 DESC). Per ulteriori informazioni su, vedere sotto. CLUSTERING ORDER table_options CREATE TABLE

Risultati di impaginazione in Amazon Keyspaces

Amazon Keyspaces impagina automaticamente i risultati delle SELECT istruzioni quando i dati letti per elaborare l'SELECTistruzione superano 1 MB. Con l'impaginazione, i risultati dell'SELECTistruzione sono suddivisi in «pagine» di dati di dimensioni pari o inferiori a 1 MB. Un'applicazione può elaborare la prima pagina dei risultati, quindi la seconda pagina e così via. I client devono sempre verificare la presenza di token di impaginazione durante l'elaborazione di SELECT query che restituiscono più righe.

Se un client fornisce un messaggio PAGE SIZE che richiede la lettura di più di 1 MB di dati, Amazon Keyspaces suddivide automaticamente i risultati in più pagine in base agli incrementi di lettura dei dati di 1 MB.

Ad esempio, se la dimensione media di una riga è di 100 KB e si specifica un valore PAGE SIZE di 20, Amazon Keyspaces impagina automaticamente i dati dopo aver letto 10 righe (1000 KB di dati letti).

Poiché Amazon Keyspaces impagina i risultati in base al numero di righe lette per elaborare una richiesta e non al numero di righe restituite nel set di risultati, alcune pagine potrebbero non contenere alcuna riga se si eseguono query filtrate.

Ad esempio, se PAGE SIZE imposti su 10 e Keyspaces valuta 30 righe per elaborare la tua querySELECT, Amazon Keyspaces restituirà tre pagine. Se solo un sottoinsieme di righe corrisponde alla tua query, alcune pagine potrebbero avere meno di 10 righe. Per un esempio di come le LIMIT query possono influire sulla capacità PAGE SIZE di lettura, vedere. Limita le interrogazioni