nidus-sync/models/fs_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"
)

// FSProposedtreatmentarea is an object representing the database table.
type FSProposedtreatmentarea 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          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" `
	Updated           time.Time         `db:"updated" `

	R fsProposedtreatmentareaR `db:"-" `
}

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

// FSProposedtreatmentareas contains methods to work with the fs_proposedtreatmentarea table
var FSProposedtreatmentareas = psql.NewTablex[*FSProposedtreatmentarea, FSProposedtreatmentareaSlice, *FSProposedtreatmentareaSetter]("", "fs_proposedtreatmentarea", buildFSProposedtreatmentareaColumns("fs_proposedtreatmentarea"))

// FSProposedtreatmentareasQuery is a query on the fs_proposedtreatmentarea table
type FSProposedtreatmentareasQuery = *psql.ViewQuery[*FSProposedtreatmentarea, FSProposedtreatmentareaSlice]

// fsProposedtreatmentareaR is where relationships are stored.
type fsProposedtreatmentareaR struct {
	Organization *Organization // fs_proposedtreatmentarea.fs_proposedtreatmentarea_organization_id_fkey
}

func buildFSProposedtreatmentareaColumns(alias string) fsProposedtreatmentareaColumns {
	return fsProposedtreatmentareaColumns{
		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", "updated",
		).WithParent("fs_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"),
		Updated:           psql.Quote(alias, "updated"),
	}
}

type fsProposedtreatmentareaColumns 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
	Updated           psql.Expression
}

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

func (fsProposedtreatmentareaColumns) AliasedAs(alias string) fsProposedtreatmentareaColumns {
	return buildFSProposedtreatmentareaColumns(alias)
}

// FSProposedtreatmentareaSetter is used for insert/upsert/update operations
// All values are optional, and do not have to be set
// Generated columns are not included
type FSProposedtreatmentareaSetter 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          omit.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" `
	Updated           omit.Val[time.Time]   `db:"updated" `
}

func (s FSProposedtreatmentareaSetter) SetColumns() []string {
	vals := make([]string, 0, 37)
	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.IsValue() {
		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.Updated.IsValue() {
		vals = append(vals, "updated")
	}
	return vals
}

func (s FSProposedtreatmentareaSetter) Overwrite(t *FSProposedtreatmentarea) {
	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.IsValue() {
		t.Globalid = s.Globalid.MustGet()
	}
	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.Updated.IsValue() {
		t.Updated = s.Updated.MustGet()
	}
}

func (s *FSProposedtreatmentareaSetter) Apply(q *dialect.InsertQuery) {
	q.AppendHooks(func(ctx context.Context, exec bob.Executor) (context.Context, error) {
		return FSProposedtreatmentareas.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, 37)
		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.IsValue() {
			vals[12] = psql.Arg(s.Globalid.MustGet())
		} 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.Updated.IsValue() {
			vals[36] = psql.Arg(s.Updated.MustGet())
		} else {
			vals[36] = psql.Raw("DEFAULT")
		}

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

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

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

	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.IsValue() {
		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.Updated.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "updated")...),
			psql.Arg(s.Updated),
		}})
	}

	return exprs
}

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

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

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

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

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

	return err
}

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

func (o *FSProposedtreatmentarea) pkEQ() dialect.Expression {
	return psql.Quote("fs_proposedtreatmentarea", "objectid").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 FSProposedtreatmentarea
func (o *FSProposedtreatmentarea) Update(ctx context.Context, exec bob.Executor, s *FSProposedtreatmentareaSetter) error {
	v, err := FSProposedtreatmentareas.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 FSProposedtreatmentarea record with an executor
func (o *FSProposedtreatmentarea) Delete(ctx context.Context, exec bob.Executor) error {
	_, err := FSProposedtreatmentareas.Delete(dm.Where(o.pkEQ())).Exec(ctx, exec)
	return err
}

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

	return nil
}

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

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

	return err
}

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

	return psql.Quote("fs_proposedtreatmentarea", "objectid").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 FSProposedtreatmentareaSlice) copyMatchingRows(from ...*FSProposedtreatmentarea) {
	for i, old := range o {
		for _, new := range from {
			if new.Objectid != old.Objectid {
				continue
			}
			new.R = old.R
			o[i] = new
			break
		}
	}
}

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

			return err
		}))

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

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

			return err
		}))

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

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

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

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

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

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

	o2, err := FSProposedtreatmentareas.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 *FSProposedtreatmentarea) Organization(mods ...bob.Mod[*dialect.SelectQuery]) OrganizationsQuery {
	return Organizations.Query(append(mods,
		sm.Where(Organizations.Columns.ID.EQ(psql.Arg(o.OrganizationID))),
	)...)
}

func (os FSProposedtreatmentareaSlice) 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 attachFSProposedtreatmentareaOrganization0(ctx context.Context, exec bob.Executor, count int, fsProposedtreatmentarea0 *FSProposedtreatmentarea, organization1 *Organization) (*FSProposedtreatmentarea, error) {
	setter := &FSProposedtreatmentareaSetter{
		OrganizationID: omit.From(organization1.ID),
	}

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

	return fsProposedtreatmentarea0, nil
}

func (fsProposedtreatmentarea0 *FSProposedtreatmentarea) 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 = attachFSProposedtreatmentareaOrganization0(ctx, exec, 1, fsProposedtreatmentarea0, organization1)
	if err != nil {
		return err
	}

	fsProposedtreatmentarea0.R.Organization = organization1

	organization1.R.FSProposedtreatmentareas = append(organization1.R.FSProposedtreatmentareas, fsProposedtreatmentarea0)

	return nil
}

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

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

	fsProposedtreatmentarea0.R.Organization = organization1

	organization1.R.FSProposedtreatmentareas = append(organization1.R.FSProposedtreatmentareas, fsProposedtreatmentarea0)

	return nil
}

type fsProposedtreatmentareaWhere[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.WhereMod[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]
	Updated           psql.WhereMod[Q, time.Time]
}

func (fsProposedtreatmentareaWhere[Q]) AliasedAs(alias string) fsProposedtreatmentareaWhere[Q] {
	return buildFSProposedtreatmentareaWhere[Q](buildFSProposedtreatmentareaColumns(alias))
}

func buildFSProposedtreatmentareaWhere[Q psql.Filterable](cols fsProposedtreatmentareaColumns) fsProposedtreatmentareaWhere[Q] {
	return fsProposedtreatmentareaWhere[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.Where[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),
		Updated:           psql.Where[Q, time.Time](cols.Updated),
	}
}

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

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

		o.R.Organization = rel

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

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

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

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

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

	return fsProposedtreatmentareaThenLoader[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 fsProposedtreatmentarea's Organization into the .R struct
func (o *FSProposedtreatmentarea) 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.FSProposedtreatmentareas = FSProposedtreatmentareaSlice{o}

	o.R.Organization = related
	return nil
}

// LoadOrganization loads the fsProposedtreatmentarea's Organization into the .R struct
func (os FSProposedtreatmentareaSlice) 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.FSProposedtreatmentareas = append(rel.R.FSProposedtreatmentareas, o)

			o.R.Organization = rel
			break
		}
	}

	return nil
}

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

func (j fsProposedtreatmentareaJoins[Q]) aliasedAs(alias string) fsProposedtreatmentareaJoins[Q] {
	return buildFSProposedtreatmentareaJoins[Q](buildFSProposedtreatmentareaColumns(alias), j.typ)
}

func buildFSProposedtreatmentareaJoins[Q dialect.Joinable](cols fsProposedtreatmentareaColumns, typ string) fsProposedtreatmentareaJoins[Q] {
	return fsProposedtreatmentareaJoins[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
			},
		},
	}
}