DynamoDB Scan en Go (AWS SDK v2)

Scan lee todos los items de una tabla o índice, página a página, y luego descarta filas opcionalmente con un FilterExpression. En AWS SDK para Go v2 el ScanPaginator integrado sigue LastEvaluatedKey hasta que se lee toda la tabla.

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)

	paginator := dynamodb.NewScanPaginator(client, &dynamodb.ScanInput{
		TableName:        aws.String("Music"),
		FilterExpression: aws.String("#filter0 >= :filterValue0"),
		ExpressionAttributeNames: map[string]string{
			"#filter0": "Year",
		},
		ExpressionAttributeValues: map[string]types.AttributeValue{
			":filterValue0": &types.AttributeValueMemberN{Value: "2010"},
		},
	})

	var items []map[string]types.AttributeValue
	for paginator.HasMorePages() {
		page, err := paginator.NextPage(ctx)
		if err != nil {
			log.Fatalf("scan: %v", err)
		}
		items = append(items, page.Items...)
	}
	fmt.Printf("Matched %d items\n", len(items))
}

Explicación

FilterExpression — se aplica después de la lectura, en el servidor. Reduce la respuesta pero no el coste: pagas por leer todos los items escaneados, filtrados o no.
ExpressionAttributeNames — el atributo filtrado lleva un alias (#filter0 → Year), lo que mantiene a salvo palabras reservadas como Year.
Paginación — cada página de Scan lee como máximo 1 MB antes de filtrar, así que una página filtrada puede volver vacía mientras la tabla aún tiene coincidencias. dynamodb.NewScanPaginator sigue llamando hasta agotar LastEvaluatedKey — nunca te pares en la primera página.
Pon Limit para limitar los items escaneados por página (antes del filtro) — no limita los items devueltos.
Para un scan grande de la tabla completa, reparte el trabajo entre goroutines con Segment / TotalSegments (un scan en paralelo).
Prefiere Query. Scan lee toda la tabla; en cualquier cosa que no sea una tabla diminuta es lento y caro.

Hazlo visualmente

¿Montando un filtro a mano? El DynamoDB Expression Builder construye el FilterExpression + los mapas de nombres/valores y copia código ejecutable.

Para explorar tablas en una interfaz gráfica — con cuadrículas de resultados filtradas y paginadas y copiar como código — descarga DynoTable, en lugar de escanear a ciegas desde un script.

Ejemplos relacionados

DynamoDB Scan en Java — el mismo scan con AWS SDK para Java 2.x.
DynamoDB Query en Go — la lectura más barata a la que normalmente deberías recurrir.
Query vs. Scan — cuándo (rara vez) se justifica un Scan.
¿Por qué mi DynamoDB Scan es lento y caro? — el modelo de costes y cómo evitarlo.
DynamoDB ProvisionedThroughputExceededException — lo que un scan de tabla completa le hace a la capacidad de una tabla aprovisionada.
DynamoDB ThrottlingException — el otro throttle, y cómo lo gestiona el retroceso exponencial.

References

Verificado por última vez el 2026-07-13 contra la documentación oficial de AWS enlazada arriba.