nidus-sync/models/history_proposedtreatmentarea.bob.go

// Code generated by BobGen psql v0.41.1. 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"
	"time"

	"github.com/aarondl/opt/null"
	"github.com/aarondl/opt/omit"
	"github.com/aarondl/opt/omitnull"
	"github.com/stephenafamo/bob"
	"github.com/stephenafamo/bob/dialect/psql"
	"github.com/stephenafamo/bob/dialect/psql/dialect"
	"github.com/stephenafamo/bob/dialect/psql/dm"
	"github.com/stephenafamo/bob/dialect/psql/sm"
	"github.com/stephenafamo/bob/dialect/psql/um"
	"github.com/stephenafamo/bob/expr"
	"github.com/stephenafamo/bob/mods"
	"github.com/stephenafamo/bob/orm"
	"github.com/stephenafamo/bob/types/pgtypes"
)

// HistoryProposedtreatmentarea is an object representing the database table.
type HistoryProposedtreatmentarea struct {
	OrganizationID    int32               `db:"organization_id" `
	Acres             null.Val[float64]   `db:"acres" `
	Comments          null.Val[string]    `db:"comments" `
	Completed         null.Val[int16]     `db:"completed" `
	Completedby       null.Val[string]    `db:"completedby" `
	Completeddate     null.Val[int64]     `db:"completeddate" `
	Creationdate      null.Val[int64]     `db:"creationdate" `
	Creator           null.Val[string]    `db:"creator" `
	Duedate           null.Val[int64]     `db:"duedate" `
	Exported          null.Val[int16]     `db:"exported" `
	Editdate          null.Val[int64]     `db:"editdate" `
	Editor            null.Val[string]    `db:"editor" `
	Globalid          null.Val[string]    `db:"globalid" `
	Hectares          null.Val[float64]   `db:"hectares" `
	Issprayroute      null.Val[int16]     `db:"issprayroute" `
	Lasttreatactivity null.Val[string]    `db:"lasttreatactivity" `
	Lasttreatdate     null.Val[int64]     `db:"lasttreatdate" `
	Lasttreatproduct  null.Val[string]    `db:"lasttreatproduct" `
	Lasttreatqty      null.Val[float64]   `db:"lasttreatqty" `
	Lasttreatqtyunit  null.Val[string]    `db:"lasttreatqtyunit" `
	Method            null.Val[string]    `db:"method" `
	Name              null.Val[string]    `db:"name" `
	Objectid          int32               `db:"objectid,pk" `
	Priority          null.Val[string]    `db:"priority" `
	Reviewed          null.Val[int16]     `db:"reviewed" `
	Reviewedby        null.Val[string]    `db:"reviewedby" `
	Revieweddate      null.Val[int64]     `db:"revieweddate" `
	ShapeArea         null.Val[float64]   `db:"shape__area" `
	ShapeLength       null.Val[float64]   `db:"shape__length" `
	Targetapprate     null.Val[float64]   `db:"targetapprate" `
	Targetproduct     null.Val[string]    `db:"targetproduct" `
	Targetspecies     null.Val[string]    `db:"targetspecies" `
	Zone              null.Val[string]    `db:"zone" `
	Zone2             null.Val[string]    `db:"zone2" `
	GeometryX         null.Val[float64]   `db:"geometry_x" `
	GeometryY         null.Val[float64]   `db:"geometry_y" `
	Version           int32               `db:"version,pk" `
	Created           null.Val[time.Time] `db:"created" `

	R historyProposedtreatmentareaR `db:"-" `
}

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

// HistoryProposedtreatmentareas contains methods to work with the history_proposedtreatmentarea table
var HistoryProposedtreatmentareas = psql.NewTablex[*HistoryProposedtreatmentarea, HistoryProposedtreatmentareaSlice, *HistoryProposedtreatmentareaSetter]("", "history_proposedtreatmentarea", buildHistoryProposedtreatmentareaColumns("history_proposedtreatmentarea"))

// HistoryProposedtreatmentareasQuery is a query on the history_proposedtreatmentarea table
type HistoryProposedtreatmentareasQuery = *psql.ViewQuery[*HistoryProposedtreatmentarea, HistoryProposedtreatmentareaSlice]

// historyProposedtreatmentareaR is where relationships are stored.
type historyProposedtreatmentareaR struct {
	Organization *Organization // history_proposedtreatmentarea.history_proposedtreatmentarea_organization_id_fkey
}

func buildHistoryProposedtreatmentareaColumns(alias string) historyProposedtreatmentareaColumns {
	return historyProposedtreatmentareaColumns{
		ColumnsExpr: expr.NewColumnsExpr(
			"organization_id", "acres", "comments", "completed", "completedby", "completeddate", "creationdate", "creator", "duedate", "exported", "editdate", "editor", "globalid", "hectares", "issprayroute", "lasttreatactivity", "lasttreatdate", "lasttreatproduct", "lasttreatqty", "lasttreatqtyunit", "method", "name", "objectid", "priority", "reviewed", "reviewedby", "revieweddate", "shape__area", "shape__length", "targetapprate", "targetproduct", "targetspecies", "zone", "zone2", "geometry_x", "geometry_y", "version", "created",
		).WithParent("history_proposedtreatmentarea"),
		tableAlias:        alias,
		OrganizationID:    psql.Quote(alias, "organization_id"),
		Acres:             psql.Quote(alias, "acres"),
		Comments:          psql.Quote(alias, "comments"),
		Completed:         psql.Quote(alias, "completed"),
		Completedby:       psql.Quote(alias, "completedby"),
		Completeddate:     psql.Quote(alias, "completeddate"),
		Creationdate:      psql.Quote(alias, "creationdate"),
		Creator:           psql.Quote(alias, "creator"),
		Duedate:           psql.Quote(alias, "duedate"),
		Exported:          psql.Quote(alias, "exported"),
		Editdate:          psql.Quote(alias, "editdate"),
		Editor:            psql.Quote(alias, "editor"),
		Globalid:          psql.Quote(alias, "globalid"),
		Hectares:          psql.Quote(alias, "hectares"),
		Issprayroute:      psql.Quote(alias, "issprayroute"),
		Lasttreatactivity: psql.Quote(alias, "lasttreatactivity"),
		Lasttreatdate:     psql.Quote(alias, "lasttreatdate"),
		Lasttreatproduct:  psql.Quote(alias, "lasttreatproduct"),
		Lasttreatqty:      psql.Quote(alias, "lasttreatqty"),
		Lasttreatqtyunit:  psql.Quote(alias, "lasttreatqtyunit"),
		Method:            psql.Quote(alias, "method"),
		Name:              psql.Quote(alias, "name"),
		Objectid:          psql.Quote(alias, "objectid"),
		Priority:          psql.Quote(alias, "priority"),
		Reviewed:          psql.Quote(alias, "reviewed"),
		Reviewedby:        psql.Quote(alias, "reviewedby"),
		Revieweddate:      psql.Quote(alias, "revieweddate"),
		ShapeArea:         psql.Quote(alias, "shape__area"),
		ShapeLength:       psql.Quote(alias, "shape__length"),
		Targetapprate:     psql.Quote(alias, "targetapprate"),
		Targetproduct:     psql.Quote(alias, "targetproduct"),
		Targetspecies:     psql.Quote(alias, "targetspecies"),
		Zone:              psql.Quote(alias, "zone"),
		Zone2:             psql.Quote(alias, "zone2"),
		GeometryX:         psql.Quote(alias, "geometry_x"),
		GeometryY:         psql.Quote(alias, "geometry_y"),
		Version:           psql.Quote(alias, "version"),
		Created:           psql.Quote(alias, "created"),
	}
}

type historyProposedtreatmentareaColumns struct {
	expr.ColumnsExpr
	tableAlias        string
	OrganizationID    psql.Expression
	Acres             psql.Expression
	Comments          psql.Expression
	Completed         psql.Expression
	Completedby       psql.Expression
	Completeddate     psql.Expression
	Creationdate      psql.Expression
	Creator           psql.Expression
	Duedate           psql.Expression
	Exported          psql.Expression
	Editdate          psql.Expression
	Editor            psql.Expression
	Globalid          psql.Expression
	Hectares          psql.Expression
	Issprayroute      psql.Expression
	Lasttreatactivity psql.Expression
	Lasttreatdate     psql.Expression
	Lasttreatproduct  psql.Expression
	Lasttreatqty      psql.Expression
	Lasttreatqtyunit  psql.Expression
	Method            psql.Expression
	Name              psql.Expression
	Objectid          psql.Expression
	Priority          psql.Expression
	Reviewed          psql.Expression
	Reviewedby        psql.Expression
	Revieweddate      psql.Expression
	ShapeArea         psql.Expression
	ShapeLength       psql.Expression
	Targetapprate     psql.Expression
	Targetproduct     psql.Expression
	Targetspecies     psql.Expression
	Zone              psql.Expression
	Zone2             psql.Expression
	GeometryX         psql.Expression
	GeometryY         psql.Expression
	Version           psql.Expression
	Created           psql.Expression
}

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

func (historyProposedtreatmentareaColumns) AliasedAs(alias string) historyProposedtreatmentareaColumns {
	return buildHistoryProposedtreatmentareaColumns(alias)
}

// HistoryProposedtreatmentareaSetter is used for insert/upsert/update operations
// All values are optional, and do not have to be set
// Generated columns are not included
type HistoryProposedtreatmentareaSetter struct {
	OrganizationID    omit.Val[int32]         `db:"organization_id" `
	Acres             omitnull.Val[float64]   `db:"acres" `
	Comments          omitnull.Val[string]    `db:"comments" `
	Completed         omitnull.Val[int16]     `db:"completed" `
	Completedby       omitnull.Val[string]    `db:"completedby" `
	Completeddate     omitnull.Val[int64]     `db:"completeddate" `
	Creationdate      omitnull.Val[int64]     `db:"creationdate" `
	Creator           omitnull.Val[string]    `db:"creator" `
	Duedate           omitnull.Val[int64]     `db:"duedate" `
	Exported          omitnull.Val[int16]     `db:"exported" `
	Editdate          omitnull.Val[int64]     `db:"editdate" `
	Editor            omitnull.Val[string]    `db:"editor" `
	Globalid          omitnull.Val[string]    `db:"globalid" `
	Hectares          omitnull.Val[float64]   `db:"hectares" `
	Issprayroute      omitnull.Val[int16]     `db:"issprayroute" `
	Lasttreatactivity omitnull.Val[string]    `db:"lasttreatactivity" `
	Lasttreatdate     omitnull.Val[int64]     `db:"lasttreatdate" `
	Lasttreatproduct  omitnull.Val[string]    `db:"lasttreatproduct" `
	Lasttreatqty      omitnull.Val[float64]   `db:"lasttreatqty" `
	Lasttreatqtyunit  omitnull.Val[string]    `db:"lasttreatqtyunit" `
	Method            omitnull.Val[string]    `db:"method" `
	Name              omitnull.Val[string]    `db:"name" `
	Objectid          omit.Val[int32]         `db:"objectid,pk" `
	Priority          omitnull.Val[string]    `db:"priority" `
	Reviewed          omitnull.Val[int16]     `db:"reviewed" `
	Reviewedby        omitnull.Val[string]    `db:"reviewedby" `
	Revieweddate      omitnull.Val[int64]     `db:"revieweddate" `
	ShapeArea         omitnull.Val[float64]   `db:"shape__area" `
	ShapeLength       omitnull.Val[float64]   `db:"shape__length" `
	Targetapprate     omitnull.Val[float64]   `db:"targetapprate" `
	Targetproduct     omitnull.Val[string]    `db:"targetproduct" `
	Targetspecies     omitnull.Val[string]    `db:"targetspecies" `
	Zone              omitnull.Val[string]    `db:"zone" `
	Zone2             omitnull.Val[string]    `db:"zone2" `
	GeometryX         omitnull.Val[float64]   `db:"geometry_x" `
	GeometryY         omitnull.Val[float64]   `db:"geometry_y" `
	Version           omit.Val[int32]         `db:"version,pk" `
	Created           omitnull.Val[time.Time] `db:"created" `
}

func (s HistoryProposedtreatmentareaSetter) SetColumns() []string {
	vals := make([]string, 0, 38)
	if s.OrganizationID.IsValue() {
		vals = append(vals, "organization_id")
	}
	if !s.Acres.IsUnset() {
		vals = append(vals, "acres")
	}
	if !s.Comments.IsUnset() {
		vals = append(vals, "comments")
	}
	if !s.Completed.IsUnset() {
		vals = append(vals, "completed")
	}
	if !s.Completedby.IsUnset() {
		vals = append(vals, "completedby")
	}
	if !s.Completeddate.IsUnset() {
		vals = append(vals, "completeddate")
	}
	if !s.Creationdate.IsUnset() {
		vals = append(vals, "creationdate")
	}
	if !s.Creator.IsUnset() {
		vals = append(vals, "creator")
	}
	if !s.Duedate.IsUnset() {
		vals = append(vals, "duedate")
	}
	if !s.Exported.IsUnset() {
		vals = append(vals, "exported")
	}
	if !s.Editdate.IsUnset() {
		vals = append(vals, "editdate")
	}
	if !s.Editor.IsUnset() {
		vals = append(vals, "editor")
	}
	if !s.Globalid.IsUnset() {
		vals = append(vals, "globalid")
	}
	if !s.Hectares.IsUnset() {
		vals = append(vals, "hectares")
	}
	if !s.Issprayroute.IsUnset() {
		vals = append(vals, "issprayroute")
	}
	if !s.Lasttreatactivity.IsUnset() {
		vals = append(vals, "lasttreatactivity")
	}
	if !s.Lasttreatdate.IsUnset() {
		vals = append(vals, "lasttreatdate")
	}
	if !s.Lasttreatproduct.IsUnset() {
		vals = append(vals, "lasttreatproduct")
	}
	if !s.Lasttreatqty.IsUnset() {
		vals = append(vals, "lasttreatqty")
	}
	if !s.Lasttreatqtyunit.IsUnset() {
		vals = append(vals, "lasttreatqtyunit")
	}
	if !s.Method.IsUnset() {
		vals = append(vals, "method")
	}
	if !s.Name.IsUnset() {
		vals = append(vals, "name")
	}
	if s.Objectid.IsValue() {
		vals = append(vals, "objectid")
	}
	if !s.Priority.IsUnset() {
		vals = append(vals, "priority")
	}
	if !s.Reviewed.IsUnset() {
		vals = append(vals, "reviewed")
	}
	if !s.Reviewedby.IsUnset() {
		vals = append(vals, "reviewedby")
	}
	if !s.Revieweddate.IsUnset() {
		vals = append(vals, "revieweddate")
	}
	if !s.ShapeArea.IsUnset() {
		vals = append(vals, "shape__area")
	}
	if !s.ShapeLength.IsUnset() {
		vals = append(vals, "shape__length")
	}
	if !s.Targetapprate.IsUnset() {
		vals = append(vals, "targetapprate")
	}
	if !s.Targetproduct.IsUnset() {
		vals = append(vals, "targetproduct")
	}
	if !s.Targetspecies.IsUnset() {
		vals = append(vals, "targetspecies")
	}
	if !s.Zone.IsUnset() {
		vals = append(vals, "zone")
	}
	if !s.Zone2.IsUnset() {
		vals = append(vals, "zone2")
	}
	if !s.GeometryX.IsUnset() {
		vals = append(vals, "geometry_x")
	}
	if !s.GeometryY.IsUnset() {
		vals = append(vals, "geometry_y")
	}
	if s.Version.IsValue() {
		vals = append(vals, "version")
	}
	if !s.Created.IsUnset() {
		vals = append(vals, "created")
	}
	return vals
}

func (s HistoryProposedtreatmentareaSetter) Overwrite(t *HistoryProposedtreatmentarea) {
	if s.OrganizationID.IsValue() {
		t.OrganizationID = s.OrganizationID.MustGet()
	}
	if !s.Acres.IsUnset() {
		t.Acres = s.Acres.MustGetNull()
	}
	if !s.Comments.IsUnset() {
		t.Comments = s.Comments.MustGetNull()
	}
	if !s.Completed.IsUnset() {
		t.Completed = s.Completed.MustGetNull()
	}
	if !s.Completedby.IsUnset() {
		t.Completedby = s.Completedby.MustGetNull()
	}
	if !s.Completeddate.IsUnset() {
		t.Completeddate = s.Completeddate.MustGetNull()
	}
	if !s.Creationdate.IsUnset() {
		t.Creationdate = s.Creationdate.MustGetNull()
	}
	if !s.Creator.IsUnset() {
		t.Creator = s.Creator.MustGetNull()
	}
	if !s.Duedate.IsUnset() {
		t.Duedate = s.Duedate.MustGetNull()
	}
	if !s.Exported.IsUnset() {
		t.Exported = s.Exported.MustGetNull()
	}
	if !s.Editdate.IsUnset() {
		t.Editdate = s.Editdate.MustGetNull()
	}
	if !s.Editor.IsUnset() {
		t.Editor = s.Editor.MustGetNull()
	}
	if !s.Globalid.IsUnset() {
		t.Globalid = s.Globalid.MustGetNull()
	}
	if !s.Hectares.IsUnset() {
		t.Hectares = s.Hectares.MustGetNull()
	}
	if !s.Issprayroute.IsUnset() {
		t.Issprayroute = s.Issprayroute.MustGetNull()
	}
	if !s.Lasttreatactivity.IsUnset() {
		t.Lasttreatactivity = s.Lasttreatactivity.MustGetNull()
	}
	if !s.Lasttreatdate.IsUnset() {
		t.Lasttreatdate = s.Lasttreatdate.MustGetNull()
	}
	if !s.Lasttreatproduct.IsUnset() {
		t.Lasttreatproduct = s.Lasttreatproduct.MustGetNull()
	}
	if !s.Lasttreatqty.IsUnset() {
		t.Lasttreatqty = s.Lasttreatqty.MustGetNull()
	}
	if !s.Lasttreatqtyunit.IsUnset() {
		t.Lasttreatqtyunit = s.Lasttreatqtyunit.MustGetNull()
	}
	if !s.Method.IsUnset() {
		t.Method = s.Method.MustGetNull()
	}
	if !s.Name.IsUnset() {
		t.Name = s.Name.MustGetNull()
	}
	if s.Objectid.IsValue() {
		t.Objectid = s.Objectid.MustGet()
	}
	if !s.Priority.IsUnset() {
		t.Priority = s.Priority.MustGetNull()
	}
	if !s.Reviewed.IsUnset() {
		t.Reviewed = s.Reviewed.MustGetNull()
	}
	if !s.Reviewedby.IsUnset() {
		t.Reviewedby = s.Reviewedby.MustGetNull()
	}
	if !s.Revieweddate.IsUnset() {
		t.Revieweddate = s.Revieweddate.MustGetNull()
	}
	if !s.ShapeArea.IsUnset() {
		t.ShapeArea = s.ShapeArea.MustGetNull()
	}
	if !s.ShapeLength.IsUnset() {
		t.ShapeLength = s.ShapeLength.MustGetNull()
	}
	if !s.Targetapprate.IsUnset() {
		t.Targetapprate = s.Targetapprate.MustGetNull()
	}
	if !s.Targetproduct.IsUnset() {
		t.Targetproduct = s.Targetproduct.MustGetNull()
	}
	if !s.Targetspecies.IsUnset() {
		t.Targetspecies = s.Targetspecies.MustGetNull()
	}
	if !s.Zone.IsUnset() {
		t.Zone = s.Zone.MustGetNull()
	}
	if !s.Zone2.IsUnset() {
		t.Zone2 = s.Zone2.MustGetNull()
	}
	if !s.GeometryX.IsUnset() {
		t.GeometryX = s.GeometryX.MustGetNull()
	}
	if !s.GeometryY.IsUnset() {
		t.GeometryY = s.GeometryY.MustGetNull()
	}
	if s.Version.IsValue() {
		t.Version = s.Version.MustGet()
	}
	if !s.Created.IsUnset() {
		t.Created = s.Created.MustGetNull()
	}
}

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

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

		if !s.Acres.IsUnset() {
			vals[1] = psql.Arg(s.Acres.MustGetNull())
		} else {
			vals[1] = psql.Raw("DEFAULT")
		}

		if !s.Comments.IsUnset() {
			vals[2] = psql.Arg(s.Comments.MustGetNull())
		} else {
			vals[2] = psql.Raw("DEFAULT")
		}

		if !s.Completed.IsUnset() {
			vals[3] = psql.Arg(s.Completed.MustGetNull())
		} else {
			vals[3] = psql.Raw("DEFAULT")
		}

		if !s.Completedby.IsUnset() {
			vals[4] = psql.Arg(s.Completedby.MustGetNull())
		} else {
			vals[4] = psql.Raw("DEFAULT")
		}

		if !s.Completeddate.IsUnset() {
			vals[5] = psql.Arg(s.Completeddate.MustGetNull())
		} else {
			vals[5] = psql.Raw("DEFAULT")
		}

		if !s.Creationdate.IsUnset() {
			vals[6] = psql.Arg(s.Creationdate.MustGetNull())
		} else {
			vals[6] = psql.Raw("DEFAULT")
		}

		if !s.Creator.IsUnset() {
			vals[7] = psql.Arg(s.Creator.MustGetNull())
		} else {
			vals[7] = psql.Raw("DEFAULT")
		}

		if !s.Duedate.IsUnset() {
			vals[8] = psql.Arg(s.Duedate.MustGetNull())
		} else {
			vals[8] = psql.Raw("DEFAULT")
		}

		if !s.Exported.IsUnset() {
			vals[9] = psql.Arg(s.Exported.MustGetNull())
		} else {
			vals[9] = psql.Raw("DEFAULT")
		}

		if !s.Editdate.IsUnset() {
			vals[10] = psql.Arg(s.Editdate.MustGetNull())
		} else {
			vals[10] = psql.Raw("DEFAULT")
		}

		if !s.Editor.IsUnset() {
			vals[11] = psql.Arg(s.Editor.MustGetNull())
		} else {
			vals[11] = psql.Raw("DEFAULT")
		}

		if !s.Globalid.IsUnset() {
			vals[12] = psql.Arg(s.Globalid.MustGetNull())
		} else {
			vals[12] = psql.Raw("DEFAULT")
		}

		if !s.Hectares.IsUnset() {
			vals[13] = psql.Arg(s.Hectares.MustGetNull())
		} else {
			vals[13] = psql.Raw("DEFAULT")
		}

		if !s.Issprayroute.IsUnset() {
			vals[14] = psql.Arg(s.Issprayroute.MustGetNull())
		} else {
			vals[14] = psql.Raw("DEFAULT")
		}

		if !s.Lasttreatactivity.IsUnset() {
			vals[15] = psql.Arg(s.Lasttreatactivity.MustGetNull())
		} else {
			vals[15] = psql.Raw("DEFAULT")
		}

		if !s.Lasttreatdate.IsUnset() {
			vals[16] = psql.Arg(s.Lasttreatdate.MustGetNull())
		} else {
			vals[16] = psql.Raw("DEFAULT")
		}

		if !s.Lasttreatproduct.IsUnset() {
			vals[17] = psql.Arg(s.Lasttreatproduct.MustGetNull())
		} else {
			vals[17] = psql.Raw("DEFAULT")
		}

		if !s.Lasttreatqty.IsUnset() {
			vals[18] = psql.Arg(s.Lasttreatqty.MustGetNull())
		} else {
			vals[18] = psql.Raw("DEFAULT")
		}

		if !s.Lasttreatqtyunit.IsUnset() {
			vals[19] = psql.Arg(s.Lasttreatqtyunit.MustGetNull())
		} else {
			vals[19] = psql.Raw("DEFAULT")
		}

		if !s.Method.IsUnset() {
			vals[20] = psql.Arg(s.Method.MustGetNull())
		} else {
			vals[20] = psql.Raw("DEFAULT")
		}

		if !s.Name.IsUnset() {
			vals[21] = psql.Arg(s.Name.MustGetNull())
		} else {
			vals[21] = psql.Raw("DEFAULT")
		}

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

		if !s.Priority.IsUnset() {
			vals[23] = psql.Arg(s.Priority.MustGetNull())
		} else {
			vals[23] = psql.Raw("DEFAULT")
		}

		if !s.Reviewed.IsUnset() {
			vals[24] = psql.Arg(s.Reviewed.MustGetNull())
		} else {
			vals[24] = psql.Raw("DEFAULT")
		}

		if !s.Reviewedby.IsUnset() {
			vals[25] = psql.Arg(s.Reviewedby.MustGetNull())
		} else {
			vals[25] = psql.Raw("DEFAULT")
		}

		if !s.Revieweddate.IsUnset() {
			vals[26] = psql.Arg(s.Revieweddate.MustGetNull())
		} else {
			vals[26] = psql.Raw("DEFAULT")
		}

		if !s.ShapeArea.IsUnset() {
			vals[27] = psql.Arg(s.ShapeArea.MustGetNull())
		} else {
			vals[27] = psql.Raw("DEFAULT")
		}

		if !s.ShapeLength.IsUnset() {
			vals[28] = psql.Arg(s.ShapeLength.MustGetNull())
		} else {
			vals[28] = psql.Raw("DEFAULT")
		}

		if !s.Targetapprate.IsUnset() {
			vals[29] = psql.Arg(s.Targetapprate.MustGetNull())
		} else {
			vals[29] = psql.Raw("DEFAULT")
		}

		if !s.Targetproduct.IsUnset() {
			vals[30] = psql.Arg(s.Targetproduct.MustGetNull())
		} else {
			vals[30] = psql.Raw("DEFAULT")
		}

		if !s.Targetspecies.IsUnset() {
			vals[31] = psql.Arg(s.Targetspecies.MustGetNull())
		} else {
			vals[31] = psql.Raw("DEFAULT")
		}

		if !s.Zone.IsUnset() {
			vals[32] = psql.Arg(s.Zone.MustGetNull())
		} else {
			vals[32] = psql.Raw("DEFAULT")
		}

		if !s.Zone2.IsUnset() {
			vals[33] = psql.Arg(s.Zone2.MustGetNull())
		} else {
			vals[33] = psql.Raw("DEFAULT")
		}

		if !s.GeometryX.IsUnset() {
			vals[34] = psql.Arg(s.GeometryX.MustGetNull())
		} else {
			vals[34] = psql.Raw("DEFAULT")
		}

		if !s.GeometryY.IsUnset() {
			vals[35] = psql.Arg(s.GeometryY.MustGetNull())
		} else {
			vals[35] = psql.Raw("DEFAULT")
		}

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

		if !s.Created.IsUnset() {
			vals[37] = psql.Arg(s.Created.MustGetNull())
		} else {
			vals[37] = psql.Raw("DEFAULT")
		}

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

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

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

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

	if !s.Acres.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "acres")...),
			psql.Arg(s.Acres),
		}})
	}

	if !s.Comments.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "comments")...),
			psql.Arg(s.Comments),
		}})
	}

	if !s.Completed.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "completed")...),
			psql.Arg(s.Completed),
		}})
	}

	if !s.Completedby.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "completedby")...),
			psql.Arg(s.Completedby),
		}})
	}

	if !s.Completeddate.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "completeddate")...),
			psql.Arg(s.Completeddate),
		}})
	}

	if !s.Creationdate.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "creationdate")...),
			psql.Arg(s.Creationdate),
		}})
	}

	if !s.Creator.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "creator")...),
			psql.Arg(s.Creator),
		}})
	}

	if !s.Duedate.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "duedate")...),
			psql.Arg(s.Duedate),
		}})
	}

	if !s.Exported.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "exported")...),
			psql.Arg(s.Exported),
		}})
	}

	if !s.Editdate.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "editdate")...),
			psql.Arg(s.Editdate),
		}})
	}

	if !s.Editor.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "editor")...),
			psql.Arg(s.Editor),
		}})
	}

	if !s.Globalid.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "globalid")...),
			psql.Arg(s.Globalid),
		}})
	}

	if !s.Hectares.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "hectares")...),
			psql.Arg(s.Hectares),
		}})
	}

	if !s.Issprayroute.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "issprayroute")...),
			psql.Arg(s.Issprayroute),
		}})
	}

	if !s.Lasttreatactivity.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "lasttreatactivity")...),
			psql.Arg(s.Lasttreatactivity),
		}})
	}

	if !s.Lasttreatdate.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "lasttreatdate")...),
			psql.Arg(s.Lasttreatdate),
		}})
	}

	if !s.Lasttreatproduct.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "lasttreatproduct")...),
			psql.Arg(s.Lasttreatproduct),
		}})
	}

	if !s.Lasttreatqty.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "lasttreatqty")...),
			psql.Arg(s.Lasttreatqty),
		}})
	}

	if !s.Lasttreatqtyunit.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "lasttreatqtyunit")...),
			psql.Arg(s.Lasttreatqtyunit),
		}})
	}

	if !s.Method.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "method")...),
			psql.Arg(s.Method),
		}})
	}

	if !s.Name.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "name")...),
			psql.Arg(s.Name),
		}})
	}

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

	if !s.Priority.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "priority")...),
			psql.Arg(s.Priority),
		}})
	}

	if !s.Reviewed.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "reviewed")...),
			psql.Arg(s.Reviewed),
		}})
	}

	if !s.Reviewedby.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "reviewedby")...),
			psql.Arg(s.Reviewedby),
		}})
	}

	if !s.Revieweddate.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "revieweddate")...),
			psql.Arg(s.Revieweddate),
		}})
	}

	if !s.ShapeArea.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "shape__area")...),
			psql.Arg(s.ShapeArea),
		}})
	}

	if !s.ShapeLength.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "shape__length")...),
			psql.Arg(s.ShapeLength),
		}})
	}

	if !s.Targetapprate.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "targetapprate")...),
			psql.Arg(s.Targetapprate),
		}})
	}

	if !s.Targetproduct.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "targetproduct")...),
			psql.Arg(s.Targetproduct),
		}})
	}

	if !s.Targetspecies.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "targetspecies")...),
			psql.Arg(s.Targetspecies),
		}})
	}

	if !s.Zone.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "zone")...),
			psql.Arg(s.Zone),
		}})
	}

	if !s.Zone2.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "zone2")...),
			psql.Arg(s.Zone2),
		}})
	}

	if !s.GeometryX.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "geometry_x")...),
			psql.Arg(s.GeometryX),
		}})
	}

	if !s.GeometryY.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "geometry_y")...),
			psql.Arg(s.GeometryY),
		}})
	}

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

	if !s.Created.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "created")...),
			psql.Arg(s.Created),
		}})
	}

	return exprs
}

// FindHistoryProposedtreatmentarea retrieves a single record by primary key
// If cols is empty Find will return all columns.
func FindHistoryProposedtreatmentarea(ctx context.Context, exec bob.Executor, ObjectidPK int32, VersionPK int32, cols ...string) (*HistoryProposedtreatmentarea, error) {
	if len(cols) == 0 {
		return HistoryProposedtreatmentareas.Query(
			sm.Where(HistoryProposedtreatmentareas.Columns.Objectid.EQ(psql.Arg(ObjectidPK))),
			sm.Where(HistoryProposedtreatmentareas.Columns.Version.EQ(psql.Arg(VersionPK))),
		).One(ctx, exec)
	}

	return HistoryProposedtreatmentareas.Query(
		sm.Where(HistoryProposedtreatmentareas.Columns.Objectid.EQ(psql.Arg(ObjectidPK))),
		sm.Where(HistoryProposedtreatmentareas.Columns.Version.EQ(psql.Arg(VersionPK))),
		sm.Columns(HistoryProposedtreatmentareas.Columns.Only(cols...)),
	).One(ctx, exec)
}

// HistoryProposedtreatmentareaExists checks the presence of a single record by primary key
func HistoryProposedtreatmentareaExists(ctx context.Context, exec bob.Executor, ObjectidPK int32, VersionPK int32) (bool, error) {
	return HistoryProposedtreatmentareas.Query(
		sm.Where(HistoryProposedtreatmentareas.Columns.Objectid.EQ(psql.Arg(ObjectidPK))),
		sm.Where(HistoryProposedtreatmentareas.Columns.Version.EQ(psql.Arg(VersionPK))),
	).Exists(ctx, exec)
}

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

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

	return err
}

// primaryKeyVals returns the primary key values of the HistoryProposedtreatmentarea
func (o *HistoryProposedtreatmentarea) primaryKeyVals() bob.Expression {
	return psql.ArgGroup(
		o.Objectid,
		o.Version,
	)
}

func (o *HistoryProposedtreatmentarea) pkEQ() dialect.Expression {
	return psql.Group(psql.Quote("history_proposedtreatmentarea", "objectid"), psql.Quote("history_proposedtreatmentarea", "version")).EQ(bob.ExpressionFunc(func(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
		return o.primaryKeyVals().WriteSQL(ctx, w, d, start)
	}))
}

// Update uses an executor to update the HistoryProposedtreatmentarea
func (o *HistoryProposedtreatmentarea) Update(ctx context.Context, exec bob.Executor, s *HistoryProposedtreatmentareaSetter) error {
	v, err := HistoryProposedtreatmentareas.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 HistoryProposedtreatmentarea record with an executor
func (o *HistoryProposedtreatmentarea) Delete(ctx context.Context, exec bob.Executor) error {
	_, err := HistoryProposedtreatmentareas.Delete(dm.Where(o.pkEQ())).Exec(ctx, exec)
	return err
}

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

	return nil
}

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

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

	return err
}

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

	return psql.Group(psql.Quote("history_proposedtreatmentarea", "objectid"), psql.Quote("history_proposedtreatmentarea", "version")).In(bob.ExpressionFunc(func(ctx context.Context, w io.Writer, 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 HistoryProposedtreatmentareaSlice) copyMatchingRows(from ...*HistoryProposedtreatmentarea) {
	for i, old := range o {
		for _, new := range from {
			if new.Objectid != old.Objectid {
				continue
			}
			if new.Version != old.Version {
				continue
			}
			new.R = old.R
			o[i] = new
			break
		}
	}
}

// UpdateMod modifies an update query with "WHERE primary_key IN (o...)"
func (o HistoryProposedtreatmentareaSlice) 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 HistoryProposedtreatmentareas.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 *HistoryProposedtreatmentarea:
				o.copyMatchingRows(retrieved)
			case []*HistoryProposedtreatmentarea:
				o.copyMatchingRows(retrieved...)
			case HistoryProposedtreatmentareaSlice:
				o.copyMatchingRows(retrieved...)
			default:
				// If the retrieved value is not a HistoryProposedtreatmentarea or a slice of HistoryProposedtreatmentarea
				// then run the AfterUpdateHooks on the slice
				_, err = HistoryProposedtreatmentareas.AfterUpdateHooks.RunHooks(ctx, exec, o)
			}

			return err
		}))

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

// DeleteMod modifies an delete query with "WHERE primary_key IN (o...)"
func (o HistoryProposedtreatmentareaSlice) 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 HistoryProposedtreatmentareas.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 *HistoryProposedtreatmentarea:
				o.copyMatchingRows(retrieved)
			case []*HistoryProposedtreatmentarea:
				o.copyMatchingRows(retrieved...)
			case HistoryProposedtreatmentareaSlice:
				o.copyMatchingRows(retrieved...)
			default:
				// If the retrieved value is not a HistoryProposedtreatmentarea or a slice of HistoryProposedtreatmentarea
				// then run the AfterDeleteHooks on the slice
				_, err = HistoryProposedtreatmentareas.AfterDeleteHooks.RunHooks(ctx, exec, o)
			}

			return err
		}))

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

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

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

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

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

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

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

	o.copyMatchingRows(o2...)

	return nil
}

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

func (os HistoryProposedtreatmentareaSlice) Organization(mods ...bob.Mod[*dialect.SelectQuery]) OrganizationsQuery {
	pkOrganizationID := make(pgtypes.Array[int32], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkOrganizationID = append(pkOrganizationID, o.OrganizationID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkOrganizationID), "integer[]")),
	))

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

func attachHistoryProposedtreatmentareaOrganization0(ctx context.Context, exec bob.Executor, count int, historyProposedtreatmentarea0 *HistoryProposedtreatmentarea, organization1 *Organization) (*HistoryProposedtreatmentarea, error) {
	setter := &HistoryProposedtreatmentareaSetter{
		OrganizationID: omit.From(organization1.ID),
	}

	err := historyProposedtreatmentarea0.Update(ctx, exec, setter)
	if err != nil {
		return nil, fmt.Errorf("attachHistoryProposedtreatmentareaOrganization0: %w", err)
	}

	return historyProposedtreatmentarea0, nil
}

func (historyProposedtreatmentarea0 *HistoryProposedtreatmentarea) InsertOrganization(ctx context.Context, exec bob.Executor, related *OrganizationSetter) error {
	var err error

	organization1, err := Organizations.Insert(related).One(ctx, exec)
	if err != nil {
		return fmt.Errorf("inserting related objects: %w", err)
	}

	_, err = attachHistoryProposedtreatmentareaOrganization0(ctx, exec, 1, historyProposedtreatmentarea0, organization1)
	if err != nil {
		return err
	}

	historyProposedtreatmentarea0.R.Organization = organization1

	organization1.R.HistoryProposedtreatmentareas = append(organization1.R.HistoryProposedtreatmentareas, historyProposedtreatmentarea0)

	return nil
}

func (historyProposedtreatmentarea0 *HistoryProposedtreatmentarea) AttachOrganization(ctx context.Context, exec bob.Executor, organization1 *Organization) error {
	var err error

	_, err = attachHistoryProposedtreatmentareaOrganization0(ctx, exec, 1, historyProposedtreatmentarea0, organization1)
	if err != nil {
		return err
	}

	historyProposedtreatmentarea0.R.Organization = organization1

	organization1.R.HistoryProposedtreatmentareas = append(organization1.R.HistoryProposedtreatmentareas, historyProposedtreatmentarea0)

	return nil
}

type historyProposedtreatmentareaWhere[Q psql.Filterable] struct {
	OrganizationID    psql.WhereMod[Q, int32]
	Acres             psql.WhereNullMod[Q, float64]
	Comments          psql.WhereNullMod[Q, string]
	Completed         psql.WhereNullMod[Q, int16]
	Completedby       psql.WhereNullMod[Q, string]
	Completeddate     psql.WhereNullMod[Q, int64]
	Creationdate      psql.WhereNullMod[Q, int64]
	Creator           psql.WhereNullMod[Q, string]
	Duedate           psql.WhereNullMod[Q, int64]
	Exported          psql.WhereNullMod[Q, int16]
	Editdate          psql.WhereNullMod[Q, int64]
	Editor            psql.WhereNullMod[Q, string]
	Globalid          psql.WhereNullMod[Q, string]
	Hectares          psql.WhereNullMod[Q, float64]
	Issprayroute      psql.WhereNullMod[Q, int16]
	Lasttreatactivity psql.WhereNullMod[Q, string]
	Lasttreatdate     psql.WhereNullMod[Q, int64]
	Lasttreatproduct  psql.WhereNullMod[Q, string]
	Lasttreatqty      psql.WhereNullMod[Q, float64]
	Lasttreatqtyunit  psql.WhereNullMod[Q, string]
	Method            psql.WhereNullMod[Q, string]
	Name              psql.WhereNullMod[Q, string]
	Objectid          psql.WhereMod[Q, int32]
	Priority          psql.WhereNullMod[Q, string]
	Reviewed          psql.WhereNullMod[Q, int16]
	Reviewedby        psql.WhereNullMod[Q, string]
	Revieweddate      psql.WhereNullMod[Q, int64]
	ShapeArea         psql.WhereNullMod[Q, float64]
	ShapeLength       psql.WhereNullMod[Q, float64]
	Targetapprate     psql.WhereNullMod[Q, float64]
	Targetproduct     psql.WhereNullMod[Q, string]
	Targetspecies     psql.WhereNullMod[Q, string]
	Zone              psql.WhereNullMod[Q, string]
	Zone2             psql.WhereNullMod[Q, string]
	GeometryX         psql.WhereNullMod[Q, float64]
	GeometryY         psql.WhereNullMod[Q, float64]
	Version           psql.WhereMod[Q, int32]
	Created           psql.WhereNullMod[Q, time.Time]
}

func (historyProposedtreatmentareaWhere[Q]) AliasedAs(alias string) historyProposedtreatmentareaWhere[Q] {
	return buildHistoryProposedtreatmentareaWhere[Q](buildHistoryProposedtreatmentareaColumns(alias))
}

func buildHistoryProposedtreatmentareaWhere[Q psql.Filterable](cols historyProposedtreatmentareaColumns) historyProposedtreatmentareaWhere[Q] {
	return historyProposedtreatmentareaWhere[Q]{
		OrganizationID:    psql.Where[Q, int32](cols.OrganizationID),
		Acres:             psql.WhereNull[Q, float64](cols.Acres),
		Comments:          psql.WhereNull[Q, string](cols.Comments),
		Completed:         psql.WhereNull[Q, int16](cols.Completed),
		Completedby:       psql.WhereNull[Q, string](cols.Completedby),
		Completeddate:     psql.WhereNull[Q, int64](cols.Completeddate),
		Creationdate:      psql.WhereNull[Q, int64](cols.Creationdate),
		Creator:           psql.WhereNull[Q, string](cols.Creator),
		Duedate:           psql.WhereNull[Q, int64](cols.Duedate),
		Exported:          psql.WhereNull[Q, int16](cols.Exported),
		Editdate:          psql.WhereNull[Q, int64](cols.Editdate),
		Editor:            psql.WhereNull[Q, string](cols.Editor),
		Globalid:          psql.WhereNull[Q, string](cols.Globalid),
		Hectares:          psql.WhereNull[Q, float64](cols.Hectares),
		Issprayroute:      psql.WhereNull[Q, int16](cols.Issprayroute),
		Lasttreatactivity: psql.WhereNull[Q, string](cols.Lasttreatactivity),
		Lasttreatdate:     psql.WhereNull[Q, int64](cols.Lasttreatdate),
		Lasttreatproduct:  psql.WhereNull[Q, string](cols.Lasttreatproduct),
		Lasttreatqty:      psql.WhereNull[Q, float64](cols.Lasttreatqty),
		Lasttreatqtyunit:  psql.WhereNull[Q, string](cols.Lasttreatqtyunit),
		Method:            psql.WhereNull[Q, string](cols.Method),
		Name:              psql.WhereNull[Q, string](cols.Name),
		Objectid:          psql.Where[Q, int32](cols.Objectid),
		Priority:          psql.WhereNull[Q, string](cols.Priority),
		Reviewed:          psql.WhereNull[Q, int16](cols.Reviewed),
		Reviewedby:        psql.WhereNull[Q, string](cols.Reviewedby),
		Revieweddate:      psql.WhereNull[Q, int64](cols.Revieweddate),
		ShapeArea:         psql.WhereNull[Q, float64](cols.ShapeArea),
		ShapeLength:       psql.WhereNull[Q, float64](cols.ShapeLength),
		Targetapprate:     psql.WhereNull[Q, float64](cols.Targetapprate),
		Targetproduct:     psql.WhereNull[Q, string](cols.Targetproduct),
		Targetspecies:     psql.WhereNull[Q, string](cols.Targetspecies),
		Zone:              psql.WhereNull[Q, string](cols.Zone),
		Zone2:             psql.WhereNull[Q, string](cols.Zone2),
		GeometryX:         psql.WhereNull[Q, float64](cols.GeometryX),
		GeometryY:         psql.WhereNull[Q, float64](cols.GeometryY),
		Version:           psql.Where[Q, int32](cols.Version),
		Created:           psql.WhereNull[Q, time.Time](cols.Created),
	}
}

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

	switch name {
	case "Organization":
		rel, ok := retrieved.(*Organization)
		if !ok {
			return fmt.Errorf("historyProposedtreatmentarea cannot load %T as %q", retrieved, name)
		}

		o.R.Organization = rel

		if rel != nil {
			rel.R.HistoryProposedtreatmentareas = HistoryProposedtreatmentareaSlice{o}
		}
		return nil
	default:
		return fmt.Errorf("historyProposedtreatmentarea has no relationship %q", name)
	}
}

type historyProposedtreatmentareaPreloader struct {
	Organization func(...psql.PreloadOption) psql.Preloader
}

func buildHistoryProposedtreatmentareaPreloader() historyProposedtreatmentareaPreloader {
	return historyProposedtreatmentareaPreloader{
		Organization: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*Organization, OrganizationSlice](psql.PreloadRel{
				Name: "Organization",
				Sides: []psql.PreloadSide{
					{
						From:        HistoryProposedtreatmentareas,
						To:          Organizations,
						FromColumns: []string{"organization_id"},
						ToColumns:   []string{"id"},
					},
				},
			}, Organizations.Columns.Names(), opts...)
		},
	}
}

type historyProposedtreatmentareaThenLoader[Q orm.Loadable] struct {
	Organization func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
}

func buildHistoryProposedtreatmentareaThenLoader[Q orm.Loadable]() historyProposedtreatmentareaThenLoader[Q] {
	type OrganizationLoadInterface interface {
		LoadOrganization(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}

	return historyProposedtreatmentareaThenLoader[Q]{
		Organization: thenLoadBuilder[Q](
			"Organization",
			func(ctx context.Context, exec bob.Executor, retrieved OrganizationLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadOrganization(ctx, exec, mods...)
			},
		),
	}
}

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

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

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

	related.R.HistoryProposedtreatmentareas = HistoryProposedtreatmentareaSlice{o}

	o.R.Organization = related
	return nil
}

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

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

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

		for _, rel := range organizations {

			if !(o.OrganizationID == rel.ID) {
				continue
			}

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

			o.R.Organization = rel
			break
		}
	}

	return nil
}

type historyProposedtreatmentareaJoins[Q dialect.Joinable] struct {
	typ          string
	Organization modAs[Q, organizationColumns]
}

func (j historyProposedtreatmentareaJoins[Q]) aliasedAs(alias string) historyProposedtreatmentareaJoins[Q] {
	return buildHistoryProposedtreatmentareaJoins[Q](buildHistoryProposedtreatmentareaColumns(alias), j.typ)
}

func buildHistoryProposedtreatmentareaJoins[Q dialect.Joinable](cols historyProposedtreatmentareaColumns, typ string) historyProposedtreatmentareaJoins[Q] {
	return historyProposedtreatmentareaJoins[Q]{
		typ: typ,
		Organization: modAs[Q, organizationColumns]{
			c: Organizations.Columns,
			f: func(to organizationColumns) bob.Mod[Q] {
				mods := make(mods.QueryMods[Q], 0, 1)

				{
					mods = append(mods, dialect.Join[Q](typ, Organizations.Name().As(to.Alias())).On(
						to.ID.EQ(cols.OrganizationID),
					))
				}

				return mods
			},
		},
	}
}