An Ent Cheat Sheet for Schemas Queries and Mutations

package main

import (
	"context"
	"errors"
	"fmt"

	"example.test/lab/ent"
	"example.test/lab/ent/author"
	"example.test/lab/ent/book"
)

func main() {
	ctx := context.Background()
	client := open("l0755")
	defer client.Close()
	must(client.Schema.Create(ctx))

	// create
	ada := client.Author.Create().SetName("Ada").SetEmail("[email protected]").SaveX(ctx)
	client.Book.CreateBulk(
		client.Book.Create().SetTitle("A").SetPages(120).SetAuthor(ada).SetPublished(true),
		client.Book.Create().SetTitle("B").SetPages(300).SetAuthor(ada),
		client.Book.Create().SetTitle("C").SetPages(450).SetAuthor(ada).SetPublished(true),
	).ExecX(ctx)
	fmt.Println("create:", ada.ID, client.Book.Query().CountX(ctx), "books")

	// read
	first := client.Book.Query().Order(ent.Asc(book.FieldTitle)).FirstX(ctx)
	only := client.Book.Query().Where(book.Title("B")).OnlyX(ctx)
	byID := client.Book.GetX(ctx, only.ID)
	pages := client.Book.Query().Where(book.PagesGTE(300)).Order(ent.Desc(book.FieldPages)).AllX(ctx)
	titles := client.Book.Query().Where(book.Published(true)).Order(ent.Asc(book.FieldTitle)).Select(book.FieldTitle).StringsX(ctx)
	fmt.Println("read:", first.Title, only.Title, byID.Pages, len(pages), titles)
	fmt.Println("exist/count/ids:", client.Book.Query().Where(book.PagesGT(400)).ExistX(ctx), client.Book.Query().Where(book.Published(false)).CountX(ctx), client.Book.Query().Order(ent.Asc(book.FieldID)).IDsX(ctx))

	// predicates
	n := client.Book.Query().Where(book.Or(book.PagesLT(150), book.And(book.Published(true), book.Not(book.TitleEQ("C"))))).CountX(ctx)
	fmt.Println("or/and/not:", n)

	// edges
	withBooks := client.Author.Query().Where(author.HasBooksWith(book.PagesGT(400))).WithBooks().OnlyX(ctx)
	fmt.Println("edges:", withBooks.Name, len(withBooks.Edges.Books), "books;", ada.QueryBooks().CountX(ctx), "via QueryBooks;", only.QueryAuthor().OnlyX(ctx).Name, "via QueryAuthor")

	// update
	b2 := only.Update().SetPublished(true).AddPages(5).SaveX(ctx)
	rows := client.Book.Update().Where(book.PagesLT(200)).SetPublished(false).SaveX(ctx)
	fmt.Println("update:", b2.Pages, b2.Published, "| bulk rows:", rows)

	// aggregate
	var agg []struct {
		Sum int `json:"sum"`
		Max int `json:"max"`
	}
	client.Book.Query().Aggregate(ent.Sum(book.FieldPages), ent.Max(book.FieldPages)).ScanX(ctx, &agg)
	fmt.Println("aggregate:", agg)

	// transaction
	tx, _ := client.Tx(ctx)
	tx.Book.Create().SetTitle("D").SetPages(10).SetAuthorID(ada.ID).SaveX(ctx)
	tx.Rollback()
	fmt.Println("rolled back, books:", client.Book.Query().CountX(ctx))

	// errors
	_, err := client.Book.Get(ctx, 999)
	fmt.Println("errors:", ent.IsNotFound(err))
	_, err = client.Author.Create().SetName("Dup").SetEmail("[email protected]").Save(ctx)
	fmt.Println("   constraint:", ent.IsConstraintError(err))
	_, err = client.Book.Create().SetTitle("").SetPages(1).SetAuthor(ada).Save(ctx)
	var ve *ent.ValidationError
	fmt.Println("   validation:", ent.IsValidationError(err), errors.As(err, &ve))
	_, err = client.Book.Query().Where(book.PagesGT(1)).Only(ctx)
	fmt.Println("   not singular:", ent.IsNotSingular(err))

	// delete
	deleted := client.Book.Delete().Where(book.Published(false)).ExecX(ctx)
	client.Book.DeleteOneID(only.ID).ExecX(ctx)
	fmt.Println("delete:", deleted, "left", client.Book.Query().CountX(ctx))
}

package main

import (
	"database/sql"
	"log"

	"entgo.io/ent/dialect"
	entsql "entgo.io/ent/dialect/sql"
	"example.test/lab/ent"
	_ "github.com/jackc/pgx/v5/stdlib"
)

const base = "postgres://postgres:[email protected]:55432/lab?sslmode=disable"

// open recreates a schema and returns a client whose connections use it.
func open(schema string, opts ...ent.Option) *ent.Client {
	admin, err := sql.Open("pgx", base)
	if err != nil {
		log.Fatal(err)
	}
	admin.Exec("drop schema if exists " + schema + " cascade")
	admin.Exec("create schema " + schema)
	admin.Close()
	db, err := sql.Open("pgx", base+"&search_path="+schema)
	if err != nil {
		log.Fatal(err)
	}
	drv := entsql.OpenDB(dialect.Postgres, db)
	return ent.NewClient(append([]ent.Option{ent.Driver(drv)}, opts...)...)
}

func must(err error) {
	if err != nil {
		log.SetFlags(0)
		log.Fatal(err)
	}
}

package ent

//go:generate go run -mod=mod entgo.io/ent/cmd/ent generate  ./schema

package schema

import (
	"time"

	"entgo.io/ent"
	"entgo.io/ent/schema/edge"
	"entgo.io/ent/schema/field"
)

type Author struct{ ent.Schema }

func (Author) Fields() []ent.Field {
	return []ent.Field{
		field.String("name").NotEmpty(),
		field.String("email").Unique(),
		field.Time("created_at").Default(time.Now).Immutable(),
	}
}

func (Author) Edges() []ent.Edge { return []ent.Edge{edge.To("books", Book.Type)} }

package schema

import (
	"entgo.io/ent"
	"entgo.io/ent/schema/edge"
	"entgo.io/ent/schema/field"
	"entgo.io/ent/schema/index"
)

type Book struct{ ent.Schema }

func (Book) Fields() []ent.Field {
	return []ent.Field{
		field.String("title").NotEmpty(),
		field.Int("pages").Positive(),
		field.Bool("published").Default(false),
	}
}

func (Book) Edges() []ent.Edge {
	return []ent.Edge{edge.From("author", Author.Type).Ref("books").Unique().Required()}
}

func (Book) Indexes() []ent.Index { return []ent.Index{index.Fields("title").Edges("author").Unique()} }

set -e
GOFLAGS=-mod=mod go generate ./ent
go mod tidy > /dev/null 2>&1
go run .

create: 1 3 books
read: A B 300 2 [A C]
exist/count/ids: true 1 [1 2 3]
or/and/not: 1
edges: Ada 3 books; 3 via QueryBooks; Ada via QueryAuthor
update: 305 true | bulk rows: 1
aggregate: [{875 450}]
rolled back, books: 3
errors: true
   constraint: true
   validation: true true
   not singular: true
delete: 1 left 1