DynamoDB DeleteItem en Go (AWS SDK v2)

client.DeleteItem prend un dynamodb.DeleteItemInput portant la clé primaire complète. Avec types.ReturnValueAllOld, la réponse te dit s'il y avait effectivement quelque chose ; dès que tu ajoutes une ConditionExpression, c'est l'erreur qui te dit pourquoi l'élément est resté.

Code

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
)

func main() {
	ctx := context.TODO()
	cfg, err := config.LoadDefaultConfig(ctx, config.WithRegion("us-east-1"))
	if err != nil {
		log.Fatalf("load config: %v", err)
	}
	client := dynamodb.NewFromConfig(cfg)

	out, err := client.DeleteItem(ctx, &dynamodb.DeleteItemInput{
		TableName: aws.String("Music"),
		Key: map[string]types.AttributeValue{
			"Artist":    &types.AttributeValueMemberS{Value: "Arturo Sandoval"},
			"SongTitle": &types.AttributeValueMemberS{Value: "Cubano Chant"},
		},
		ReturnValues: types.ReturnValueAllOld,
	})
	if err != nil {
		log.Fatalf("delete item: %v", err)
	}

	if len(out.Attributes) == 0 {
		fmt.Println("No item with that key existed")
	} else {
		fmt.Println("Deleted:", out.Attributes)
	}
}

Explication

types.ReturnValueAllOld est une constante typée, pas la chaîne "ALL_OLD" — le champ prend un types.ReturnValue, donc une faute de frappe est une erreur de compilation plutôt qu'une ValidationException à l'exécution. DeleteItem n'accepte que NONE et ALL_OLD ; le reste de l'enum est partagé avec UpdateItem.
len(out.Attributes) == 0 est le seul signal que tu obtiens — supprimer une clé qui n'a jamais existé réussit, et le SDK te rend une map nil plutôt qu'une erreur. Rien d'autre ne distingue « je l'ai supprimé » de « il n'y avait rien à supprimer ».
Discrimine l'échec de la garde avec errors.As — var ccfe *types.ConditionalCheckFailedException puis errors.As(err, &ccfe). Une comparaison directe le manque, parce que Go v2 enveloppe les fautes de service dans une erreur d'opération Smithy.
L'exception peut transporter l'élément perdant — mets ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailureAllOld et ccfe.Item contient la ligne telle que DynamoDB l'a vue : tu peux journaliser la valeur qui a réellement fait échouer la garde au lieu de la relire. Le SDK en annonce le prix : "No read capacity units are consumed."
Un élément par appel — il n'y a pas d'API « tout supprimer ». Supprimer beaucoup d'éléments revient à collecter les clés d'abord puis à grouper les écritures, ou à supprimer la table.

Le faire visuellement

La garde est la moitié délicate : une ConditionExpression plus les maps de noms et de valeurs qui vont avec. Le DynamoDB Expression Builder assemble les trois à partir d'un formulaire.

DynoTable attaque le même risque par l'autre bout. Une suppression atterrit d'abord dans un panneau de modifications en attente et n'atteint la table que quand tu la valides : une mauvaise ligne devient donc quelque chose que tu abandonnes plutôt que quelque chose que tu restaures. Télécharge DynoTable.

Exemples liés

DynamoDB DeleteItem en Java — la même suppression avec l'AWS SDK for Java 2.x.
DynamoDB PutItem en Go — le côté écriture de la même clé.
Les expressions de condition DynamoDB — protéger les suppressions avec attribute_exists et des vérifications de valeur.
DynamoDB ConditionalCheckFailedException — ce que lève une suppression conditionnelle en échec, et quand c'est attendu.

Références

Dernière vérification le 2026-07-28 par rapport à la documentation officielle AWS liée ci-dessus.