Come eliminare più item in DynamoDB

In DynamoDB non esiste alcun DELETE FROM table WHERE …. Ogni delete punta a un item tramite la sua primary key completa — l'API non ha alcuna operazione di bulk-delete, nessun truncate, e l'istruzione DELETE di PartiQL rimuove esattamente un item per istruzione. Quindi "eliminare più item" è sempre un lavoro in due passi: trova le chiavi, poi emetti un delete per chiave, raggruppato in batch per il throughput.

Questa guida copre le opzioni di batching, la variante transazionale tutto-o-niente, il caso "elimina tutto", e come fare la stessa cosa con una selezione e due tasti in una GUI.

Come elimino più item in DynamoDB?

Raccogli le primary key degli item che vuoi eliminare (via Query o Scan), poi eliminali in batch: BatchWriteItem accetta fino a 25 DeleteRequest per chiamata, TransactWriteItems elimina fino a 100 item atomicamente, e le istruzioni DELETE di PartiQL possono essere raggruppate 25 alla volta con BatchExecuteStatement. In DynoTable selezioni le righe e premi ⌘⌫ per mettere le eliminazioni in staging, poi rivedi e fai il commit.

• Bulk, best-effort: BatchWriteItem — 25 delete per chiamata, ritenta gli avanzi.
• Tutto-o-niente: TransactWriteItems — fino a 100 azioni che riescono o falliscono insieme.
• Sintassi in stile SQL: PartiQL DELETE + BatchExecuteStatement — stessa regola per-chiave, ortografia familiare.
• Tutto ciò che c'è nella tabella: strategie di truncate — di solito è più economico eliminare e ricreare la tabella.
• Una selezione visuale: eliminazioni in staging in DynoTable — seleziona le righe, metti in staging, rivedi i diff rossi, committa.

Passo 0: raccogli le chiavi

Un delete richiede l'intera primary key — su una tabella a chiave composita sono la partition key e la sort key (AWS: "For each primary key, you must provide all of the key attributes"). Non puoi eliminare per un attributo arbitrario, quindi "elimina ogni item dove status = 'archived'" inizia con una lettura:

• Se la condizione vive su una chiave (o su una chiave di un GSI), una Query mirata raccoglie le chiavi a basso costo.
• Altrimenti è uno Scan con un filtro — che legge (e fattura) l'intera tabella, filtro o no; vedi query vs scan.

Usa una ProjectionExpression che restituisce solo gli attributi chiave, e segui LastEvaluatedKey fino alla fine (paginazione) o eliminerai silenziosamente solo il contenuto della prima pagina da 1 MB.

Metodo 1: BatchWriteItem (fino a 25 delete per chiamata)

BatchWriteItem raggruppa fino a 25 richieste put/delete o 16 MB per chiamata (riferimento API AWS: "A single call to BatchWriteItem can transmit up to 16MB of data over the network, consisting of up to 25 item put or delete operations").

aws dynamodb batch-write-item --request-items '{
  "Orders": [
    {"DeleteRequest": {"Key": {"PK": {"S": "ORDER#1001"}, "SK": {"S": "META"}}}},
    {"DeleteRequest": {"Key": {"PK": {"S": "ORDER#1002"}, "SK": {"S": "META"}}}},
    {"DeleteRequest": {"Key": {"PK": {"S": "ORDER#1003"}, "SK": {"S": "META"}}}}
  ]
}'

Tre proprietà del batch fanno inciampare le persone — tutte direttamente dal riferimento API:

• Non è atomico. "The individual PutItem and DeleteItem operations specified in BatchWriteItem are atomic; however BatchWriteItem as a whole is not." Alcuni delete possono atterrare mentre altri no.
• Devi ritentare UnprocessedItems. Le richieste sotto throttling tornano nella mappa UnprocessedItems della risposta, nella stessa forma della richiesta — "Typically, you would call BatchWriteItem in a loop", e AWS "strongly recommend[s] that you use an exponential backoff algorithm" tra i retry.
• Nessuna condizione. "You cannot specify conditions on individual put and delete requests" — un delete condizionale deve passare da DeleteItem o da una transazione. Un batch rifiuta anche due operazioni sulla stessa chiave in una chiamata.

La forma del ciclo — spezza per 25, invia, rimetti in coda gli avanzi con backoff — è la stessa trattata in operazioni batch.

Metodo 2: TransactWriteItems (delete atomici)

Quando un insieme di delete deve riuscire o fallire insieme — rimuovere un item padre e i figli della sua item collection, per esempio — usa TransactWriteItems: fino a 100 azioni (delete, put, update, condition check) applicate atomicamente, con condition expression per-item ammesse. Il compromesso: una scrittura transazionale costa il doppio della write capacity di una scrittura semplice. La meccanica completa (token di idempotenza, TransactionCanceledException, matematica dei costi) è in transazioni DynamoDB.

Metodo 3: PartiQL DELETE, in batch

PartiQL non elimina la regola per-chiave — la riscrive soltanto. La developer guide è esplicita (PartiQL DELETE): "You can only delete one item at a time. You cannot issue a single DynamoDB PartiQL statement that deletes multiple items", e la condizione WHERE "must resolve to a single primary key value".

Per eliminare più item raggruppi in batch istruzioni a singolo item — BatchExecuteStatement esegue fino a 25 istruzioni per batch (tutte letture o tutte scritture, mai miste):

[
  {"Statement": "DELETE FROM \"Orders\" WHERE PK = 'ORDER#1001' AND SK = 'META'"},
  {"Statement": "DELETE FROM \"Orders\" WHERE PK = 'ORDER#1002' AND SK = 'META'"}
]

aws dynamodb batch-execute-statement --statements file://statements.json

Un WHERE che non blocca la chiave completa fallisce — non esiste alcun DELETE FROM Orders WHERE status = 'archived'. Altri pattern PartiQL (e i limiti dietro di essi) in esempi PartiQL e PartiQL vs SQL.

Eliminare TUTTI gli item (truncate)

DynamoDB non ha alcun truncate. Le tue opzioni, in ordine di preferenza:

1. Elimina e ricrea la tabella. L'eliminazione item-per-item di un'intera tabella fattura una scrittura per item; DeleteTable + CreateTable aggira l'intero conto delle scritture. Il rovescio: le impostazioni della tabella — indici, TTL, stream, modalità di capacità, tag — non tornano da sole; le ridichiari alla creazione (con l'infrastructure-as-code è un non-evento).
2. Fai scadere gli item con il TTL. Se "elimina tutto ciò che è più vecchio di X" è davvero quello che vuoi, il TTL elimina gli item scaduti in background senza consumare write capacity — un bulk delete al rallentatore che non costa nulla.
3. Scan + batch-delete (Metodo 1) quando la tabella deve restare live e se ne va solo un sottoinsieme — paghi una lettura per item scansionato più una scrittura per item eliminato.

Eliminare più item in DynoTable

Il flusso seleziona-poi-elimina qui sopra — query, raccogli le chiavi, spezza in blocchi, ritenta — è esattamente il lavoro ripetitivo che una GUI dovrebbe prendersi in carico. In DynoTable è una selezione nella griglia:

1. Esegui o filtra una query così che le righe da eliminare siano sullo schermo.
2. Selezionale e premi ⌘⌫ — ogni riga selezionata diventa un delete in staging. Nulla ha ancora toccato DynamoDB: le righe si tingono di rosso nella griglia e appaiono come card revisionabili nel pannello di staging.
3. Rivedi, poi Commit. I commit partono come batch TransactWriteItems con condizioni di optimistic-locking — un delete in staging passa solo se l'item esiste ancora — e gli staging grandi vengono spezzati automaticamente per restare dentro i limiti di transazione di DynamoDB. ⌘⇧⌫ salta la revisione ed elimina-e-committa la selezione in un solo accordo di tasti.

L'ambito è onesto: elimini le righe che hai selezionato — un'operazione rivista e recuperabile fino al commit — non un truncate cieco dell'intera tabella. Per svuotare una tabella intera, eliminala e ricreala (sopra).

Se un delete richiede una condizione scritta a mano (attribute_exists, un controllo di versione), costruisci l'esatta ConditionExpression + le mappe di placeholder nel DynamoDB Expression Builder e allegala a un DeleteItem o a una transazione.

FAQ

Posso eliminare più item in una sola chiamata DynamoDB? Sì — fino a 25 con BatchWriteItem (best-effort, ritenta UnprocessedItems) o fino a 100 atomicamente con TransactWriteItems. Entrambe richiedono una primary key completa per item; nessuna delle due accetta una condizione "where" per selezionare gli item.

Esiste un DELETE WHERE in DynamoDB? No. Né l'API di basso livello né PartiQL possono eliminare per condizione — il DELETE di PartiQL richiede un WHERE che "resolve[s] to a single primary key value". Prima fai query o scan per le chiavi, poi elimini ognuna.

Come elimino tutti gli item in una tabella DynamoDB? Per una pulizia completa, elimina e ricrea la tabella — eviti di pagare una scrittura per item. Per pulizie basate sull'età, usa il TTL, che elimina gli item scaduti senza consumare write capacity. Scan + batch-delete è il ripiego quando la tabella deve restare live.

Perché gli item riappaiono dopo il mio batch delete? Quasi sempre UnprocessedItems non ritentati: un BatchWriteItem sotto throttling restituisce silenziosamente i delete falliti nella risposta, e il codice che non cicla su di essi "finisce" con item ancora nella tabella. Ritenta con backoff esponenziale finché la mappa non torna vuota.

Quanto costa eliminare item? Ogni delete è una scrittura standard (una WCU per 1 KB, raddoppiata dentro una transazione), e anche trovare le chiavi costa letture. Stima il danno con il calcolatore di prezzi.

Preferisci vedere cosa stai eliminando prima? Scarica DynoTable — seleziona le righe, metti i delete in staging con ⌘⌫, rivedi i diff e committa quando sei sicuro.