Eli Ribble
7c4fb02908
This is an intermediate step between shifting from the old fs_* prefixed table names to an entire fieldseeker schema. At this point we have both, and we aren't doing much with the new schema but compiling.
1400 lines
49 KiB
Go
1400 lines
49 KiB
Go
// Code generated by BobGen psql v0.42.0. DO NOT EDIT.
|
|
// This file is meant to be re-generated in place and/or deleted at any time.
|
|
|
|
package models
|
|
|
|
import (
|
|
"context"
|
|
"io"
|
|
"time"
|
|
|
|
enums "github.com/Gleipnir-Technology/nidus-sync/db/enums"
|
|
"github.com/aarondl/opt/null"
|
|
"github.com/aarondl/opt/omit"
|
|
"github.com/aarondl/opt/omitnull"
|
|
"github.com/gofrs/uuid/v5"
|
|
"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"
|
|
)
|
|
|
|
// FieldseekerTrapdatum is an object representing the database table.
|
|
type FieldseekerTrapdatum struct {
|
|
Objectid int64 `db:"objectid,pk" `
|
|
// Trap Type
|
|
Traptype null.Val[enums.FieldseekerTrapdataMosquitotraptypeEnum] `db:"traptype" `
|
|
// Trap Activity Type
|
|
Trapactivitytype null.Val[enums.FieldseekerTrapdataNotinuitrapactivitytypeEnum] `db:"trapactivitytype" `
|
|
// Start
|
|
Startdatetime null.Val[time.Time] `db:"startdatetime" `
|
|
// Finish
|
|
Enddatetime null.Val[time.Time] `db:"enddatetime" `
|
|
// Comments
|
|
Comments null.Val[string] `db:"comments" `
|
|
// Tech Identifying Species in Lab
|
|
Idbytech null.Val[string] `db:"idbytech" `
|
|
// Tech Sorting Trap Results in Lab
|
|
Sortbytech null.Val[string] `db:"sortbytech" `
|
|
// Processed
|
|
Processed null.Val[enums.FieldseekerTrapdataNotinuitFEnum] `db:"processed" `
|
|
// Site Conditions
|
|
Sitecond null.Val[enums.FieldseekerTrapdataMosquitositeconditionEnum] `db:"sitecond" `
|
|
// Location Name
|
|
Locationname null.Val[string] `db:"locationname" `
|
|
// RecordStatus
|
|
Recordstatus null.Val[int16] `db:"recordstatus" `
|
|
// Reviewed
|
|
Reviewed null.Val[enums.FieldseekerTrapdataNotinuitFEnum] `db:"reviewed" `
|
|
// Reviewed By
|
|
Reviewedby null.Val[string] `db:"reviewedby" `
|
|
// Reviewed Date
|
|
Revieweddate null.Val[time.Time] `db:"revieweddate" `
|
|
// Trap Condition
|
|
Trapcondition null.Val[enums.FieldseekerTrapdataMosquitotrapconditionEnum] `db:"trapcondition" `
|
|
// Trap Nights
|
|
Trapnights null.Val[int16] `db:"trapnights" `
|
|
// Zone
|
|
Zone null.Val[string] `db:"zone" `
|
|
// Zone2
|
|
Zone2 null.Val[string] `db:"zone2" `
|
|
Globalid null.Val[uuid.UUID] `db:"globalid" `
|
|
CreatedUser null.Val[string] `db:"created_user" `
|
|
CreatedDate null.Val[time.Time] `db:"created_date" `
|
|
LastEditedUser null.Val[string] `db:"last_edited_user" `
|
|
LastEditedDate null.Val[time.Time] `db:"last_edited_date" `
|
|
Srid null.Val[uuid.UUID] `db:"srid" `
|
|
// Field Tech
|
|
Fieldtech null.Val[string] `db:"fieldtech" `
|
|
// Gateway Sync
|
|
Gatewaysync null.Val[int16] `db:"gatewaysync" `
|
|
LocID null.Val[uuid.UUID] `db:"loc_id" `
|
|
// Voltage
|
|
Voltage null.Val[float64] `db:"voltage" `
|
|
Winddir null.Val[enums.FieldseekerTrapdataTrapdataWinddirC1a31e05D0B94B228800Be127bb3f166] `db:"winddir" `
|
|
Windspeed null.Val[float64] `db:"windspeed" `
|
|
Avetemp null.Val[float64] `db:"avetemp" `
|
|
Raingauge null.Val[float64] `db:"raingauge" `
|
|
// Landing Rate
|
|
LR null.Val[int16] `db:"lr" `
|
|
Field null.Val[int32] `db:"field" `
|
|
Vectorsurvtrapdataid null.Val[string] `db:"vectorsurvtrapdataid" `
|
|
Vectorsurvtraplocationid null.Val[string] `db:"vectorsurvtraplocationid" `
|
|
Creationdate null.Val[time.Time] `db:"creationdate" `
|
|
Creator null.Val[string] `db:"creator" `
|
|
Editdate null.Val[time.Time] `db:"editdate" `
|
|
Editor null.Val[string] `db:"editor" `
|
|
Lure null.Val[enums.FieldseekerTrapdataTrapdataLure25fe542f077F4254868176e8f436354bEnu] `db:"lure" `
|
|
}
|
|
|
|
// FieldseekerTrapdatumSlice is an alias for a slice of pointers to FieldseekerTrapdatum.
|
|
// This should almost always be used instead of []*FieldseekerTrapdatum.
|
|
type FieldseekerTrapdatumSlice []*FieldseekerTrapdatum
|
|
|
|
// FieldseekerTrapdata contains methods to work with the trapdata table
|
|
var FieldseekerTrapdata = psql.NewTablex[*FieldseekerTrapdatum, FieldseekerTrapdatumSlice, *FieldseekerTrapdatumSetter]("fieldseeker", "trapdata", buildFieldseekerTrapdatumColumns("fieldseeker.trapdata"))
|
|
|
|
// FieldseekerTrapdataQuery is a query on the trapdata table
|
|
type FieldseekerTrapdataQuery = *psql.ViewQuery[*FieldseekerTrapdatum, FieldseekerTrapdatumSlice]
|
|
|
|
func buildFieldseekerTrapdatumColumns(alias string) fieldseekerTrapdatumColumns {
|
|
return fieldseekerTrapdatumColumns{
|
|
ColumnsExpr: expr.NewColumnsExpr(
|
|
"objectid", "traptype", "trapactivitytype", "startdatetime", "enddatetime", "comments", "idbytech", "sortbytech", "processed", "sitecond", "locationname", "recordstatus", "reviewed", "reviewedby", "revieweddate", "trapcondition", "trapnights", "zone", "zone2", "globalid", "created_user", "created_date", "last_edited_user", "last_edited_date", "srid", "fieldtech", "gatewaysync", "loc_id", "voltage", "winddir", "windspeed", "avetemp", "raingauge", "lr", "field", "vectorsurvtrapdataid", "vectorsurvtraplocationid", "creationdate", "creator", "editdate", "editor", "lure",
|
|
).WithParent("fieldseeker.trapdata"),
|
|
tableAlias: alias,
|
|
Objectid: psql.Quote(alias, "objectid"),
|
|
Traptype: psql.Quote(alias, "traptype"),
|
|
Trapactivitytype: psql.Quote(alias, "trapactivitytype"),
|
|
Startdatetime: psql.Quote(alias, "startdatetime"),
|
|
Enddatetime: psql.Quote(alias, "enddatetime"),
|
|
Comments: psql.Quote(alias, "comments"),
|
|
Idbytech: psql.Quote(alias, "idbytech"),
|
|
Sortbytech: psql.Quote(alias, "sortbytech"),
|
|
Processed: psql.Quote(alias, "processed"),
|
|
Sitecond: psql.Quote(alias, "sitecond"),
|
|
Locationname: psql.Quote(alias, "locationname"),
|
|
Recordstatus: psql.Quote(alias, "recordstatus"),
|
|
Reviewed: psql.Quote(alias, "reviewed"),
|
|
Reviewedby: psql.Quote(alias, "reviewedby"),
|
|
Revieweddate: psql.Quote(alias, "revieweddate"),
|
|
Trapcondition: psql.Quote(alias, "trapcondition"),
|
|
Trapnights: psql.Quote(alias, "trapnights"),
|
|
Zone: psql.Quote(alias, "zone"),
|
|
Zone2: psql.Quote(alias, "zone2"),
|
|
Globalid: psql.Quote(alias, "globalid"),
|
|
CreatedUser: psql.Quote(alias, "created_user"),
|
|
CreatedDate: psql.Quote(alias, "created_date"),
|
|
LastEditedUser: psql.Quote(alias, "last_edited_user"),
|
|
LastEditedDate: psql.Quote(alias, "last_edited_date"),
|
|
Srid: psql.Quote(alias, "srid"),
|
|
Fieldtech: psql.Quote(alias, "fieldtech"),
|
|
Gatewaysync: psql.Quote(alias, "gatewaysync"),
|
|
LocID: psql.Quote(alias, "loc_id"),
|
|
Voltage: psql.Quote(alias, "voltage"),
|
|
Winddir: psql.Quote(alias, "winddir"),
|
|
Windspeed: psql.Quote(alias, "windspeed"),
|
|
Avetemp: psql.Quote(alias, "avetemp"),
|
|
Raingauge: psql.Quote(alias, "raingauge"),
|
|
LR: psql.Quote(alias, "lr"),
|
|
Field: psql.Quote(alias, "field"),
|
|
Vectorsurvtrapdataid: psql.Quote(alias, "vectorsurvtrapdataid"),
|
|
Vectorsurvtraplocationid: psql.Quote(alias, "vectorsurvtraplocationid"),
|
|
Creationdate: psql.Quote(alias, "creationdate"),
|
|
Creator: psql.Quote(alias, "creator"),
|
|
Editdate: psql.Quote(alias, "editdate"),
|
|
Editor: psql.Quote(alias, "editor"),
|
|
Lure: psql.Quote(alias, "lure"),
|
|
}
|
|
}
|
|
|
|
type fieldseekerTrapdatumColumns struct {
|
|
expr.ColumnsExpr
|
|
tableAlias string
|
|
Objectid psql.Expression
|
|
Traptype psql.Expression
|
|
Trapactivitytype psql.Expression
|
|
Startdatetime psql.Expression
|
|
Enddatetime psql.Expression
|
|
Comments psql.Expression
|
|
Idbytech psql.Expression
|
|
Sortbytech psql.Expression
|
|
Processed psql.Expression
|
|
Sitecond psql.Expression
|
|
Locationname psql.Expression
|
|
Recordstatus psql.Expression
|
|
Reviewed psql.Expression
|
|
Reviewedby psql.Expression
|
|
Revieweddate psql.Expression
|
|
Trapcondition psql.Expression
|
|
Trapnights psql.Expression
|
|
Zone psql.Expression
|
|
Zone2 psql.Expression
|
|
Globalid psql.Expression
|
|
CreatedUser psql.Expression
|
|
CreatedDate psql.Expression
|
|
LastEditedUser psql.Expression
|
|
LastEditedDate psql.Expression
|
|
Srid psql.Expression
|
|
Fieldtech psql.Expression
|
|
Gatewaysync psql.Expression
|
|
LocID psql.Expression
|
|
Voltage psql.Expression
|
|
Winddir psql.Expression
|
|
Windspeed psql.Expression
|
|
Avetemp psql.Expression
|
|
Raingauge psql.Expression
|
|
LR psql.Expression
|
|
Field psql.Expression
|
|
Vectorsurvtrapdataid psql.Expression
|
|
Vectorsurvtraplocationid psql.Expression
|
|
Creationdate psql.Expression
|
|
Creator psql.Expression
|
|
Editdate psql.Expression
|
|
Editor psql.Expression
|
|
Lure psql.Expression
|
|
}
|
|
|
|
func (c fieldseekerTrapdatumColumns) Alias() string {
|
|
return c.tableAlias
|
|
}
|
|
|
|
func (fieldseekerTrapdatumColumns) AliasedAs(alias string) fieldseekerTrapdatumColumns {
|
|
return buildFieldseekerTrapdatumColumns(alias)
|
|
}
|
|
|
|
// FieldseekerTrapdatumSetter is used for insert/upsert/update operations
|
|
// All values are optional, and do not have to be set
|
|
// Generated columns are not included
|
|
type FieldseekerTrapdatumSetter struct {
|
|
Objectid omit.Val[int64] `db:"objectid,pk" `
|
|
Traptype omitnull.Val[enums.FieldseekerTrapdataMosquitotraptypeEnum] `db:"traptype" `
|
|
Trapactivitytype omitnull.Val[enums.FieldseekerTrapdataNotinuitrapactivitytypeEnum] `db:"trapactivitytype" `
|
|
Startdatetime omitnull.Val[time.Time] `db:"startdatetime" `
|
|
Enddatetime omitnull.Val[time.Time] `db:"enddatetime" `
|
|
Comments omitnull.Val[string] `db:"comments" `
|
|
Idbytech omitnull.Val[string] `db:"idbytech" `
|
|
Sortbytech omitnull.Val[string] `db:"sortbytech" `
|
|
Processed omitnull.Val[enums.FieldseekerTrapdataNotinuitFEnum] `db:"processed" `
|
|
Sitecond omitnull.Val[enums.FieldseekerTrapdataMosquitositeconditionEnum] `db:"sitecond" `
|
|
Locationname omitnull.Val[string] `db:"locationname" `
|
|
Recordstatus omitnull.Val[int16] `db:"recordstatus" `
|
|
Reviewed omitnull.Val[enums.FieldseekerTrapdataNotinuitFEnum] `db:"reviewed" `
|
|
Reviewedby omitnull.Val[string] `db:"reviewedby" `
|
|
Revieweddate omitnull.Val[time.Time] `db:"revieweddate" `
|
|
Trapcondition omitnull.Val[enums.FieldseekerTrapdataMosquitotrapconditionEnum] `db:"trapcondition" `
|
|
Trapnights omitnull.Val[int16] `db:"trapnights" `
|
|
Zone omitnull.Val[string] `db:"zone" `
|
|
Zone2 omitnull.Val[string] `db:"zone2" `
|
|
Globalid omitnull.Val[uuid.UUID] `db:"globalid" `
|
|
CreatedUser omitnull.Val[string] `db:"created_user" `
|
|
CreatedDate omitnull.Val[time.Time] `db:"created_date" `
|
|
LastEditedUser omitnull.Val[string] `db:"last_edited_user" `
|
|
LastEditedDate omitnull.Val[time.Time] `db:"last_edited_date" `
|
|
Srid omitnull.Val[uuid.UUID] `db:"srid" `
|
|
Fieldtech omitnull.Val[string] `db:"fieldtech" `
|
|
Gatewaysync omitnull.Val[int16] `db:"gatewaysync" `
|
|
LocID omitnull.Val[uuid.UUID] `db:"loc_id" `
|
|
Voltage omitnull.Val[float64] `db:"voltage" `
|
|
Winddir omitnull.Val[enums.FieldseekerTrapdataTrapdataWinddirC1a31e05D0B94B228800Be127bb3f166] `db:"winddir" `
|
|
Windspeed omitnull.Val[float64] `db:"windspeed" `
|
|
Avetemp omitnull.Val[float64] `db:"avetemp" `
|
|
Raingauge omitnull.Val[float64] `db:"raingauge" `
|
|
LR omitnull.Val[int16] `db:"lr" `
|
|
Field omitnull.Val[int32] `db:"field" `
|
|
Vectorsurvtrapdataid omitnull.Val[string] `db:"vectorsurvtrapdataid" `
|
|
Vectorsurvtraplocationid omitnull.Val[string] `db:"vectorsurvtraplocationid" `
|
|
Creationdate omitnull.Val[time.Time] `db:"creationdate" `
|
|
Creator omitnull.Val[string] `db:"creator" `
|
|
Editdate omitnull.Val[time.Time] `db:"editdate" `
|
|
Editor omitnull.Val[string] `db:"editor" `
|
|
Lure omitnull.Val[enums.FieldseekerTrapdataTrapdataLure25fe542f077F4254868176e8f436354bEnu] `db:"lure" `
|
|
}
|
|
|
|
func (s FieldseekerTrapdatumSetter) SetColumns() []string {
|
|
vals := make([]string, 0, 42)
|
|
if s.Objectid.IsValue() {
|
|
vals = append(vals, "objectid")
|
|
}
|
|
if !s.Traptype.IsUnset() {
|
|
vals = append(vals, "traptype")
|
|
}
|
|
if !s.Trapactivitytype.IsUnset() {
|
|
vals = append(vals, "trapactivitytype")
|
|
}
|
|
if !s.Startdatetime.IsUnset() {
|
|
vals = append(vals, "startdatetime")
|
|
}
|
|
if !s.Enddatetime.IsUnset() {
|
|
vals = append(vals, "enddatetime")
|
|
}
|
|
if !s.Comments.IsUnset() {
|
|
vals = append(vals, "comments")
|
|
}
|
|
if !s.Idbytech.IsUnset() {
|
|
vals = append(vals, "idbytech")
|
|
}
|
|
if !s.Sortbytech.IsUnset() {
|
|
vals = append(vals, "sortbytech")
|
|
}
|
|
if !s.Processed.IsUnset() {
|
|
vals = append(vals, "processed")
|
|
}
|
|
if !s.Sitecond.IsUnset() {
|
|
vals = append(vals, "sitecond")
|
|
}
|
|
if !s.Locationname.IsUnset() {
|
|
vals = append(vals, "locationname")
|
|
}
|
|
if !s.Recordstatus.IsUnset() {
|
|
vals = append(vals, "recordstatus")
|
|
}
|
|
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.Trapcondition.IsUnset() {
|
|
vals = append(vals, "trapcondition")
|
|
}
|
|
if !s.Trapnights.IsUnset() {
|
|
vals = append(vals, "trapnights")
|
|
}
|
|
if !s.Zone.IsUnset() {
|
|
vals = append(vals, "zone")
|
|
}
|
|
if !s.Zone2.IsUnset() {
|
|
vals = append(vals, "zone2")
|
|
}
|
|
if !s.Globalid.IsUnset() {
|
|
vals = append(vals, "globalid")
|
|
}
|
|
if !s.CreatedUser.IsUnset() {
|
|
vals = append(vals, "created_user")
|
|
}
|
|
if !s.CreatedDate.IsUnset() {
|
|
vals = append(vals, "created_date")
|
|
}
|
|
if !s.LastEditedUser.IsUnset() {
|
|
vals = append(vals, "last_edited_user")
|
|
}
|
|
if !s.LastEditedDate.IsUnset() {
|
|
vals = append(vals, "last_edited_date")
|
|
}
|
|
if !s.Srid.IsUnset() {
|
|
vals = append(vals, "srid")
|
|
}
|
|
if !s.Fieldtech.IsUnset() {
|
|
vals = append(vals, "fieldtech")
|
|
}
|
|
if !s.Gatewaysync.IsUnset() {
|
|
vals = append(vals, "gatewaysync")
|
|
}
|
|
if !s.LocID.IsUnset() {
|
|
vals = append(vals, "loc_id")
|
|
}
|
|
if !s.Voltage.IsUnset() {
|
|
vals = append(vals, "voltage")
|
|
}
|
|
if !s.Winddir.IsUnset() {
|
|
vals = append(vals, "winddir")
|
|
}
|
|
if !s.Windspeed.IsUnset() {
|
|
vals = append(vals, "windspeed")
|
|
}
|
|
if !s.Avetemp.IsUnset() {
|
|
vals = append(vals, "avetemp")
|
|
}
|
|
if !s.Raingauge.IsUnset() {
|
|
vals = append(vals, "raingauge")
|
|
}
|
|
if !s.LR.IsUnset() {
|
|
vals = append(vals, "lr")
|
|
}
|
|
if !s.Field.IsUnset() {
|
|
vals = append(vals, "field")
|
|
}
|
|
if !s.Vectorsurvtrapdataid.IsUnset() {
|
|
vals = append(vals, "vectorsurvtrapdataid")
|
|
}
|
|
if !s.Vectorsurvtraplocationid.IsUnset() {
|
|
vals = append(vals, "vectorsurvtraplocationid")
|
|
}
|
|
if !s.Creationdate.IsUnset() {
|
|
vals = append(vals, "creationdate")
|
|
}
|
|
if !s.Creator.IsUnset() {
|
|
vals = append(vals, "creator")
|
|
}
|
|
if !s.Editdate.IsUnset() {
|
|
vals = append(vals, "editdate")
|
|
}
|
|
if !s.Editor.IsUnset() {
|
|
vals = append(vals, "editor")
|
|
}
|
|
if !s.Lure.IsUnset() {
|
|
vals = append(vals, "lure")
|
|
}
|
|
return vals
|
|
}
|
|
|
|
func (s FieldseekerTrapdatumSetter) Overwrite(t *FieldseekerTrapdatum) {
|
|
if s.Objectid.IsValue() {
|
|
t.Objectid = s.Objectid.MustGet()
|
|
}
|
|
if !s.Traptype.IsUnset() {
|
|
t.Traptype = s.Traptype.MustGetNull()
|
|
}
|
|
if !s.Trapactivitytype.IsUnset() {
|
|
t.Trapactivitytype = s.Trapactivitytype.MustGetNull()
|
|
}
|
|
if !s.Startdatetime.IsUnset() {
|
|
t.Startdatetime = s.Startdatetime.MustGetNull()
|
|
}
|
|
if !s.Enddatetime.IsUnset() {
|
|
t.Enddatetime = s.Enddatetime.MustGetNull()
|
|
}
|
|
if !s.Comments.IsUnset() {
|
|
t.Comments = s.Comments.MustGetNull()
|
|
}
|
|
if !s.Idbytech.IsUnset() {
|
|
t.Idbytech = s.Idbytech.MustGetNull()
|
|
}
|
|
if !s.Sortbytech.IsUnset() {
|
|
t.Sortbytech = s.Sortbytech.MustGetNull()
|
|
}
|
|
if !s.Processed.IsUnset() {
|
|
t.Processed = s.Processed.MustGetNull()
|
|
}
|
|
if !s.Sitecond.IsUnset() {
|
|
t.Sitecond = s.Sitecond.MustGetNull()
|
|
}
|
|
if !s.Locationname.IsUnset() {
|
|
t.Locationname = s.Locationname.MustGetNull()
|
|
}
|
|
if !s.Recordstatus.IsUnset() {
|
|
t.Recordstatus = s.Recordstatus.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.Trapcondition.IsUnset() {
|
|
t.Trapcondition = s.Trapcondition.MustGetNull()
|
|
}
|
|
if !s.Trapnights.IsUnset() {
|
|
t.Trapnights = s.Trapnights.MustGetNull()
|
|
}
|
|
if !s.Zone.IsUnset() {
|
|
t.Zone = s.Zone.MustGetNull()
|
|
}
|
|
if !s.Zone2.IsUnset() {
|
|
t.Zone2 = s.Zone2.MustGetNull()
|
|
}
|
|
if !s.Globalid.IsUnset() {
|
|
t.Globalid = s.Globalid.MustGetNull()
|
|
}
|
|
if !s.CreatedUser.IsUnset() {
|
|
t.CreatedUser = s.CreatedUser.MustGetNull()
|
|
}
|
|
if !s.CreatedDate.IsUnset() {
|
|
t.CreatedDate = s.CreatedDate.MustGetNull()
|
|
}
|
|
if !s.LastEditedUser.IsUnset() {
|
|
t.LastEditedUser = s.LastEditedUser.MustGetNull()
|
|
}
|
|
if !s.LastEditedDate.IsUnset() {
|
|
t.LastEditedDate = s.LastEditedDate.MustGetNull()
|
|
}
|
|
if !s.Srid.IsUnset() {
|
|
t.Srid = s.Srid.MustGetNull()
|
|
}
|
|
if !s.Fieldtech.IsUnset() {
|
|
t.Fieldtech = s.Fieldtech.MustGetNull()
|
|
}
|
|
if !s.Gatewaysync.IsUnset() {
|
|
t.Gatewaysync = s.Gatewaysync.MustGetNull()
|
|
}
|
|
if !s.LocID.IsUnset() {
|
|
t.LocID = s.LocID.MustGetNull()
|
|
}
|
|
if !s.Voltage.IsUnset() {
|
|
t.Voltage = s.Voltage.MustGetNull()
|
|
}
|
|
if !s.Winddir.IsUnset() {
|
|
t.Winddir = s.Winddir.MustGetNull()
|
|
}
|
|
if !s.Windspeed.IsUnset() {
|
|
t.Windspeed = s.Windspeed.MustGetNull()
|
|
}
|
|
if !s.Avetemp.IsUnset() {
|
|
t.Avetemp = s.Avetemp.MustGetNull()
|
|
}
|
|
if !s.Raingauge.IsUnset() {
|
|
t.Raingauge = s.Raingauge.MustGetNull()
|
|
}
|
|
if !s.LR.IsUnset() {
|
|
t.LR = s.LR.MustGetNull()
|
|
}
|
|
if !s.Field.IsUnset() {
|
|
t.Field = s.Field.MustGetNull()
|
|
}
|
|
if !s.Vectorsurvtrapdataid.IsUnset() {
|
|
t.Vectorsurvtrapdataid = s.Vectorsurvtrapdataid.MustGetNull()
|
|
}
|
|
if !s.Vectorsurvtraplocationid.IsUnset() {
|
|
t.Vectorsurvtraplocationid = s.Vectorsurvtraplocationid.MustGetNull()
|
|
}
|
|
if !s.Creationdate.IsUnset() {
|
|
t.Creationdate = s.Creationdate.MustGetNull()
|
|
}
|
|
if !s.Creator.IsUnset() {
|
|
t.Creator = s.Creator.MustGetNull()
|
|
}
|
|
if !s.Editdate.IsUnset() {
|
|
t.Editdate = s.Editdate.MustGetNull()
|
|
}
|
|
if !s.Editor.IsUnset() {
|
|
t.Editor = s.Editor.MustGetNull()
|
|
}
|
|
if !s.Lure.IsUnset() {
|
|
t.Lure = s.Lure.MustGetNull()
|
|
}
|
|
}
|
|
|
|
func (s *FieldseekerTrapdatumSetter) Apply(q *dialect.InsertQuery) {
|
|
q.AppendHooks(func(ctx context.Context, exec bob.Executor) (context.Context, error) {
|
|
return FieldseekerTrapdata.BeforeInsertHooks.RunHooks(ctx, exec, s)
|
|
})
|
|
|
|
q.AppendValues(bob.ExpressionFunc(func(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
|
|
vals := make([]bob.Expression, 42)
|
|
if s.Objectid.IsValue() {
|
|
vals[0] = psql.Arg(s.Objectid.MustGet())
|
|
} else {
|
|
vals[0] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Traptype.IsUnset() {
|
|
vals[1] = psql.Arg(s.Traptype.MustGetNull())
|
|
} else {
|
|
vals[1] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Trapactivitytype.IsUnset() {
|
|
vals[2] = psql.Arg(s.Trapactivitytype.MustGetNull())
|
|
} else {
|
|
vals[2] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Startdatetime.IsUnset() {
|
|
vals[3] = psql.Arg(s.Startdatetime.MustGetNull())
|
|
} else {
|
|
vals[3] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Enddatetime.IsUnset() {
|
|
vals[4] = psql.Arg(s.Enddatetime.MustGetNull())
|
|
} else {
|
|
vals[4] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Comments.IsUnset() {
|
|
vals[5] = psql.Arg(s.Comments.MustGetNull())
|
|
} else {
|
|
vals[5] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Idbytech.IsUnset() {
|
|
vals[6] = psql.Arg(s.Idbytech.MustGetNull())
|
|
} else {
|
|
vals[6] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Sortbytech.IsUnset() {
|
|
vals[7] = psql.Arg(s.Sortbytech.MustGetNull())
|
|
} else {
|
|
vals[7] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Processed.IsUnset() {
|
|
vals[8] = psql.Arg(s.Processed.MustGetNull())
|
|
} else {
|
|
vals[8] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Sitecond.IsUnset() {
|
|
vals[9] = psql.Arg(s.Sitecond.MustGetNull())
|
|
} else {
|
|
vals[9] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Locationname.IsUnset() {
|
|
vals[10] = psql.Arg(s.Locationname.MustGetNull())
|
|
} else {
|
|
vals[10] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Recordstatus.IsUnset() {
|
|
vals[11] = psql.Arg(s.Recordstatus.MustGetNull())
|
|
} else {
|
|
vals[11] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Reviewed.IsUnset() {
|
|
vals[12] = psql.Arg(s.Reviewed.MustGetNull())
|
|
} else {
|
|
vals[12] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Reviewedby.IsUnset() {
|
|
vals[13] = psql.Arg(s.Reviewedby.MustGetNull())
|
|
} else {
|
|
vals[13] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Revieweddate.IsUnset() {
|
|
vals[14] = psql.Arg(s.Revieweddate.MustGetNull())
|
|
} else {
|
|
vals[14] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Trapcondition.IsUnset() {
|
|
vals[15] = psql.Arg(s.Trapcondition.MustGetNull())
|
|
} else {
|
|
vals[15] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Trapnights.IsUnset() {
|
|
vals[16] = psql.Arg(s.Trapnights.MustGetNull())
|
|
} else {
|
|
vals[16] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Zone.IsUnset() {
|
|
vals[17] = psql.Arg(s.Zone.MustGetNull())
|
|
} else {
|
|
vals[17] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Zone2.IsUnset() {
|
|
vals[18] = psql.Arg(s.Zone2.MustGetNull())
|
|
} else {
|
|
vals[18] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Globalid.IsUnset() {
|
|
vals[19] = psql.Arg(s.Globalid.MustGetNull())
|
|
} else {
|
|
vals[19] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.CreatedUser.IsUnset() {
|
|
vals[20] = psql.Arg(s.CreatedUser.MustGetNull())
|
|
} else {
|
|
vals[20] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.CreatedDate.IsUnset() {
|
|
vals[21] = psql.Arg(s.CreatedDate.MustGetNull())
|
|
} else {
|
|
vals[21] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.LastEditedUser.IsUnset() {
|
|
vals[22] = psql.Arg(s.LastEditedUser.MustGetNull())
|
|
} else {
|
|
vals[22] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.LastEditedDate.IsUnset() {
|
|
vals[23] = psql.Arg(s.LastEditedDate.MustGetNull())
|
|
} else {
|
|
vals[23] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Srid.IsUnset() {
|
|
vals[24] = psql.Arg(s.Srid.MustGetNull())
|
|
} else {
|
|
vals[24] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Fieldtech.IsUnset() {
|
|
vals[25] = psql.Arg(s.Fieldtech.MustGetNull())
|
|
} else {
|
|
vals[25] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Gatewaysync.IsUnset() {
|
|
vals[26] = psql.Arg(s.Gatewaysync.MustGetNull())
|
|
} else {
|
|
vals[26] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.LocID.IsUnset() {
|
|
vals[27] = psql.Arg(s.LocID.MustGetNull())
|
|
} else {
|
|
vals[27] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Voltage.IsUnset() {
|
|
vals[28] = psql.Arg(s.Voltage.MustGetNull())
|
|
} else {
|
|
vals[28] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Winddir.IsUnset() {
|
|
vals[29] = psql.Arg(s.Winddir.MustGetNull())
|
|
} else {
|
|
vals[29] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Windspeed.IsUnset() {
|
|
vals[30] = psql.Arg(s.Windspeed.MustGetNull())
|
|
} else {
|
|
vals[30] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Avetemp.IsUnset() {
|
|
vals[31] = psql.Arg(s.Avetemp.MustGetNull())
|
|
} else {
|
|
vals[31] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Raingauge.IsUnset() {
|
|
vals[32] = psql.Arg(s.Raingauge.MustGetNull())
|
|
} else {
|
|
vals[32] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.LR.IsUnset() {
|
|
vals[33] = psql.Arg(s.LR.MustGetNull())
|
|
} else {
|
|
vals[33] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Field.IsUnset() {
|
|
vals[34] = psql.Arg(s.Field.MustGetNull())
|
|
} else {
|
|
vals[34] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Vectorsurvtrapdataid.IsUnset() {
|
|
vals[35] = psql.Arg(s.Vectorsurvtrapdataid.MustGetNull())
|
|
} else {
|
|
vals[35] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Vectorsurvtraplocationid.IsUnset() {
|
|
vals[36] = psql.Arg(s.Vectorsurvtraplocationid.MustGetNull())
|
|
} else {
|
|
vals[36] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Creationdate.IsUnset() {
|
|
vals[37] = psql.Arg(s.Creationdate.MustGetNull())
|
|
} else {
|
|
vals[37] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Creator.IsUnset() {
|
|
vals[38] = psql.Arg(s.Creator.MustGetNull())
|
|
} else {
|
|
vals[38] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Editdate.IsUnset() {
|
|
vals[39] = psql.Arg(s.Editdate.MustGetNull())
|
|
} else {
|
|
vals[39] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Editor.IsUnset() {
|
|
vals[40] = psql.Arg(s.Editor.MustGetNull())
|
|
} else {
|
|
vals[40] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
if !s.Lure.IsUnset() {
|
|
vals[41] = psql.Arg(s.Lure.MustGetNull())
|
|
} else {
|
|
vals[41] = psql.Raw("DEFAULT")
|
|
}
|
|
|
|
return bob.ExpressSlice(ctx, w, d, start, vals, "", ", ", "")
|
|
}))
|
|
}
|
|
|
|
func (s FieldseekerTrapdatumSetter) UpdateMod() bob.Mod[*dialect.UpdateQuery] {
|
|
return um.Set(s.Expressions()...)
|
|
}
|
|
|
|
func (s FieldseekerTrapdatumSetter) Expressions(prefix ...string) []bob.Expression {
|
|
exprs := make([]bob.Expression, 0, 42)
|
|
|
|
if s.Objectid.IsValue() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "objectid")...),
|
|
psql.Arg(s.Objectid),
|
|
}})
|
|
}
|
|
|
|
if !s.Traptype.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "traptype")...),
|
|
psql.Arg(s.Traptype),
|
|
}})
|
|
}
|
|
|
|
if !s.Trapactivitytype.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "trapactivitytype")...),
|
|
psql.Arg(s.Trapactivitytype),
|
|
}})
|
|
}
|
|
|
|
if !s.Startdatetime.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "startdatetime")...),
|
|
psql.Arg(s.Startdatetime),
|
|
}})
|
|
}
|
|
|
|
if !s.Enddatetime.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "enddatetime")...),
|
|
psql.Arg(s.Enddatetime),
|
|
}})
|
|
}
|
|
|
|
if !s.Comments.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "comments")...),
|
|
psql.Arg(s.Comments),
|
|
}})
|
|
}
|
|
|
|
if !s.Idbytech.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "idbytech")...),
|
|
psql.Arg(s.Idbytech),
|
|
}})
|
|
}
|
|
|
|
if !s.Sortbytech.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "sortbytech")...),
|
|
psql.Arg(s.Sortbytech),
|
|
}})
|
|
}
|
|
|
|
if !s.Processed.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "processed")...),
|
|
psql.Arg(s.Processed),
|
|
}})
|
|
}
|
|
|
|
if !s.Sitecond.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "sitecond")...),
|
|
psql.Arg(s.Sitecond),
|
|
}})
|
|
}
|
|
|
|
if !s.Locationname.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "locationname")...),
|
|
psql.Arg(s.Locationname),
|
|
}})
|
|
}
|
|
|
|
if !s.Recordstatus.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "recordstatus")...),
|
|
psql.Arg(s.Recordstatus),
|
|
}})
|
|
}
|
|
|
|
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.Trapcondition.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "trapcondition")...),
|
|
psql.Arg(s.Trapcondition),
|
|
}})
|
|
}
|
|
|
|
if !s.Trapnights.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "trapnights")...),
|
|
psql.Arg(s.Trapnights),
|
|
}})
|
|
}
|
|
|
|
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.Globalid.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "globalid")...),
|
|
psql.Arg(s.Globalid),
|
|
}})
|
|
}
|
|
|
|
if !s.CreatedUser.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "created_user")...),
|
|
psql.Arg(s.CreatedUser),
|
|
}})
|
|
}
|
|
|
|
if !s.CreatedDate.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "created_date")...),
|
|
psql.Arg(s.CreatedDate),
|
|
}})
|
|
}
|
|
|
|
if !s.LastEditedUser.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "last_edited_user")...),
|
|
psql.Arg(s.LastEditedUser),
|
|
}})
|
|
}
|
|
|
|
if !s.LastEditedDate.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "last_edited_date")...),
|
|
psql.Arg(s.LastEditedDate),
|
|
}})
|
|
}
|
|
|
|
if !s.Srid.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "srid")...),
|
|
psql.Arg(s.Srid),
|
|
}})
|
|
}
|
|
|
|
if !s.Fieldtech.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "fieldtech")...),
|
|
psql.Arg(s.Fieldtech),
|
|
}})
|
|
}
|
|
|
|
if !s.Gatewaysync.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "gatewaysync")...),
|
|
psql.Arg(s.Gatewaysync),
|
|
}})
|
|
}
|
|
|
|
if !s.LocID.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "loc_id")...),
|
|
psql.Arg(s.LocID),
|
|
}})
|
|
}
|
|
|
|
if !s.Voltage.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "voltage")...),
|
|
psql.Arg(s.Voltage),
|
|
}})
|
|
}
|
|
|
|
if !s.Winddir.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "winddir")...),
|
|
psql.Arg(s.Winddir),
|
|
}})
|
|
}
|
|
|
|
if !s.Windspeed.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "windspeed")...),
|
|
psql.Arg(s.Windspeed),
|
|
}})
|
|
}
|
|
|
|
if !s.Avetemp.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "avetemp")...),
|
|
psql.Arg(s.Avetemp),
|
|
}})
|
|
}
|
|
|
|
if !s.Raingauge.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "raingauge")...),
|
|
psql.Arg(s.Raingauge),
|
|
}})
|
|
}
|
|
|
|
if !s.LR.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "lr")...),
|
|
psql.Arg(s.LR),
|
|
}})
|
|
}
|
|
|
|
if !s.Field.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "field")...),
|
|
psql.Arg(s.Field),
|
|
}})
|
|
}
|
|
|
|
if !s.Vectorsurvtrapdataid.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "vectorsurvtrapdataid")...),
|
|
psql.Arg(s.Vectorsurvtrapdataid),
|
|
}})
|
|
}
|
|
|
|
if !s.Vectorsurvtraplocationid.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "vectorsurvtraplocationid")...),
|
|
psql.Arg(s.Vectorsurvtraplocationid),
|
|
}})
|
|
}
|
|
|
|
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.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.Lure.IsUnset() {
|
|
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
|
|
psql.Quote(append(prefix, "lure")...),
|
|
psql.Arg(s.Lure),
|
|
}})
|
|
}
|
|
|
|
return exprs
|
|
}
|
|
|
|
// FindFieldseekerTrapdatum retrieves a single record by primary key
|
|
// If cols is empty Find will return all columns.
|
|
func FindFieldseekerTrapdatum(ctx context.Context, exec bob.Executor, ObjectidPK int64, cols ...string) (*FieldseekerTrapdatum, error) {
|
|
if len(cols) == 0 {
|
|
return FieldseekerTrapdata.Query(
|
|
sm.Where(FieldseekerTrapdata.Columns.Objectid.EQ(psql.Arg(ObjectidPK))),
|
|
).One(ctx, exec)
|
|
}
|
|
|
|
return FieldseekerTrapdata.Query(
|
|
sm.Where(FieldseekerTrapdata.Columns.Objectid.EQ(psql.Arg(ObjectidPK))),
|
|
sm.Columns(FieldseekerTrapdata.Columns.Only(cols...)),
|
|
).One(ctx, exec)
|
|
}
|
|
|
|
// FieldseekerTrapdatumExists checks the presence of a single record by primary key
|
|
func FieldseekerTrapdatumExists(ctx context.Context, exec bob.Executor, ObjectidPK int64) (bool, error) {
|
|
return FieldseekerTrapdata.Query(
|
|
sm.Where(FieldseekerTrapdata.Columns.Objectid.EQ(psql.Arg(ObjectidPK))),
|
|
).Exists(ctx, exec)
|
|
}
|
|
|
|
// AfterQueryHook is called after FieldseekerTrapdatum is retrieved from the database
|
|
func (o *FieldseekerTrapdatum) AfterQueryHook(ctx context.Context, exec bob.Executor, queryType bob.QueryType) error {
|
|
var err error
|
|
|
|
switch queryType {
|
|
case bob.QueryTypeSelect:
|
|
ctx, err = FieldseekerTrapdata.AfterSelectHooks.RunHooks(ctx, exec, FieldseekerTrapdatumSlice{o})
|
|
case bob.QueryTypeInsert:
|
|
ctx, err = FieldseekerTrapdata.AfterInsertHooks.RunHooks(ctx, exec, FieldseekerTrapdatumSlice{o})
|
|
case bob.QueryTypeUpdate:
|
|
ctx, err = FieldseekerTrapdata.AfterUpdateHooks.RunHooks(ctx, exec, FieldseekerTrapdatumSlice{o})
|
|
case bob.QueryTypeDelete:
|
|
ctx, err = FieldseekerTrapdata.AfterDeleteHooks.RunHooks(ctx, exec, FieldseekerTrapdatumSlice{o})
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
// primaryKeyVals returns the primary key values of the FieldseekerTrapdatum
|
|
func (o *FieldseekerTrapdatum) primaryKeyVals() bob.Expression {
|
|
return psql.Arg(o.Objectid)
|
|
}
|
|
|
|
func (o *FieldseekerTrapdatum) pkEQ() dialect.Expression {
|
|
return psql.Quote("fieldseeker.trapdata", "objectid").EQ(bob.ExpressionFunc(func(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
|
|
return o.primaryKeyVals().WriteSQL(ctx, w, d, start)
|
|
}))
|
|
}
|
|
|
|
// Update uses an executor to update the FieldseekerTrapdatum
|
|
func (o *FieldseekerTrapdatum) Update(ctx context.Context, exec bob.Executor, s *FieldseekerTrapdatumSetter) error {
|
|
v, err := FieldseekerTrapdata.Update(s.UpdateMod(), um.Where(o.pkEQ())).One(ctx, exec)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
*o = *v
|
|
|
|
return nil
|
|
}
|
|
|
|
// Delete deletes a single FieldseekerTrapdatum record with an executor
|
|
func (o *FieldseekerTrapdatum) Delete(ctx context.Context, exec bob.Executor) error {
|
|
_, err := FieldseekerTrapdata.Delete(dm.Where(o.pkEQ())).Exec(ctx, exec)
|
|
return err
|
|
}
|
|
|
|
// Reload refreshes the FieldseekerTrapdatum using the executor
|
|
func (o *FieldseekerTrapdatum) Reload(ctx context.Context, exec bob.Executor) error {
|
|
o2, err := FieldseekerTrapdata.Query(
|
|
sm.Where(FieldseekerTrapdata.Columns.Objectid.EQ(psql.Arg(o.Objectid))),
|
|
).One(ctx, exec)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
*o = *o2
|
|
|
|
return nil
|
|
}
|
|
|
|
// AfterQueryHook is called after FieldseekerTrapdatumSlice is retrieved from the database
|
|
func (o FieldseekerTrapdatumSlice) AfterQueryHook(ctx context.Context, exec bob.Executor, queryType bob.QueryType) error {
|
|
var err error
|
|
|
|
switch queryType {
|
|
case bob.QueryTypeSelect:
|
|
ctx, err = FieldseekerTrapdata.AfterSelectHooks.RunHooks(ctx, exec, o)
|
|
case bob.QueryTypeInsert:
|
|
ctx, err = FieldseekerTrapdata.AfterInsertHooks.RunHooks(ctx, exec, o)
|
|
case bob.QueryTypeUpdate:
|
|
ctx, err = FieldseekerTrapdata.AfterUpdateHooks.RunHooks(ctx, exec, o)
|
|
case bob.QueryTypeDelete:
|
|
ctx, err = FieldseekerTrapdata.AfterDeleteHooks.RunHooks(ctx, exec, o)
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
func (o FieldseekerTrapdatumSlice) pkIN() dialect.Expression {
|
|
if len(o) == 0 {
|
|
return psql.Raw("NULL")
|
|
}
|
|
|
|
return psql.Quote("fieldseeker.trapdata", "objectid").In(bob.ExpressionFunc(func(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
|
|
pkPairs := make([]bob.Expression, len(o))
|
|
for i, row := range o {
|
|
pkPairs[i] = row.primaryKeyVals()
|
|
}
|
|
return bob.ExpressSlice(ctx, w, d, start, pkPairs, "", ", ", "")
|
|
}))
|
|
}
|
|
|
|
// copyMatchingRows finds models in the given slice that have the same primary key
|
|
// then it first copies the existing relationships from the old model to the new model
|
|
// and then replaces the old model in the slice with the new model
|
|
func (o FieldseekerTrapdatumSlice) copyMatchingRows(from ...*FieldseekerTrapdatum) {
|
|
for i, old := range o {
|
|
for _, new := range from {
|
|
if new.Objectid != old.Objectid {
|
|
continue
|
|
}
|
|
|
|
o[i] = new
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// UpdateMod modifies an update query with "WHERE primary_key IN (o...)"
|
|
func (o FieldseekerTrapdatumSlice) 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 FieldseekerTrapdata.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 *FieldseekerTrapdatum:
|
|
o.copyMatchingRows(retrieved)
|
|
case []*FieldseekerTrapdatum:
|
|
o.copyMatchingRows(retrieved...)
|
|
case FieldseekerTrapdatumSlice:
|
|
o.copyMatchingRows(retrieved...)
|
|
default:
|
|
// If the retrieved value is not a FieldseekerTrapdatum or a slice of FieldseekerTrapdatum
|
|
// then run the AfterUpdateHooks on the slice
|
|
_, err = FieldseekerTrapdata.AfterUpdateHooks.RunHooks(ctx, exec, o)
|
|
}
|
|
|
|
return err
|
|
}))
|
|
|
|
q.AppendWhere(o.pkIN())
|
|
})
|
|
}
|
|
|
|
// DeleteMod modifies an delete query with "WHERE primary_key IN (o...)"
|
|
func (o FieldseekerTrapdatumSlice) 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 FieldseekerTrapdata.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 *FieldseekerTrapdatum:
|
|
o.copyMatchingRows(retrieved)
|
|
case []*FieldseekerTrapdatum:
|
|
o.copyMatchingRows(retrieved...)
|
|
case FieldseekerTrapdatumSlice:
|
|
o.copyMatchingRows(retrieved...)
|
|
default:
|
|
// If the retrieved value is not a FieldseekerTrapdatum or a slice of FieldseekerTrapdatum
|
|
// then run the AfterDeleteHooks on the slice
|
|
_, err = FieldseekerTrapdata.AfterDeleteHooks.RunHooks(ctx, exec, o)
|
|
}
|
|
|
|
return err
|
|
}))
|
|
|
|
q.AppendWhere(o.pkIN())
|
|
})
|
|
}
|
|
|
|
func (o FieldseekerTrapdatumSlice) UpdateAll(ctx context.Context, exec bob.Executor, vals FieldseekerTrapdatumSetter) error {
|
|
if len(o) == 0 {
|
|
return nil
|
|
}
|
|
|
|
_, err := FieldseekerTrapdata.Update(vals.UpdateMod(), o.UpdateMod()).All(ctx, exec)
|
|
return err
|
|
}
|
|
|
|
func (o FieldseekerTrapdatumSlice) DeleteAll(ctx context.Context, exec bob.Executor) error {
|
|
if len(o) == 0 {
|
|
return nil
|
|
}
|
|
|
|
_, err := FieldseekerTrapdata.Delete(o.DeleteMod()).Exec(ctx, exec)
|
|
return err
|
|
}
|
|
|
|
func (o FieldseekerTrapdatumSlice) ReloadAll(ctx context.Context, exec bob.Executor) error {
|
|
if len(o) == 0 {
|
|
return nil
|
|
}
|
|
|
|
o2, err := FieldseekerTrapdata.Query(sm.Where(o.pkIN())).All(ctx, exec)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
o.copyMatchingRows(o2...)
|
|
|
|
return nil
|
|
}
|
|
|
|
type fieldseekerTrapdatumWhere[Q psql.Filterable] struct {
|
|
Objectid psql.WhereMod[Q, int64]
|
|
Traptype psql.WhereNullMod[Q, enums.FieldseekerTrapdataMosquitotraptypeEnum]
|
|
Trapactivitytype psql.WhereNullMod[Q, enums.FieldseekerTrapdataNotinuitrapactivitytypeEnum]
|
|
Startdatetime psql.WhereNullMod[Q, time.Time]
|
|
Enddatetime psql.WhereNullMod[Q, time.Time]
|
|
Comments psql.WhereNullMod[Q, string]
|
|
Idbytech psql.WhereNullMod[Q, string]
|
|
Sortbytech psql.WhereNullMod[Q, string]
|
|
Processed psql.WhereNullMod[Q, enums.FieldseekerTrapdataNotinuitFEnum]
|
|
Sitecond psql.WhereNullMod[Q, enums.FieldseekerTrapdataMosquitositeconditionEnum]
|
|
Locationname psql.WhereNullMod[Q, string]
|
|
Recordstatus psql.WhereNullMod[Q, int16]
|
|
Reviewed psql.WhereNullMod[Q, enums.FieldseekerTrapdataNotinuitFEnum]
|
|
Reviewedby psql.WhereNullMod[Q, string]
|
|
Revieweddate psql.WhereNullMod[Q, time.Time]
|
|
Trapcondition psql.WhereNullMod[Q, enums.FieldseekerTrapdataMosquitotrapconditionEnum]
|
|
Trapnights psql.WhereNullMod[Q, int16]
|
|
Zone psql.WhereNullMod[Q, string]
|
|
Zone2 psql.WhereNullMod[Q, string]
|
|
Globalid psql.WhereNullMod[Q, uuid.UUID]
|
|
CreatedUser psql.WhereNullMod[Q, string]
|
|
CreatedDate psql.WhereNullMod[Q, time.Time]
|
|
LastEditedUser psql.WhereNullMod[Q, string]
|
|
LastEditedDate psql.WhereNullMod[Q, time.Time]
|
|
Srid psql.WhereNullMod[Q, uuid.UUID]
|
|
Fieldtech psql.WhereNullMod[Q, string]
|
|
Gatewaysync psql.WhereNullMod[Q, int16]
|
|
LocID psql.WhereNullMod[Q, uuid.UUID]
|
|
Voltage psql.WhereNullMod[Q, float64]
|
|
Winddir psql.WhereNullMod[Q, enums.FieldseekerTrapdataTrapdataWinddirC1a31e05D0B94B228800Be127bb3f166]
|
|
Windspeed psql.WhereNullMod[Q, float64]
|
|
Avetemp psql.WhereNullMod[Q, float64]
|
|
Raingauge psql.WhereNullMod[Q, float64]
|
|
LR psql.WhereNullMod[Q, int16]
|
|
Field psql.WhereNullMod[Q, int32]
|
|
Vectorsurvtrapdataid psql.WhereNullMod[Q, string]
|
|
Vectorsurvtraplocationid psql.WhereNullMod[Q, string]
|
|
Creationdate psql.WhereNullMod[Q, time.Time]
|
|
Creator psql.WhereNullMod[Q, string]
|
|
Editdate psql.WhereNullMod[Q, time.Time]
|
|
Editor psql.WhereNullMod[Q, string]
|
|
Lure psql.WhereNullMod[Q, enums.FieldseekerTrapdataTrapdataLure25fe542f077F4254868176e8f436354bEnu]
|
|
}
|
|
|
|
func (fieldseekerTrapdatumWhere[Q]) AliasedAs(alias string) fieldseekerTrapdatumWhere[Q] {
|
|
return buildFieldseekerTrapdatumWhere[Q](buildFieldseekerTrapdatumColumns(alias))
|
|
}
|
|
|
|
func buildFieldseekerTrapdatumWhere[Q psql.Filterable](cols fieldseekerTrapdatumColumns) fieldseekerTrapdatumWhere[Q] {
|
|
return fieldseekerTrapdatumWhere[Q]{
|
|
Objectid: psql.Where[Q, int64](cols.Objectid),
|
|
Traptype: psql.WhereNull[Q, enums.FieldseekerTrapdataMosquitotraptypeEnum](cols.Traptype),
|
|
Trapactivitytype: psql.WhereNull[Q, enums.FieldseekerTrapdataNotinuitrapactivitytypeEnum](cols.Trapactivitytype),
|
|
Startdatetime: psql.WhereNull[Q, time.Time](cols.Startdatetime),
|
|
Enddatetime: psql.WhereNull[Q, time.Time](cols.Enddatetime),
|
|
Comments: psql.WhereNull[Q, string](cols.Comments),
|
|
Idbytech: psql.WhereNull[Q, string](cols.Idbytech),
|
|
Sortbytech: psql.WhereNull[Q, string](cols.Sortbytech),
|
|
Processed: psql.WhereNull[Q, enums.FieldseekerTrapdataNotinuitFEnum](cols.Processed),
|
|
Sitecond: psql.WhereNull[Q, enums.FieldseekerTrapdataMosquitositeconditionEnum](cols.Sitecond),
|
|
Locationname: psql.WhereNull[Q, string](cols.Locationname),
|
|
Recordstatus: psql.WhereNull[Q, int16](cols.Recordstatus),
|
|
Reviewed: psql.WhereNull[Q, enums.FieldseekerTrapdataNotinuitFEnum](cols.Reviewed),
|
|
Reviewedby: psql.WhereNull[Q, string](cols.Reviewedby),
|
|
Revieweddate: psql.WhereNull[Q, time.Time](cols.Revieweddate),
|
|
Trapcondition: psql.WhereNull[Q, enums.FieldseekerTrapdataMosquitotrapconditionEnum](cols.Trapcondition),
|
|
Trapnights: psql.WhereNull[Q, int16](cols.Trapnights),
|
|
Zone: psql.WhereNull[Q, string](cols.Zone),
|
|
Zone2: psql.WhereNull[Q, string](cols.Zone2),
|
|
Globalid: psql.WhereNull[Q, uuid.UUID](cols.Globalid),
|
|
CreatedUser: psql.WhereNull[Q, string](cols.CreatedUser),
|
|
CreatedDate: psql.WhereNull[Q, time.Time](cols.CreatedDate),
|
|
LastEditedUser: psql.WhereNull[Q, string](cols.LastEditedUser),
|
|
LastEditedDate: psql.WhereNull[Q, time.Time](cols.LastEditedDate),
|
|
Srid: psql.WhereNull[Q, uuid.UUID](cols.Srid),
|
|
Fieldtech: psql.WhereNull[Q, string](cols.Fieldtech),
|
|
Gatewaysync: psql.WhereNull[Q, int16](cols.Gatewaysync),
|
|
LocID: psql.WhereNull[Q, uuid.UUID](cols.LocID),
|
|
Voltage: psql.WhereNull[Q, float64](cols.Voltage),
|
|
Winddir: psql.WhereNull[Q, enums.FieldseekerTrapdataTrapdataWinddirC1a31e05D0B94B228800Be127bb3f166](cols.Winddir),
|
|
Windspeed: psql.WhereNull[Q, float64](cols.Windspeed),
|
|
Avetemp: psql.WhereNull[Q, float64](cols.Avetemp),
|
|
Raingauge: psql.WhereNull[Q, float64](cols.Raingauge),
|
|
LR: psql.WhereNull[Q, int16](cols.LR),
|
|
Field: psql.WhereNull[Q, int32](cols.Field),
|
|
Vectorsurvtrapdataid: psql.WhereNull[Q, string](cols.Vectorsurvtrapdataid),
|
|
Vectorsurvtraplocationid: psql.WhereNull[Q, string](cols.Vectorsurvtraplocationid),
|
|
Creationdate: psql.WhereNull[Q, time.Time](cols.Creationdate),
|
|
Creator: psql.WhereNull[Q, string](cols.Creator),
|
|
Editdate: psql.WhereNull[Q, time.Time](cols.Editdate),
|
|
Editor: psql.WhereNull[Q, string](cols.Editor),
|
|
Lure: psql.WhereNull[Q, enums.FieldseekerTrapdataTrapdataLure25fe542f077F4254868176e8f436354bEnu](cols.Lure),
|
|
}
|
|
}
|