testmodels

var AuditProductMeta = drel.ModelMeta[AuditProduct]{
	Table:    "a_products",
	Columns:  []string{"id", "name", "price", "created_by", "updated_by", "created_at", "updated_at"},
	PKColumn: "id",
	HasAudit: true,
	AuditSetCreate: func(p *AuditProduct, actor string) {
		createdByPtr, updatedByPtr := p.AuditPtrs()
		*createdByPtr = actor
		*updatedByPtr = actor
	},
	AuditSetUpdate: func(p *AuditProduct, actor string) {
		_, updatedByPtr := p.AuditPtrs()
		*updatedByPtr = actor
	},
	Scan: func(row drel.Row) (*AuditProduct, error) {
		p := &AuditProduct{}
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		createdByPtr, updatedByPtr := p.AuditPtrs()
		err := row.Scan(idPtr, &p.name, &p.price, createdByPtr, updatedByPtr, createdAtPtr, updatedAtPtr)
		if err != nil {
			return nil, err
		}
		return p, nil
	},
	Snapshot: func(p *AuditProduct) any {
		return apSnapshot{name: p.name, price: p.price}
	},
	Diff: func(p *AuditProduct, snap any) []drel.FieldChange {
		s := snap.(apSnapshot)
		var changes []drel.FieldChange
		if p.name != s.name {
			changes = append(changes, drel.FieldChange{Column: "name", Value: p.name})
		}
		if p.price != s.price {
			changes = append(changes, drel.FieldChange{Column: "price", Value: p.price})
		}
		return changes
	},
	PKValue: func(p *AuditProduct) any { return p.ID() },
	InsertColumns: func(p *AuditProduct) ([]string, []any) {
		return []string{"name", "price", "created_by", "updated_by"}, []any{p.name, p.price, p.CreatedBy(), p.UpdatedBy()}
	},
	ScanReturning: func(p *AuditProduct, row drel.Row) error {
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		return row.Scan(idPtr, createdAtPtr, updatedAtPtr)
	},
}

var EventUserMeta = drel.ModelMeta[EventUser]{
	Table:    "event_users",
	Columns:  []string{"id", "name", "email", "created_at", "updated_at"},
	PKColumn: "id",
	Scan: func(row drel.Row) (*EventUser, error) {
		u := &EventUser{}
		idPtr, createdAtPtr, updatedAtPtr := u.ScanPtrs()
		err := row.Scan(idPtr, &u.name, &u.email, createdAtPtr, updatedAtPtr)
		if err != nil {
			return nil, err
		}
		return u, nil
	},
	Snapshot: func(u *EventUser) any {
		return eventUserSnapshot{name: u.name, email: u.email}
	},
	Diff: func(u *EventUser, snap any) []drel.FieldChange {
		s := snap.(eventUserSnapshot)
		var changes []drel.FieldChange
		if u.name != s.name {
			changes = append(changes, drel.FieldChange{Column: "name", Value: u.name})
		}
		if u.email != s.email {
			changes = append(changes, drel.FieldChange{Column: "email", Value: u.email})
		}
		return changes
	},
	PKValue: func(u *EventUser) any {
		return u.ID()
	},
	InsertColumns: func(u *EventUser) ([]string, []any) {
		return []string{"name", "email"}, []any{u.name, u.email}
	},
	ScanReturning: func(u *EventUser, row drel.Row) error {
		idPtr, createdAtPtr, updatedAtPtr := u.ScanPtrs()
		return row.Scan(idPtr, createdAtPtr, updatedAtPtr)
	},
}

var ProductMeta = drel.ModelMeta[Product]{
	Table:    "products",
	Columns:  []string{"id", "name", "price", "in_stock", "created_at", "updated_at"},
	PKColumn: "id",
	Scan: func(row drel.Row) (*Product, error) {
		p := &Product{}
		err := row.Scan(&p.ID, &p.Name, &p.Price, &p.InStock, &p.CreatedAt, &p.UpdatedAt)
		if err != nil {
			return nil, err
		}
		return p, nil
	},
	Snapshot: func(p *Product) any {
		return productSnapshot{Name: p.Name, Price: p.Price, InStock: p.InStock}
	},
	Diff: func(p *Product, snap any) []drel.FieldChange {
		s := snap.(productSnapshot)
		var changes []drel.FieldChange
		if p.Name != s.Name {
			changes = append(changes, drel.FieldChange{Column: "name", Value: p.Name})
		}
		if p.Price != s.Price {
			changes = append(changes, drel.FieldChange{Column: "price", Value: p.Price})
		}
		if p.InStock != s.InStock {
			changes = append(changes, drel.FieldChange{Column: "in_stock", Value: p.InStock})
		}
		return changes
	},
	PKValue: func(p *Product) any {
		return p.ID
	},
	ColumnValue: func(p *Product, idx int) any {
		switch idx {
		case 0:
			return p.ID
		case 1:
			return p.Name
		case 2:
			return p.Price
		case 3:
			return p.InStock
		case 4:
			return p.CreatedAt
		case 5:
			return p.UpdatedAt
		}
		return nil
	},
	InsertColumns: func(p *Product) ([]string, []any) {
		return []string{"name", "price", "in_stock"}, []any{p.Name, p.Price, p.InStock}
	},
	ScanReturning: func(p *Product, row drel.Row) error {
		return row.Scan(&p.ID, &p.CreatedAt, &p.UpdatedAt)
	},
}

var Products = struct {
	ID      drel.OrderedColumn[int]
	Name    drel.StringColumn
	Price   drel.OrderedColumn[int]
	InStock drel.BoolColumn
}{
	ID:      drel.NewOrderedCol[int]("id"),
	Name:    drel.NewStringCol("name"),
	Price:   drel.NewOrderedCol[int]("price"),
	InStock: drel.NewBoolCol("in_stock"),
}

var SoftDeleteProductMeta = drel.ModelMeta[SoftDeleteProduct]{
	Table:         "sd_products",
	Columns:       []string{"id", "name", "price", "deleted_at", "created_at", "updated_at"},
	PKColumn:      "id",
	HasSoftDelete: true,
	Filters: []drel.NamedFilter{
		{Name: "soft_delete", Clause: ast.WhereClause{
			Comparison: &ast.ComparisonNode{Column: "deleted_at", Op: ast.OpIsNull},
		}},
	},
	Scan: func(row drel.Row) (*SoftDeleteProduct, error) {
		p := &SoftDeleteProduct{}
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		err := row.Scan(idPtr, &p.name, &p.price, p.DeletedAtPtr(), createdAtPtr, updatedAtPtr)
		if err != nil {
			return nil, err
		}
		return p, nil
	},
	Snapshot: func(p *SoftDeleteProduct) any {
		return sdProductSnapshot{name: p.name, price: p.price}
	},
	Diff: func(p *SoftDeleteProduct, snap any) []drel.FieldChange {
		s := snap.(sdProductSnapshot)
		var changes []drel.FieldChange
		if p.name != s.name {
			changes = append(changes, drel.FieldChange{Column: "name", Value: p.name})
		}
		if p.price != s.price {
			changes = append(changes, drel.FieldChange{Column: "price", Value: p.price})
		}
		return changes
	},
	PKValue: func(p *SoftDeleteProduct) any { return p.ID() },
	InsertColumns: func(p *SoftDeleteProduct) ([]string, []any) {
		return []string{"name", "price"}, []any{p.name, p.price}
	},
	ScanReturning: func(p *SoftDeleteProduct, row drel.Row) error {
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		return row.Scan(idPtr, createdAtPtr, updatedAtPtr)
	},
}

var SoftDeleteProducts = struct {
	ID        drel.OrderedColumn[int]
	Name      drel.StringColumn
	Price     drel.OrderedColumn[int]
	DeletedAt drel.Column[*time.Time]
}{
	ID:        drel.NewOrderedCol[int]("id"),
	Name:      drel.NewStringCol("name"),
	Price:     drel.NewOrderedCol[int]("price"),
	DeletedAt: drel.NewCol[*time.Time]("deleted_at"),
}

var VersionedProductMeta = drel.ModelMeta[VersionedProduct]{
	Table:        "v_products",
	Columns:      []string{"id", "name", "price", "version", "created_at", "updated_at"},
	PKColumn:     "id",
	HasVersioned: true,
	VersionValue: func(p *VersionedProduct) int { return p.Version() },
	SetVersion:   func(p *VersionedProduct, v int) { *p.VersionPtr() = v },
	Scan: func(row drel.Row) (*VersionedProduct, error) {
		p := &VersionedProduct{}
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		err := row.Scan(idPtr, &p.name, &p.price, p.VersionPtr(), createdAtPtr, updatedAtPtr)
		if err != nil {
			return nil, err
		}
		return p, nil
	},
	Snapshot: func(p *VersionedProduct) any {
		return vpSnapshot{name: p.name, price: p.price}
	},
	Diff: func(p *VersionedProduct, snap any) []drel.FieldChange {
		s := snap.(vpSnapshot)
		var changes []drel.FieldChange
		if p.name != s.name {
			changes = append(changes, drel.FieldChange{Column: "name", Value: p.name})
		}
		if p.price != s.price {
			changes = append(changes, drel.FieldChange{Column: "price", Value: p.price})
		}
		return changes
	},
	PKValue: func(p *VersionedProduct) any { return p.ID() },
	InsertColumns: func(p *VersionedProduct) ([]string, []any) {
		return []string{"name", "price"}, []any{p.name, p.price}
	},
	ScanReturning: func(p *VersionedProduct, row drel.Row) error {
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		return row.Scan(idPtr, createdAtPtr, updatedAtPtr)
	},
}