// Code generated by BobGen psql v0.42.5. DO NOT EDIT.
// This file is meant to be re-generated in place and/or deleted at any time.

package models

import (
	"context"
	"fmt"
	"io"

	"github.com/Gleipnir-Technology/bob"
	"github.com/Gleipnir-Technology/bob/dialect/psql"
	"github.com/Gleipnir-Technology/bob/dialect/psql/dialect"
	"github.com/Gleipnir-Technology/bob/dialect/psql/dm"
	"github.com/Gleipnir-Technology/bob/dialect/psql/sm"
	"github.com/Gleipnir-Technology/bob/dialect/psql/um"
	"github.com/Gleipnir-Technology/bob/expr"
	"github.com/Gleipnir-Technology/bob/orm"
	"github.com/Gleipnir-Technology/bob/types/pgtypes"
	"github.com/aarondl/opt/omit"
	"github.com/stephenafamo/scan"
)

// CommsEmailContact is an object representing the database table.
type CommsEmailContact struct {
	Address      string `db:"address,pk" `
	Confirmed    bool   `db:"confirmed" `
	IsSubscribed bool   `db:"is_subscribed" `
	PublicID     string `db:"public_id" `

	R commsEmailContactR `db:"-" `
}

// CommsEmailContactSlice is an alias for a slice of pointers to CommsEmailContact.
// This should almost always be used instead of []*CommsEmailContact.
type CommsEmailContactSlice []*CommsEmailContact

// CommsEmailContacts contains methods to work with the email_contact table
var CommsEmailContacts = psql.NewTablex[*CommsEmailContact, CommsEmailContactSlice, *CommsEmailContactSetter]("comms", "email_contact", buildCommsEmailContactColumns("comms.email_contact"))

// CommsEmailContactsQuery is a query on the email_contact table
type CommsEmailContactsQuery = *psql.ViewQuery[*CommsEmailContact, CommsEmailContactSlice]

// commsEmailContactR is where relationships are stored.
type commsEmailContactR struct {
	DestinationEmailLogs                CommsEmailLogSlice                      // comms.email_log.email_log_destination_fkey
	Organizations                       OrganizationSlice                       // district_subscription_email.district_subscription_email_email_contact_address_fkeydistrict_subscription_email.district_subscription_email_organization_id_fkey
	EmailAddressNotifyEmails            PublicreportNotifyEmailSlice            // publicreport.notify_email.notify_email_email_address_fkey
	EmailAddressNotifyEmailNuisanceOlds PublicreportNotifyEmailNuisanceOldSlice // publicreport.notify_email_nuisance_old.notify_email_nuisance_email_address_fkey
	EmailAddressNotifyEmailWaterOlds    PublicreportNotifyEmailWaterOldSlice    // publicreport.notify_email_water_old.notify_email_pool_email_address_fkey
	EmailAddressSubscribeEmails         PublicreportSubscribeEmailSlice         // publicreport.subscribe_email.subscribe_email_email_address_fkey
}

func buildCommsEmailContactColumns(alias string) commsEmailContactColumns {
	return commsEmailContactColumns{
		ColumnsExpr: expr.NewColumnsExpr(
			"address", "confirmed", "is_subscribed", "public_id",
		).WithParent("comms.email_contact"),
		tableAlias:   alias,
		Address:      psql.Quote(alias, "address"),
		Confirmed:    psql.Quote(alias, "confirmed"),
		IsSubscribed: psql.Quote(alias, "is_subscribed"),
		PublicID:     psql.Quote(alias, "public_id"),
	}
}

type commsEmailContactColumns struct {
	expr.ColumnsExpr
	tableAlias   string
	Address      psql.Expression
	Confirmed    psql.Expression
	IsSubscribed psql.Expression
	PublicID     psql.Expression
}

func (c commsEmailContactColumns) Alias() string {
	return c.tableAlias
}

func (commsEmailContactColumns) AliasedAs(alias string) commsEmailContactColumns {
	return buildCommsEmailContactColumns(alias)
}

// CommsEmailContactSetter is used for insert/upsert/update operations
// All values are optional, and do not have to be set
// Generated columns are not included
type CommsEmailContactSetter struct {
	Address      omit.Val[string] `db:"address,pk" `
	Confirmed    omit.Val[bool]   `db:"confirmed" `
	IsSubscribed omit.Val[bool]   `db:"is_subscribed" `
	PublicID     omit.Val[string] `db:"public_id" `
}

func (s CommsEmailContactSetter) SetColumns() []string {
	vals := make([]string, 0, 4)
	if s.Address.IsValue() {
		vals = append(vals, "address")
	}
	if s.Confirmed.IsValue() {
		vals = append(vals, "confirmed")
	}
	if s.IsSubscribed.IsValue() {
		vals = append(vals, "is_subscribed")
	}
	if s.PublicID.IsValue() {
		vals = append(vals, "public_id")
	}
	return vals
}

func (s CommsEmailContactSetter) Overwrite(t *CommsEmailContact) {
	if s.Address.IsValue() {
		t.Address = s.Address.MustGet()
	}
	if s.Confirmed.IsValue() {
		t.Confirmed = s.Confirmed.MustGet()
	}
	if s.IsSubscribed.IsValue() {
		t.IsSubscribed = s.IsSubscribed.MustGet()
	}
	if s.PublicID.IsValue() {
		t.PublicID = s.PublicID.MustGet()
	}
}

func (s *CommsEmailContactSetter) Apply(q *dialect.InsertQuery) {
	q.AppendHooks(func(ctx context.Context, exec bob.Executor) (context.Context, error) {
		return CommsEmailContacts.BeforeInsertHooks.RunHooks(ctx, exec, s)
	})

	q.AppendValues(bob.ExpressionFunc(func(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
		vals := make([]bob.Expression, 4)
		if s.Address.IsValue() {
			vals[0] = psql.Arg(s.Address.MustGet())
		} else {
			vals[0] = psql.Raw("DEFAULT")
		}

		if s.Confirmed.IsValue() {
			vals[1] = psql.Arg(s.Confirmed.MustGet())
		} else {
			vals[1] = psql.Raw("DEFAULT")
		}

		if s.IsSubscribed.IsValue() {
			vals[2] = psql.Arg(s.IsSubscribed.MustGet())
		} else {
			vals[2] = psql.Raw("DEFAULT")
		}

		if s.PublicID.IsValue() {
			vals[3] = psql.Arg(s.PublicID.MustGet())
		} else {
			vals[3] = psql.Raw("DEFAULT")
		}

		return bob.ExpressSlice(ctx, w, d, start, vals, "", ", ", "")
	}))
}

func (s CommsEmailContactSetter) UpdateMod() bob.Mod[*dialect.UpdateQuery] {
	return um.Set(s.Expressions()...)
}

func (s CommsEmailContactSetter) Expressions(prefix ...string) []bob.Expression {
	exprs := make([]bob.Expression, 0, 4)

	if s.Address.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "address")...),
			psql.Arg(s.Address),
		}})
	}

	if s.Confirmed.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "confirmed")...),
			psql.Arg(s.Confirmed),
		}})
	}

	if s.IsSubscribed.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "is_subscribed")...),
			psql.Arg(s.IsSubscribed),
		}})
	}

	if s.PublicID.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "public_id")...),
			psql.Arg(s.PublicID),
		}})
	}

	return exprs
}

// FindCommsEmailContact retrieves a single record by primary key
// If cols is empty Find will return all columns.
func FindCommsEmailContact(ctx context.Context, exec bob.Executor, AddressPK string, cols ...string) (*CommsEmailContact, error) {
	if len(cols) == 0 {
		return CommsEmailContacts.Query(
			sm.Where(CommsEmailContacts.Columns.Address.EQ(psql.Arg(AddressPK))),
		).One(ctx, exec)
	}

	return CommsEmailContacts.Query(
		sm.Where(CommsEmailContacts.Columns.Address.EQ(psql.Arg(AddressPK))),
		sm.Columns(CommsEmailContacts.Columns.Only(cols...)),
	).One(ctx, exec)
}

// CommsEmailContactExists checks the presence of a single record by primary key
func CommsEmailContactExists(ctx context.Context, exec bob.Executor, AddressPK string) (bool, error) {
	return CommsEmailContacts.Query(
		sm.Where(CommsEmailContacts.Columns.Address.EQ(psql.Arg(AddressPK))),
	).Exists(ctx, exec)
}

// AfterQueryHook is called after CommsEmailContact is retrieved from the database
func (o *CommsEmailContact) AfterQueryHook(ctx context.Context, exec bob.Executor, queryType bob.QueryType) error {
	var err error

	switch queryType {
	case bob.QueryTypeSelect:
		ctx, err = CommsEmailContacts.AfterSelectHooks.RunHooks(ctx, exec, CommsEmailContactSlice{o})
	case bob.QueryTypeInsert:
		ctx, err = CommsEmailContacts.AfterInsertHooks.RunHooks(ctx, exec, CommsEmailContactSlice{o})
	case bob.QueryTypeUpdate:
		ctx, err = CommsEmailContacts.AfterUpdateHooks.RunHooks(ctx, exec, CommsEmailContactSlice{o})
	case bob.QueryTypeDelete:
		ctx, err = CommsEmailContacts.AfterDeleteHooks.RunHooks(ctx, exec, CommsEmailContactSlice{o})
	}

	return err
}

// primaryKeyVals returns the primary key values of the CommsEmailContact
func (o *CommsEmailContact) primaryKeyVals() bob.Expression {
	return psql.Arg(o.Address)
}

func (o *CommsEmailContact) pkEQ() dialect.Expression {
	return psql.Quote("comms.email_contact", "address").EQ(bob.ExpressionFunc(func(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
		return o.primaryKeyVals().WriteSQL(ctx, w, d, start)
	}))
}

// Update uses an executor to update the CommsEmailContact
func (o *CommsEmailContact) Update(ctx context.Context, exec bob.Executor, s *CommsEmailContactSetter) error {
	v, err := CommsEmailContacts.Update(s.UpdateMod(), um.Where(o.pkEQ())).One(ctx, exec)
	if err != nil {
		return err
	}

	o.R = v.R
	*o = *v

	return nil
}

// Delete deletes a single CommsEmailContact record with an executor
func (o *CommsEmailContact) Delete(ctx context.Context, exec bob.Executor) error {
	_, err := CommsEmailContacts.Delete(dm.Where(o.pkEQ())).Exec(ctx, exec)
	return err
}

// Reload refreshes the CommsEmailContact using the executor
func (o *CommsEmailContact) Reload(ctx context.Context, exec bob.Executor) error {
	o2, err := CommsEmailContacts.Query(
		sm.Where(CommsEmailContacts.Columns.Address.EQ(psql.Arg(o.Address))),
	).One(ctx, exec)
	if err != nil {
		return err
	}
	o2.R = o.R
	*o = *o2

	return nil
}

// AfterQueryHook is called after CommsEmailContactSlice is retrieved from the database
func (o CommsEmailContactSlice) AfterQueryHook(ctx context.Context, exec bob.Executor, queryType bob.QueryType) error {
	var err error

	switch queryType {
	case bob.QueryTypeSelect:
		ctx, err = CommsEmailContacts.AfterSelectHooks.RunHooks(ctx, exec, o)
	case bob.QueryTypeInsert:
		ctx, err = CommsEmailContacts.AfterInsertHooks.RunHooks(ctx, exec, o)
	case bob.QueryTypeUpdate:
		ctx, err = CommsEmailContacts.AfterUpdateHooks.RunHooks(ctx, exec, o)
	case bob.QueryTypeDelete:
		ctx, err = CommsEmailContacts.AfterDeleteHooks.RunHooks(ctx, exec, o)
	}

	return err
}

func (o CommsEmailContactSlice) pkIN() dialect.Expression {
	if len(o) == 0 {
		return psql.Raw("NULL")
	}

	return psql.Quote("comms.email_contact", "address").In(bob.ExpressionFunc(func(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
		pkPairs := make([]bob.Expression, len(o))
		for i, row := range o {
			pkPairs[i] = row.primaryKeyVals()
		}
		return bob.ExpressSlice(ctx, w, d, start, pkPairs, "", ", ", "")
	}))
}

// copyMatchingRows finds models in the given slice that have the same primary key
// then it first copies the existing relationships from the old model to the new model
// and then replaces the old model in the slice with the new model
func (o CommsEmailContactSlice) copyMatchingRows(from ...*CommsEmailContact) {
	for i, old := range o {
		for _, new := range from {
			if new.Address != old.Address {
				continue
			}
			new.R = old.R
			o[i] = new
			break
		}
	}
}

// UpdateMod modifies an update query with "WHERE primary_key IN (o...)"
func (o CommsEmailContactSlice) UpdateMod() bob.Mod[*dialect.UpdateQuery] {
	return bob.ModFunc[*dialect.UpdateQuery](func(q *dialect.UpdateQuery) {
		q.AppendHooks(func(ctx context.Context, exec bob.Executor) (context.Context, error) {
			return CommsEmailContacts.BeforeUpdateHooks.RunHooks(ctx, exec, o)
		})

		q.AppendLoader(bob.LoaderFunc(func(ctx context.Context, exec bob.Executor, retrieved any) error {
			var err error
			switch retrieved := retrieved.(type) {
			case *CommsEmailContact:
				o.copyMatchingRows(retrieved)
			case []*CommsEmailContact:
				o.copyMatchingRows(retrieved...)
			case CommsEmailContactSlice:
				o.copyMatchingRows(retrieved...)
			default:
				// If the retrieved value is not a CommsEmailContact or a slice of CommsEmailContact
				// then run the AfterUpdateHooks on the slice
				_, err = CommsEmailContacts.AfterUpdateHooks.RunHooks(ctx, exec, o)
			}

			return err
		}))

		q.AppendWhere(o.pkIN())
	})
}

// DeleteMod modifies an delete query with "WHERE primary_key IN (o...)"
func (o CommsEmailContactSlice) DeleteMod() bob.Mod[*dialect.DeleteQuery] {
	return bob.ModFunc[*dialect.DeleteQuery](func(q *dialect.DeleteQuery) {
		q.AppendHooks(func(ctx context.Context, exec bob.Executor) (context.Context, error) {
			return CommsEmailContacts.BeforeDeleteHooks.RunHooks(ctx, exec, o)
		})

		q.AppendLoader(bob.LoaderFunc(func(ctx context.Context, exec bob.Executor, retrieved any) error {
			var err error
			switch retrieved := retrieved.(type) {
			case *CommsEmailContact:
				o.copyMatchingRows(retrieved)
			case []*CommsEmailContact:
				o.copyMatchingRows(retrieved...)
			case CommsEmailContactSlice:
				o.copyMatchingRows(retrieved...)
			default:
				// If the retrieved value is not a CommsEmailContact or a slice of CommsEmailContact
				// then run the AfterDeleteHooks on the slice
				_, err = CommsEmailContacts.AfterDeleteHooks.RunHooks(ctx, exec, o)
			}

			return err
		}))

		q.AppendWhere(o.pkIN())
	})
}

func (o CommsEmailContactSlice) UpdateAll(ctx context.Context, exec bob.Executor, vals CommsEmailContactSetter) error {
	if len(o) == 0 {
		return nil
	}

	_, err := CommsEmailContacts.Update(vals.UpdateMod(), o.UpdateMod()).All(ctx, exec)
	return err
}

func (o CommsEmailContactSlice) DeleteAll(ctx context.Context, exec bob.Executor) error {
	if len(o) == 0 {
		return nil
	}

	_, err := CommsEmailContacts.Delete(o.DeleteMod()).Exec(ctx, exec)
	return err
}

func (o CommsEmailContactSlice) ReloadAll(ctx context.Context, exec bob.Executor) error {
	if len(o) == 0 {
		return nil
	}

	o2, err := CommsEmailContacts.Query(sm.Where(o.pkIN())).All(ctx, exec)
	if err != nil {
		return err
	}

	o.copyMatchingRows(o2...)

	return nil
}

// DestinationEmailLogs starts a query for related objects on comms.email_log
func (o *CommsEmailContact) DestinationEmailLogs(mods ...bob.Mod[*dialect.SelectQuery]) CommsEmailLogsQuery {
	return CommsEmailLogs.Query(append(mods,
		sm.Where(CommsEmailLogs.Columns.Destination.EQ(psql.Arg(o.Address))),
	)...)
}

func (os CommsEmailContactSlice) DestinationEmailLogs(mods ...bob.Mod[*dialect.SelectQuery]) CommsEmailLogsQuery {
	pkAddress := make(pgtypes.Array[string], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkAddress = append(pkAddress, o.Address)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkAddress), "text[]")),
	))

	return CommsEmailLogs.Query(append(mods,
		sm.Where(psql.Group(CommsEmailLogs.Columns.Destination).OP("IN", PKArgExpr)),
	)...)
}

// Organizations starts a query for related objects on organization
func (o *CommsEmailContact) Organizations(mods ...bob.Mod[*dialect.SelectQuery]) OrganizationsQuery {
	return Organizations.Query(append(mods,
		sm.InnerJoin(DistrictSubscriptionEmails.NameAs()).On(
			Organizations.Columns.ID.EQ(DistrictSubscriptionEmails.Columns.OrganizationID)),
		sm.Where(DistrictSubscriptionEmails.Columns.EmailContactAddress.EQ(psql.Arg(o.Address))),
	)...)
}

func (os CommsEmailContactSlice) Organizations(mods ...bob.Mod[*dialect.SelectQuery]) OrganizationsQuery {
	pkAddress := make(pgtypes.Array[string], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkAddress = append(pkAddress, o.Address)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkAddress), "text[]")),
	))

	return Organizations.Query(append(mods,
		sm.InnerJoin(DistrictSubscriptionEmails.NameAs()).On(
			Organizations.Columns.ID.EQ(DistrictSubscriptionEmails.Columns.OrganizationID),
		),
		sm.Where(psql.Group(DistrictSubscriptionEmails.Columns.EmailContactAddress).OP("IN", PKArgExpr)),
	)...)
}

// EmailAddressNotifyEmails starts a query for related objects on publicreport.notify_email
func (o *CommsEmailContact) EmailAddressNotifyEmails(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportNotifyEmailsQuery {
	return PublicreportNotifyEmails.Query(append(mods,
		sm.Where(PublicreportNotifyEmails.Columns.EmailAddress.EQ(psql.Arg(o.Address))),
	)...)
}

func (os CommsEmailContactSlice) EmailAddressNotifyEmails(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportNotifyEmailsQuery {
	pkAddress := make(pgtypes.Array[string], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkAddress = append(pkAddress, o.Address)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkAddress), "text[]")),
	))

	return PublicreportNotifyEmails.Query(append(mods,
		sm.Where(psql.Group(PublicreportNotifyEmails.Columns.EmailAddress).OP("IN", PKArgExpr)),
	)...)
}

// EmailAddressNotifyEmailNuisanceOlds starts a query for related objects on publicreport.notify_email_nuisance_old
func (o *CommsEmailContact) EmailAddressNotifyEmailNuisanceOlds(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportNotifyEmailNuisanceOldsQuery {
	return PublicreportNotifyEmailNuisanceOlds.Query(append(mods,
		sm.Where(PublicreportNotifyEmailNuisanceOlds.Columns.EmailAddress.EQ(psql.Arg(o.Address))),
	)...)
}

func (os CommsEmailContactSlice) EmailAddressNotifyEmailNuisanceOlds(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportNotifyEmailNuisanceOldsQuery {
	pkAddress := make(pgtypes.Array[string], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkAddress = append(pkAddress, o.Address)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkAddress), "text[]")),
	))

	return PublicreportNotifyEmailNuisanceOlds.Query(append(mods,
		sm.Where(psql.Group(PublicreportNotifyEmailNuisanceOlds.Columns.EmailAddress).OP("IN", PKArgExpr)),
	)...)
}

// EmailAddressNotifyEmailWaterOlds starts a query for related objects on publicreport.notify_email_water_old
func (o *CommsEmailContact) EmailAddressNotifyEmailWaterOlds(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportNotifyEmailWaterOldsQuery {
	return PublicreportNotifyEmailWaterOlds.Query(append(mods,
		sm.Where(PublicreportNotifyEmailWaterOlds.Columns.EmailAddress.EQ(psql.Arg(o.Address))),
	)...)
}

func (os CommsEmailContactSlice) EmailAddressNotifyEmailWaterOlds(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportNotifyEmailWaterOldsQuery {
	pkAddress := make(pgtypes.Array[string], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkAddress = append(pkAddress, o.Address)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkAddress), "text[]")),
	))

	return PublicreportNotifyEmailWaterOlds.Query(append(mods,
		sm.Where(psql.Group(PublicreportNotifyEmailWaterOlds.Columns.EmailAddress).OP("IN", PKArgExpr)),
	)...)
}

// EmailAddressSubscribeEmails starts a query for related objects on publicreport.subscribe_email
func (o *CommsEmailContact) EmailAddressSubscribeEmails(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportSubscribeEmailsQuery {
	return PublicreportSubscribeEmails.Query(append(mods,
		sm.Where(PublicreportSubscribeEmails.Columns.EmailAddress.EQ(psql.Arg(o.Address))),
	)...)
}

func (os CommsEmailContactSlice) EmailAddressSubscribeEmails(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportSubscribeEmailsQuery {
	pkAddress := make(pgtypes.Array[string], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkAddress = append(pkAddress, o.Address)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkAddress), "text[]")),
	))

	return PublicreportSubscribeEmails.Query(append(mods,
		sm.Where(psql.Group(PublicreportSubscribeEmails.Columns.EmailAddress).OP("IN", PKArgExpr)),
	)...)
}

func insertCommsEmailContactDestinationEmailLogs0(ctx context.Context, exec bob.Executor, commsEmailLogs1 []*CommsEmailLogSetter, commsEmailContact0 *CommsEmailContact) (CommsEmailLogSlice, error) {
	for i := range commsEmailLogs1 {
		commsEmailLogs1[i].Destination = omit.From(commsEmailContact0.Address)
	}

	ret, err := CommsEmailLogs.Insert(bob.ToMods(commsEmailLogs1...)).All(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertCommsEmailContactDestinationEmailLogs0: %w", err)
	}

	return ret, nil
}

func attachCommsEmailContactDestinationEmailLogs0(ctx context.Context, exec bob.Executor, count int, commsEmailLogs1 CommsEmailLogSlice, commsEmailContact0 *CommsEmailContact) (CommsEmailLogSlice, error) {
	setter := &CommsEmailLogSetter{
		Destination: omit.From(commsEmailContact0.Address),
	}

	err := commsEmailLogs1.UpdateAll(ctx, exec, *setter)
	if err != nil {
		return nil, fmt.Errorf("attachCommsEmailContactDestinationEmailLogs0: %w", err)
	}

	return commsEmailLogs1, nil
}

func (commsEmailContact0 *CommsEmailContact) InsertDestinationEmailLogs(ctx context.Context, exec bob.Executor, related ...*CommsEmailLogSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	commsEmailLogs1, err := insertCommsEmailContactDestinationEmailLogs0(ctx, exec, related, commsEmailContact0)
	if err != nil {
		return err
	}

	commsEmailContact0.R.DestinationEmailLogs = append(commsEmailContact0.R.DestinationEmailLogs, commsEmailLogs1...)

	for _, rel := range commsEmailLogs1 {
		rel.R.DestinationEmailContact = commsEmailContact0
	}
	return nil
}

func (commsEmailContact0 *CommsEmailContact) AttachDestinationEmailLogs(ctx context.Context, exec bob.Executor, related ...*CommsEmailLog) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	commsEmailLogs1 := CommsEmailLogSlice(related)

	_, err = attachCommsEmailContactDestinationEmailLogs0(ctx, exec, len(related), commsEmailLogs1, commsEmailContact0)
	if err != nil {
		return err
	}

	commsEmailContact0.R.DestinationEmailLogs = append(commsEmailContact0.R.DestinationEmailLogs, commsEmailLogs1...)

	for _, rel := range related {
		rel.R.DestinationEmailContact = commsEmailContact0
	}

	return nil
}

func attachCommsEmailContactOrganizations0(ctx context.Context, exec bob.Executor, count int, commsEmailContact0 *CommsEmailContact, organizations2 OrganizationSlice) (DistrictSubscriptionEmailSlice, error) {
	setters := make([]*DistrictSubscriptionEmailSetter, count)
	for i := range count {
		setters[i] = &DistrictSubscriptionEmailSetter{
			EmailContactAddress: omit.From(commsEmailContact0.Address),
			OrganizationID:      omit.From(organizations2[i].ID),
		}
	}

	districtSubscriptionEmails1, err := DistrictSubscriptionEmails.Insert(bob.ToMods(setters...)).All(ctx, exec)
	if err != nil {
		return nil, fmt.Errorf("attachCommsEmailContactOrganizations0: %w", err)
	}

	return districtSubscriptionEmails1, nil
}

func (commsEmailContact0 *CommsEmailContact) InsertOrganizations(ctx context.Context, exec bob.Executor, related ...*OrganizationSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	inserted, err := Organizations.Insert(bob.ToMods(related...)).All(ctx, exec)
	if err != nil {
		return fmt.Errorf("inserting related objects: %w", err)
	}
	organizations2 := OrganizationSlice(inserted)

	_, err = attachCommsEmailContactOrganizations0(ctx, exec, len(related), commsEmailContact0, organizations2)
	if err != nil {
		return err
	}

	commsEmailContact0.R.Organizations = append(commsEmailContact0.R.Organizations, organizations2...)

	for _, rel := range organizations2 {
		rel.R.EmailContacts = append(rel.R.EmailContacts, commsEmailContact0)
	}
	return nil
}

func (commsEmailContact0 *CommsEmailContact) AttachOrganizations(ctx context.Context, exec bob.Executor, related ...*Organization) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	organizations2 := OrganizationSlice(related)

	_, err = attachCommsEmailContactOrganizations0(ctx, exec, len(related), commsEmailContact0, organizations2)
	if err != nil {
		return err
	}

	commsEmailContact0.R.Organizations = append(commsEmailContact0.R.Organizations, organizations2...)

	for _, rel := range related {
		rel.R.EmailContacts = append(rel.R.EmailContacts, commsEmailContact0)
	}

	return nil
}

func insertCommsEmailContactEmailAddressNotifyEmails0(ctx context.Context, exec bob.Executor, publicreportNotifyEmails1 []*PublicreportNotifyEmailSetter, commsEmailContact0 *CommsEmailContact) (PublicreportNotifyEmailSlice, error) {
	for i := range publicreportNotifyEmails1 {
		publicreportNotifyEmails1[i].EmailAddress = omit.From(commsEmailContact0.Address)
	}

	ret, err := PublicreportNotifyEmails.Insert(bob.ToMods(publicreportNotifyEmails1...)).All(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertCommsEmailContactEmailAddressNotifyEmails0: %w", err)
	}

	return ret, nil
}

func attachCommsEmailContactEmailAddressNotifyEmails0(ctx context.Context, exec bob.Executor, count int, publicreportNotifyEmails1 PublicreportNotifyEmailSlice, commsEmailContact0 *CommsEmailContact) (PublicreportNotifyEmailSlice, error) {
	setter := &PublicreportNotifyEmailSetter{
		EmailAddress: omit.From(commsEmailContact0.Address),
	}

	err := publicreportNotifyEmails1.UpdateAll(ctx, exec, *setter)
	if err != nil {
		return nil, fmt.Errorf("attachCommsEmailContactEmailAddressNotifyEmails0: %w", err)
	}

	return publicreportNotifyEmails1, nil
}

func (commsEmailContact0 *CommsEmailContact) InsertEmailAddressNotifyEmails(ctx context.Context, exec bob.Executor, related ...*PublicreportNotifyEmailSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	publicreportNotifyEmails1, err := insertCommsEmailContactEmailAddressNotifyEmails0(ctx, exec, related, commsEmailContact0)
	if err != nil {
		return err
	}

	commsEmailContact0.R.EmailAddressNotifyEmails = append(commsEmailContact0.R.EmailAddressNotifyEmails, publicreportNotifyEmails1...)

	for _, rel := range publicreportNotifyEmails1 {
		rel.R.EmailAddressEmailContact = commsEmailContact0
	}
	return nil
}

func (commsEmailContact0 *CommsEmailContact) AttachEmailAddressNotifyEmails(ctx context.Context, exec bob.Executor, related ...*PublicreportNotifyEmail) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	publicreportNotifyEmails1 := PublicreportNotifyEmailSlice(related)

	_, err = attachCommsEmailContactEmailAddressNotifyEmails0(ctx, exec, len(related), publicreportNotifyEmails1, commsEmailContact0)
	if err != nil {
		return err
	}

	commsEmailContact0.R.EmailAddressNotifyEmails = append(commsEmailContact0.R.EmailAddressNotifyEmails, publicreportNotifyEmails1...)

	for _, rel := range related {
		rel.R.EmailAddressEmailContact = commsEmailContact0
	}

	return nil
}

func insertCommsEmailContactEmailAddressNotifyEmailNuisanceOlds0(ctx context.Context, exec bob.Executor, publicreportNotifyEmailNuisanceOlds1 []*PublicreportNotifyEmailNuisanceOldSetter, commsEmailContact0 *CommsEmailContact) (PublicreportNotifyEmailNuisanceOldSlice, error) {
	for i := range publicreportNotifyEmailNuisanceOlds1 {
		publicreportNotifyEmailNuisanceOlds1[i].EmailAddress = omit.From(commsEmailContact0.Address)
	}

	ret, err := PublicreportNotifyEmailNuisanceOlds.Insert(bob.ToMods(publicreportNotifyEmailNuisanceOlds1...)).All(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertCommsEmailContactEmailAddressNotifyEmailNuisanceOlds0: %w", err)
	}

	return ret, nil
}

func attachCommsEmailContactEmailAddressNotifyEmailNuisanceOlds0(ctx context.Context, exec bob.Executor, count int, publicreportNotifyEmailNuisanceOlds1 PublicreportNotifyEmailNuisanceOldSlice, commsEmailContact0 *CommsEmailContact) (PublicreportNotifyEmailNuisanceOldSlice, error) {
	setter := &PublicreportNotifyEmailNuisanceOldSetter{
		EmailAddress: omit.From(commsEmailContact0.Address),
	}

	err := publicreportNotifyEmailNuisanceOlds1.UpdateAll(ctx, exec, *setter)
	if err != nil {
		return nil, fmt.Errorf("attachCommsEmailContactEmailAddressNotifyEmailNuisanceOlds0: %w", err)
	}

	return publicreportNotifyEmailNuisanceOlds1, nil
}

func (commsEmailContact0 *CommsEmailContact) InsertEmailAddressNotifyEmailNuisanceOlds(ctx context.Context, exec bob.Executor, related ...*PublicreportNotifyEmailNuisanceOldSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	publicreportNotifyEmailNuisanceOlds1, err := insertCommsEmailContactEmailAddressNotifyEmailNuisanceOlds0(ctx, exec, related, commsEmailContact0)
	if err != nil {
		return err
	}

	commsEmailContact0.R.EmailAddressNotifyEmailNuisanceOlds = append(commsEmailContact0.R.EmailAddressNotifyEmailNuisanceOlds, publicreportNotifyEmailNuisanceOlds1...)

	for _, rel := range publicreportNotifyEmailNuisanceOlds1 {
		rel.R.EmailAddressEmailContact = commsEmailContact0
	}
	return nil
}

func (commsEmailContact0 *CommsEmailContact) AttachEmailAddressNotifyEmailNuisanceOlds(ctx context.Context, exec bob.Executor, related ...*PublicreportNotifyEmailNuisanceOld) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	publicreportNotifyEmailNuisanceOlds1 := PublicreportNotifyEmailNuisanceOldSlice(related)

	_, err = attachCommsEmailContactEmailAddressNotifyEmailNuisanceOlds0(ctx, exec, len(related), publicreportNotifyEmailNuisanceOlds1, commsEmailContact0)
	if err != nil {
		return err
	}

	commsEmailContact0.R.EmailAddressNotifyEmailNuisanceOlds = append(commsEmailContact0.R.EmailAddressNotifyEmailNuisanceOlds, publicreportNotifyEmailNuisanceOlds1...)

	for _, rel := range related {
		rel.R.EmailAddressEmailContact = commsEmailContact0
	}

	return nil
}

func insertCommsEmailContactEmailAddressNotifyEmailWaterOlds0(ctx context.Context, exec bob.Executor, publicreportNotifyEmailWaterOlds1 []*PublicreportNotifyEmailWaterOldSetter, commsEmailContact0 *CommsEmailContact) (PublicreportNotifyEmailWaterOldSlice, error) {
	for i := range publicreportNotifyEmailWaterOlds1 {
		publicreportNotifyEmailWaterOlds1[i].EmailAddress = omit.From(commsEmailContact0.Address)
	}

	ret, err := PublicreportNotifyEmailWaterOlds.Insert(bob.ToMods(publicreportNotifyEmailWaterOlds1...)).All(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertCommsEmailContactEmailAddressNotifyEmailWaterOlds0: %w", err)
	}

	return ret, nil
}

func attachCommsEmailContactEmailAddressNotifyEmailWaterOlds0(ctx context.Context, exec bob.Executor, count int, publicreportNotifyEmailWaterOlds1 PublicreportNotifyEmailWaterOldSlice, commsEmailContact0 *CommsEmailContact) (PublicreportNotifyEmailWaterOldSlice, error) {
	setter := &PublicreportNotifyEmailWaterOldSetter{
		EmailAddress: omit.From(commsEmailContact0.Address),
	}

	err := publicreportNotifyEmailWaterOlds1.UpdateAll(ctx, exec, *setter)
	if err != nil {
		return nil, fmt.Errorf("attachCommsEmailContactEmailAddressNotifyEmailWaterOlds0: %w", err)
	}

	return publicreportNotifyEmailWaterOlds1, nil
}

func (commsEmailContact0 *CommsEmailContact) InsertEmailAddressNotifyEmailWaterOlds(ctx context.Context, exec bob.Executor, related ...*PublicreportNotifyEmailWaterOldSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	publicreportNotifyEmailWaterOlds1, err := insertCommsEmailContactEmailAddressNotifyEmailWaterOlds0(ctx, exec, related, commsEmailContact0)
	if err != nil {
		return err
	}

	commsEmailContact0.R.EmailAddressNotifyEmailWaterOlds = append(commsEmailContact0.R.EmailAddressNotifyEmailWaterOlds, publicreportNotifyEmailWaterOlds1...)

	for _, rel := range publicreportNotifyEmailWaterOlds1 {
		rel.R.EmailAddressEmailContact = commsEmailContact0
	}
	return nil
}

func (commsEmailContact0 *CommsEmailContact) AttachEmailAddressNotifyEmailWaterOlds(ctx context.Context, exec bob.Executor, related ...*PublicreportNotifyEmailWaterOld) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	publicreportNotifyEmailWaterOlds1 := PublicreportNotifyEmailWaterOldSlice(related)

	_, err = attachCommsEmailContactEmailAddressNotifyEmailWaterOlds0(ctx, exec, len(related), publicreportNotifyEmailWaterOlds1, commsEmailContact0)
	if err != nil {
		return err
	}

	commsEmailContact0.R.EmailAddressNotifyEmailWaterOlds = append(commsEmailContact0.R.EmailAddressNotifyEmailWaterOlds, publicreportNotifyEmailWaterOlds1...)

	for _, rel := range related {
		rel.R.EmailAddressEmailContact = commsEmailContact0
	}

	return nil
}

func insertCommsEmailContactEmailAddressSubscribeEmails0(ctx context.Context, exec bob.Executor, publicreportSubscribeEmails1 []*PublicreportSubscribeEmailSetter, commsEmailContact0 *CommsEmailContact) (PublicreportSubscribeEmailSlice, error) {
	for i := range publicreportSubscribeEmails1 {
		publicreportSubscribeEmails1[i].EmailAddress = omit.From(commsEmailContact0.Address)
	}

	ret, err := PublicreportSubscribeEmails.Insert(bob.ToMods(publicreportSubscribeEmails1...)).All(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertCommsEmailContactEmailAddressSubscribeEmails0: %w", err)
	}

	return ret, nil
}

func attachCommsEmailContactEmailAddressSubscribeEmails0(ctx context.Context, exec bob.Executor, count int, publicreportSubscribeEmails1 PublicreportSubscribeEmailSlice, commsEmailContact0 *CommsEmailContact) (PublicreportSubscribeEmailSlice, error) {
	setter := &PublicreportSubscribeEmailSetter{
		EmailAddress: omit.From(commsEmailContact0.Address),
	}

	err := publicreportSubscribeEmails1.UpdateAll(ctx, exec, *setter)
	if err != nil {
		return nil, fmt.Errorf("attachCommsEmailContactEmailAddressSubscribeEmails0: %w", err)
	}

	return publicreportSubscribeEmails1, nil
}

func (commsEmailContact0 *CommsEmailContact) InsertEmailAddressSubscribeEmails(ctx context.Context, exec bob.Executor, related ...*PublicreportSubscribeEmailSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	publicreportSubscribeEmails1, err := insertCommsEmailContactEmailAddressSubscribeEmails0(ctx, exec, related, commsEmailContact0)
	if err != nil {
		return err
	}

	commsEmailContact0.R.EmailAddressSubscribeEmails = append(commsEmailContact0.R.EmailAddressSubscribeEmails, publicreportSubscribeEmails1...)

	for _, rel := range publicreportSubscribeEmails1 {
		rel.R.EmailAddressEmailContact = commsEmailContact0
	}
	return nil
}

func (commsEmailContact0 *CommsEmailContact) AttachEmailAddressSubscribeEmails(ctx context.Context, exec bob.Executor, related ...*PublicreportSubscribeEmail) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	publicreportSubscribeEmails1 := PublicreportSubscribeEmailSlice(related)

	_, err = attachCommsEmailContactEmailAddressSubscribeEmails0(ctx, exec, len(related), publicreportSubscribeEmails1, commsEmailContact0)
	if err != nil {
		return err
	}

	commsEmailContact0.R.EmailAddressSubscribeEmails = append(commsEmailContact0.R.EmailAddressSubscribeEmails, publicreportSubscribeEmails1...)

	for _, rel := range related {
		rel.R.EmailAddressEmailContact = commsEmailContact0
	}

	return nil
}

type commsEmailContactWhere[Q psql.Filterable] struct {
	Address      psql.WhereMod[Q, string]
	Confirmed    psql.WhereMod[Q, bool]
	IsSubscribed psql.WhereMod[Q, bool]
	PublicID     psql.WhereMod[Q, string]
}

func (commsEmailContactWhere[Q]) AliasedAs(alias string) commsEmailContactWhere[Q] {
	return buildCommsEmailContactWhere[Q](buildCommsEmailContactColumns(alias))
}

func buildCommsEmailContactWhere[Q psql.Filterable](cols commsEmailContactColumns) commsEmailContactWhere[Q] {
	return commsEmailContactWhere[Q]{
		Address:      psql.Where[Q, string](cols.Address),
		Confirmed:    psql.Where[Q, bool](cols.Confirmed),
		IsSubscribed: psql.Where[Q, bool](cols.IsSubscribed),
		PublicID:     psql.Where[Q, string](cols.PublicID),
	}
}

func (o *CommsEmailContact) Preload(name string, retrieved any) error {
	if o == nil {
		return nil
	}

	switch name {
	case "DestinationEmailLogs":
		rels, ok := retrieved.(CommsEmailLogSlice)
		if !ok {
			return fmt.Errorf("commsEmailContact cannot load %T as %q", retrieved, name)
		}

		o.R.DestinationEmailLogs = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.DestinationEmailContact = o
			}
		}
		return nil
	case "Organizations":
		rels, ok := retrieved.(OrganizationSlice)
		if !ok {
			return fmt.Errorf("commsEmailContact cannot load %T as %q", retrieved, name)
		}

		o.R.Organizations = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.EmailContacts = CommsEmailContactSlice{o}
			}
		}
		return nil
	case "EmailAddressNotifyEmails":
		rels, ok := retrieved.(PublicreportNotifyEmailSlice)
		if !ok {
			return fmt.Errorf("commsEmailContact cannot load %T as %q", retrieved, name)
		}

		o.R.EmailAddressNotifyEmails = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.EmailAddressEmailContact = o
			}
		}
		return nil
	case "EmailAddressNotifyEmailNuisanceOlds":
		rels, ok := retrieved.(PublicreportNotifyEmailNuisanceOldSlice)
		if !ok {
			return fmt.Errorf("commsEmailContact cannot load %T as %q", retrieved, name)
		}

		o.R.EmailAddressNotifyEmailNuisanceOlds = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.EmailAddressEmailContact = o
			}
		}
		return nil
	case "EmailAddressNotifyEmailWaterOlds":
		rels, ok := retrieved.(PublicreportNotifyEmailWaterOldSlice)
		if !ok {
			return fmt.Errorf("commsEmailContact cannot load %T as %q", retrieved, name)
		}

		o.R.EmailAddressNotifyEmailWaterOlds = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.EmailAddressEmailContact = o
			}
		}
		return nil
	case "EmailAddressSubscribeEmails":
		rels, ok := retrieved.(PublicreportSubscribeEmailSlice)
		if !ok {
			return fmt.Errorf("commsEmailContact cannot load %T as %q", retrieved, name)
		}

		o.R.EmailAddressSubscribeEmails = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.EmailAddressEmailContact = o
			}
		}
		return nil
	default:
		return fmt.Errorf("commsEmailContact has no relationship %q", name)
	}
}

type commsEmailContactPreloader struct{}

func buildCommsEmailContactPreloader() commsEmailContactPreloader {
	return commsEmailContactPreloader{}
}

type commsEmailContactThenLoader[Q orm.Loadable] struct {
	DestinationEmailLogs                func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	Organizations                       func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	EmailAddressNotifyEmails            func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	EmailAddressNotifyEmailNuisanceOlds func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	EmailAddressNotifyEmailWaterOlds    func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	EmailAddressSubscribeEmails         func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
}

func buildCommsEmailContactThenLoader[Q orm.Loadable]() commsEmailContactThenLoader[Q] {
	type DestinationEmailLogsLoadInterface interface {
		LoadDestinationEmailLogs(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type OrganizationsLoadInterface interface {
		LoadOrganizations(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type EmailAddressNotifyEmailsLoadInterface interface {
		LoadEmailAddressNotifyEmails(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type EmailAddressNotifyEmailNuisanceOldsLoadInterface interface {
		LoadEmailAddressNotifyEmailNuisanceOlds(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type EmailAddressNotifyEmailWaterOldsLoadInterface interface {
		LoadEmailAddressNotifyEmailWaterOlds(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type EmailAddressSubscribeEmailsLoadInterface interface {
		LoadEmailAddressSubscribeEmails(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}

	return commsEmailContactThenLoader[Q]{
		DestinationEmailLogs: thenLoadBuilder[Q](
			"DestinationEmailLogs",
			func(ctx context.Context, exec bob.Executor, retrieved DestinationEmailLogsLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadDestinationEmailLogs(ctx, exec, mods...)
			},
		),
		Organizations: thenLoadBuilder[Q](
			"Organizations",
			func(ctx context.Context, exec bob.Executor, retrieved OrganizationsLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadOrganizations(ctx, exec, mods...)
			},
		),
		EmailAddressNotifyEmails: thenLoadBuilder[Q](
			"EmailAddressNotifyEmails",
			func(ctx context.Context, exec bob.Executor, retrieved EmailAddressNotifyEmailsLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadEmailAddressNotifyEmails(ctx, exec, mods...)
			},
		),
		EmailAddressNotifyEmailNuisanceOlds: thenLoadBuilder[Q](
			"EmailAddressNotifyEmailNuisanceOlds",
			func(ctx context.Context, exec bob.Executor, retrieved EmailAddressNotifyEmailNuisanceOldsLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadEmailAddressNotifyEmailNuisanceOlds(ctx, exec, mods...)
			},
		),
		EmailAddressNotifyEmailWaterOlds: thenLoadBuilder[Q](
			"EmailAddressNotifyEmailWaterOlds",
			func(ctx context.Context, exec bob.Executor, retrieved EmailAddressNotifyEmailWaterOldsLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadEmailAddressNotifyEmailWaterOlds(ctx, exec, mods...)
			},
		),
		EmailAddressSubscribeEmails: thenLoadBuilder[Q](
			"EmailAddressSubscribeEmails",
			func(ctx context.Context, exec bob.Executor, retrieved EmailAddressSubscribeEmailsLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadEmailAddressSubscribeEmails(ctx, exec, mods...)
			},
		),
	}
}

// LoadDestinationEmailLogs loads the commsEmailContact's DestinationEmailLogs into the .R struct
func (o *CommsEmailContact) LoadDestinationEmailLogs(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.DestinationEmailLogs = nil

	related, err := o.DestinationEmailLogs(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.DestinationEmailContact = o
	}

	o.R.DestinationEmailLogs = related
	return nil
}

// LoadDestinationEmailLogs loads the commsEmailContact's DestinationEmailLogs into the .R struct
func (os CommsEmailContactSlice) LoadDestinationEmailLogs(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	commsEmailLogs, err := os.DestinationEmailLogs(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		o.R.DestinationEmailLogs = nil
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range commsEmailLogs {

			if !(o.Address == rel.Destination) {
				continue
			}

			rel.R.DestinationEmailContact = o

			o.R.DestinationEmailLogs = append(o.R.DestinationEmailLogs, rel)
		}
	}

	return nil
}

// LoadOrganizations loads the commsEmailContact's Organizations into the .R struct
func (o *CommsEmailContact) LoadOrganizations(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.Organizations = nil

	related, err := o.Organizations(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.EmailContacts = CommsEmailContactSlice{o}
	}

	o.R.Organizations = related
	return nil
}

// LoadOrganizations loads the commsEmailContact's Organizations into the .R struct
func (os CommsEmailContactSlice) LoadOrganizations(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	// since we are changing the columns, we need to check if the original columns were set or add the defaults
	sq := dialect.SelectQuery{}
	for _, mod := range mods {
		mod.Apply(&sq)
	}

	if len(sq.SelectList.Columns) == 0 {
		mods = append(mods, sm.Columns(Organizations.Columns))
	}

	q := os.Organizations(append(
		mods,
		sm.Columns(DistrictSubscriptionEmails.Columns.EmailContactAddress.As("related_comms.email_contact.Address")),
	)...)

	AddressSlice := []string{}

	mapper := scan.Mod(scan.StructMapper[*Organization](), func(ctx context.Context, cols []string) (scan.BeforeFunc, func(any, any) error) {
		return func(row *scan.Row) (any, error) {
				AddressSlice = append(AddressSlice, *new(string))
				row.ScheduleScanByName("related_comms.email_contact.Address", &AddressSlice[len(AddressSlice)-1])

				return nil, nil
			},
			func(any, any) error {
				return nil
			}
	})

	organizations, err := bob.Allx[bob.SliceTransformer[*Organization, OrganizationSlice]](ctx, exec, q, mapper)
	if err != nil {
		return err
	}

	for _, o := range os {
		o.R.Organizations = nil
	}

	for _, o := range os {
		for i, rel := range organizations {
			if !(o.Address == AddressSlice[i]) {
				continue
			}

			rel.R.EmailContacts = append(rel.R.EmailContacts, o)

			o.R.Organizations = append(o.R.Organizations, rel)
		}
	}

	return nil
}

// LoadEmailAddressNotifyEmails loads the commsEmailContact's EmailAddressNotifyEmails into the .R struct
func (o *CommsEmailContact) LoadEmailAddressNotifyEmails(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.EmailAddressNotifyEmails = nil

	related, err := o.EmailAddressNotifyEmails(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.EmailAddressEmailContact = o
	}

	o.R.EmailAddressNotifyEmails = related
	return nil
}

// LoadEmailAddressNotifyEmails loads the commsEmailContact's EmailAddressNotifyEmails into the .R struct
func (os CommsEmailContactSlice) LoadEmailAddressNotifyEmails(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	publicreportNotifyEmails, err := os.EmailAddressNotifyEmails(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		o.R.EmailAddressNotifyEmails = nil
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range publicreportNotifyEmails {

			if !(o.Address == rel.EmailAddress) {
				continue
			}

			rel.R.EmailAddressEmailContact = o

			o.R.EmailAddressNotifyEmails = append(o.R.EmailAddressNotifyEmails, rel)
		}
	}

	return nil
}

// LoadEmailAddressNotifyEmailNuisanceOlds loads the commsEmailContact's EmailAddressNotifyEmailNuisanceOlds into the .R struct
func (o *CommsEmailContact) LoadEmailAddressNotifyEmailNuisanceOlds(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.EmailAddressNotifyEmailNuisanceOlds = nil

	related, err := o.EmailAddressNotifyEmailNuisanceOlds(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.EmailAddressEmailContact = o
	}

	o.R.EmailAddressNotifyEmailNuisanceOlds = related
	return nil
}

// LoadEmailAddressNotifyEmailNuisanceOlds loads the commsEmailContact's EmailAddressNotifyEmailNuisanceOlds into the .R struct
func (os CommsEmailContactSlice) LoadEmailAddressNotifyEmailNuisanceOlds(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	publicreportNotifyEmailNuisanceOlds, err := os.EmailAddressNotifyEmailNuisanceOlds(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		o.R.EmailAddressNotifyEmailNuisanceOlds = nil
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range publicreportNotifyEmailNuisanceOlds {

			if !(o.Address == rel.EmailAddress) {
				continue
			}

			rel.R.EmailAddressEmailContact = o

			o.R.EmailAddressNotifyEmailNuisanceOlds = append(o.R.EmailAddressNotifyEmailNuisanceOlds, rel)
		}
	}

	return nil
}

// LoadEmailAddressNotifyEmailWaterOlds loads the commsEmailContact's EmailAddressNotifyEmailWaterOlds into the .R struct
func (o *CommsEmailContact) LoadEmailAddressNotifyEmailWaterOlds(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.EmailAddressNotifyEmailWaterOlds = nil

	related, err := o.EmailAddressNotifyEmailWaterOlds(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.EmailAddressEmailContact = o
	}

	o.R.EmailAddressNotifyEmailWaterOlds = related
	return nil
}

// LoadEmailAddressNotifyEmailWaterOlds loads the commsEmailContact's EmailAddressNotifyEmailWaterOlds into the .R struct
func (os CommsEmailContactSlice) LoadEmailAddressNotifyEmailWaterOlds(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	publicreportNotifyEmailWaterOlds, err := os.EmailAddressNotifyEmailWaterOlds(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		o.R.EmailAddressNotifyEmailWaterOlds = nil
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range publicreportNotifyEmailWaterOlds {

			if !(o.Address == rel.EmailAddress) {
				continue
			}

			rel.R.EmailAddressEmailContact = o

			o.R.EmailAddressNotifyEmailWaterOlds = append(o.R.EmailAddressNotifyEmailWaterOlds, rel)
		}
	}

	return nil
}

// LoadEmailAddressSubscribeEmails loads the commsEmailContact's EmailAddressSubscribeEmails into the .R struct
func (o *CommsEmailContact) LoadEmailAddressSubscribeEmails(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.EmailAddressSubscribeEmails = nil

	related, err := o.EmailAddressSubscribeEmails(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.EmailAddressEmailContact = o
	}

	o.R.EmailAddressSubscribeEmails = related
	return nil
}

// LoadEmailAddressSubscribeEmails loads the commsEmailContact's EmailAddressSubscribeEmails into the .R struct
func (os CommsEmailContactSlice) LoadEmailAddressSubscribeEmails(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	publicreportSubscribeEmails, err := os.EmailAddressSubscribeEmails(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		o.R.EmailAddressSubscribeEmails = nil
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range publicreportSubscribeEmails {

			if !(o.Address == rel.EmailAddress) {
				continue
			}

			rel.R.EmailAddressEmailContact = o

			o.R.EmailAddressSubscribeEmails = append(o.R.EmailAddressSubscribeEmails, rel)
		}
	}

	return nil
}