SaveChanges

Change what you loaded, then call SaveChangesfunc (c *Context) SaveChanges(ctx context.Context) errorSaveChanges writes every change to tracked entities in one transaction: inserts and updates with parents first, then deletes with children first.. ant compares each entity with a snapshot it took when loading it, and writes one minimal UPDATE per changed entity, all in one transaction.

The basics

user, err := db.Users.Find(ctx, id)
if err != nil {
	return err
}

user.Age++

err = db.SaveChanges(ctx)

UPDATE "users" SET "age" = $1, "updated_at" = $2 WHERE "users"."id" = $3

Only the changed column goes out, so a value someone else changed in the meantime isn't overwritten with your stale copy. If nothing changed, no statement is sent at all.

Zero values are real

The comparison is against what was loaded, so 0, "", false, and nil are changes like any other.

user, err := db.Users.Find(ctx, id)

user.Age = 0
user.Bio = nil

err = db.SaveChanges(ctx)

A write through a pointer is seen too, and so is a change inside an ant.JSON value.

What is tracked

Allfunc (t *Table[T]) All(ctx context.Context) ([]*T, error)All returns every row., Firstfunc (t *Table[T]) First(ctx context.Context) (*T, error)First returns the first row, or ErrNotFound., Singlefunc (t *Table[T]) Single(ctx context.Context) (*T, error)Single returns the only row., and 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. track their results, and so do Insertfunc (t *Table[T]) Insert(ctx context.Context, entities ...*T) errorInsert writes entities and the new entities related to them, parents first, in one transaction, so either all are saved or none are. and the rows an 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. loads. All returns pointers, so changes in a range count.

users, err := db.Users.All(ctx)

for _, user := range users {
	user.Age = 50
}

err = db.SaveChanges(ctx)

These aren't tracked, so changing them saves nothing:

Results of	Why
Eachfunc (t *Table[T]) Each(ctx context.Context) iter.Seq2[T, error]Each streams every row.	It yields values, one at a time
Columnfunc (t *Table[T]) Column[V any](field *V) *Query[T]Column starts a query limited to the named column., Omitfunc (t *Table[T]) Omit[V any](field *V) *Query[T]Omit starts a query that leaves a column out.	Their zero fields aren't real values
NoTrackingfunc (t *Table[T]) NoTracking() *Query[T]NoTracking starts a query whose results are not tracked.	You asked
ant.Rawfunc Raw[T any](h Handle, query string, args ...any) *RawQuery[T]Raw prepares a raw SQL statement., FromRaw, Project, Select	They aren't whole entities

Several entities

SaveChanges covers everything the context tracks, in one transaction, parents before children on insert and children first on delete.

user.Age = 30
post.Title = "Edited"

err := db.SaveChanges(ctx) // two UPDATEs, one transaction

Is anything pending?

user.Age = 60

db.HasChanges() // true

One instance per row

A context holds one instance per row, so a later query returns the same pointer, with your unsaved changes.

first, err := db.Users.Find(ctx, id)

first.Age = 70

again, err := db.Users.Where(ant.Eq(&U.ID, id)).Single(ctx)

fmt.Println(first == again, again.Age) // true 70

A bulk Updatefunc (q *Query[T]) Update(ctx context.Context, a ...Assignment) (int64, error)Update applies assignments to every matching row and returns the number of rows changed. doesn't touch tracked entities. Reload picks up database changes, and they become the new baseline.

Turning it off

NoTracking opts one query out, in any position in the chain. WithTracking(false) turns tracking off for a whole context.

db, err := ant.Open[AppDB](ctx, postgres.Dialect, dsn, ant.WithTracking(false))

session := ant.Session(db, ant.WithTracking(true))

That second line is a nice pattern: a shared context that never grows, and tracking only in the sessions that actually save.

Custom comparers

Deep equality decides what changed. b.Comparerfunc (b *ModelBuilder[E]) Comparer[V any](field *V, equal func(a, b V) bool)Comparer sets how change tracking compares a field, in place of a deep comparison. overrides it, for values where that is wrong, such as a list whose order means nothing.

type Tagged struct {
	ID    int64
	Items ant.JSON[[]string]
}

func (Tagged) Configure(b *ant.ModelBuilder[Tagged]) {
	b.Comparer(&TG.Items, sameItems)
}

func sameItems(a, b ant.JSON[[]string]) bool {
	return slices.Equal(slices.Sorted(slices.Values(a.V)), slices.Sorted(slices.Values(b.V)))
}

var TG = ant.Fields[Tagged]()

A context remembers everything it loads

A tracker keeps growing until it's cleared, and a shared one mixes up concurrent requests. Use a session per unit of work.

See it tested: tests/features/change_tracking/save_changes_test.go