DynamoDB DeleteItem in Go (AWS SDK v2)

client.DeleteItem nimmt ein dynamodb.DeleteItemInput entgegen, das den vollständigen Primary Key trägt. Mit types.ReturnValueAllOld sagt dir die Antwort, ob überhaupt etwas da war; sobald du eine ConditionExpression ergänzt, sagt dir der Fehler, warum es geblieben ist.

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

Erklärung

• types.ReturnValueAllOld ist eine typisierte Konstante, nicht der String "ALL_OLD" — das Feld nimmt ein types.ReturnValue, ein Tippfehler ist also ein Compile-Fehler statt einer ValidationException zur Laufzeit. DeleteItem akzeptiert nur NONE und ALL_OLD; der Rest des Enums wird mit UpdateItem geteilt.
• len(out.Attributes) == 0 ist das einzige Signal, das du bekommst — einen Key zu löschen, der nie da war, gelingt, und das SDK gibt eine nil-Map statt eines Fehlers zurück. Nichts sonst trennt „gelöscht" von „es gab nichts zu löschen".
• Fang den Guard-Fehlschlag mit errors.As ab — var ccfe *types.ConditionalCheckFailedException, dann errors.As(err, &ccfe). Ein direkter Vergleich verfehlt ihn, weil Go v2 Service-Fehler in einen Smithy-Operation-Error einpackt.
• Die Exception kann das unterlegene Item tragen — setze ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailureAllOld und ccfe.Item hält die Zeile so, wie DynamoDB sie gesehen hat. So kannst du den Wert loggen, der den Guard tatsächlich nicht bestanden hat, statt ihn neu zu lesen. Das SDK dokumentiert den Preis: "No read capacity units are consumed."
• Ein Item pro Aufruf — es gibt keine Delete-all-API. Viele Items zu löschen bedeutet, erst die Keys einzusammeln und die Writes zu batchen, oder die Tabelle zu verwerfen.

Mach es visuell

Der Guard ist die fummelige Hälfte: eine ConditionExpression plus die zugehörigen Name- und Value-Maps. Der DynamoDB Expression Builder setzt alle drei aus einem Formular zusammen.

DynoTable geht dasselbe Risiko vom anderen Ende an. Ein Delete landet zuerst in einem Panel für ausstehende Änderungen und erreicht die Tabelle erst, wenn du es committest — eine falsche Zeile ist also etwas, das du verwirfst, statt etwas, das du wiederherstellst. DynoTable herunterladen.

Verwandte Beispiele

• DynamoDB DeleteItem in Java — dasselbe Delete mit AWS SDK for Java 2.x.
• DynamoDB PutItem in Go — die Schreibseite desselben Keys.
• DynamoDB Condition Expressions — Deletes mit attribute_exists und Wertprüfungen absichern.
• DynamoDB ConditionalCheckFailedException — was ein fehlgeschlagenes bedingtes Delete wirft und wann es erwartet ist.

Referenzen

• DeleteItem — Amazon DynamoDB API Reference
• Use DeleteItem with an AWS SDK or CLI — Amazon DynamoDB Developer Guide
• dynamodb package — AWS SDK for Go v2 (pkg.go.dev)
• dynamodb/types package — AWS SDK for Go v2 (pkg.go.dev)
• Condition expressions — Amazon DynamoDB Developer Guide

Zuletzt verifiziert am 2026-07-28 gegen die oben verlinkte offizielle AWS-Dokumentation.