Soft deletes

A soft delete keeps the row but hides it, so a mistake can be undone. Add a field of type ant.DeletedAttype DeletedAt = meta.DeletedAtDeletedAt is the type of a soft delete field., and the rest follows on its own.

Turning it on

type Note struct {
	ant.Base
	Text      string
	DeletedAt ant.DeletedAt
}

var N = ant.Fields[Note]()

From then on, Deletefunc (q *Query[T]) Delete(ctx context.Context) (int64, error)Delete removes every matching row and returns the number removed., DeleteByIDfunc (t *Table[T]) DeleteByID[K comparable](ctx context.Context, key K) errorDeleteByID removes the entity with the given primary key, and stops tracking it, or returns ErrNotFound., and ant.Removefunc Remove[T any](h Handle, entity *T) errorRemove schedules an entity for deletion by the next SaveChanges. mark the row instead of removing it. Every query skips marked rows, including Findfunc (t *Table[T]) Find[K comparable](ctx context.Context, key K) (*T, error)Find returns the entity with the given primary key, or ErrNotFound., Count, Includefunc (t *Table[T]) Include[R any](rel *[]R, shape ...func(*Query[R]) *Query[R]) *Query[T]Include starts a query that loads a one-to-many relation., Has, joins, and subqueries.

n, err := db.Notes.Where(ant.Eq(&N.Text, "draft")).Delete(ctx) // marks it

all, err := db.Notes.All(ctx) // live rows only

A second delete changes nothing.

Seeing deleted rows

every, err := db.Notes.WithDeleted().All(ctx)
gone, err := db.Notes.OnlyDeleted().All(ctx)

Undoing, and really deleting

n, err := db.Notes.Where(ant.Eq(&N.Text, "draft")).Restore(ctx)

n, err = db.Notes.WithDeleted().Where(ant.Eq(&N.Text, "draft")).ForceDelete(ctx)

Restorefunc (q *Query[T]) Restore(ctx context.Context) (int64, error)Restore undeletes matching soft-deleted rows and returns how many. on a model with no DeletedAt is ant.ErrNotSoftDeletedvar ErrNotSoftDeleted = errors.New("ant: model has no DeletedAt field")ErrNotSoftDeleted reports Restore on a model with no DeletedAt field..

When a row was deleted

&N.DeletedAt.V names the column as a time. A row that was never deleted holds NULL, so Lt leaves it out.

cutoff := time.Now().AddDate(0, -3, 0)

stale, err := db.Notes.OnlyDeleted().Where(ant.Lt(&N.DeletedAt.V, cutoff)).Count(ctx)

Clearing out old rows

Prunefunc (t *Table[T]) Prune(ctx context.Context, conds ...Cond) (int64, error)Prune removes rows that meet conds for good, soft-deleted or not, in batches, so that clearing out old rows does not hold one long transaction. removes rows for good, soft-deleted or not, in batches, so it never holds one long transaction open.

removed, err := db.Notes.Prune(ctx, ant.Lt(&N.DeletedAt.V, cutoff))

Unique values

A soft-deleted row still holds its values, so a plain unique constraint stops anyone reusing that email. Index only the live rows instead.

func (User) Configure(b *ant.ModelBuilder[User]) {
	b.Index(&U.Email).Unique().Where("deleted_at IS NULL")
}

See it tested: tests/features/lifecycle/soft_delete_test.go