driver_location.go

// Code generated by SQLBoiler 4.11.0 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT.
// This file is meant to be re-generated in place and/or deleted at any time.

package models

import (
	"context"
	"database/sql"
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/friendsofgo/errors"
	"github.com/volatiletech/null/v8"
	"github.com/volatiletech/sqlboiler/v4/boil"
	"github.com/volatiletech/sqlboiler/v4/queries"
	"github.com/volatiletech/sqlboiler/v4/queries/qm"
	"github.com/volatiletech/sqlboiler/v4/queries/qmhelper"
	"github.com/volatiletech/sqlboiler/v4/types"
	"github.com/volatiletech/strmangle"
)

// DriverLocation is an object representing the database table.
type DriverLocation struct {
	ID             string            `boil:"id" json:"id" toml:"id" yaml:"id"`
	CreatedAt      time.Time         `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
	DriverID       string            `boil:"driver_id" json:"driver_id" toml:"driver_id" yaml:"driver_id"`
	Latitude       float64           `boil:"latitude" json:"latitude" toml:"latitude" yaml:"latitude"`
	Longitude      float64           `boil:"longitude" json:"longitude" toml:"longitude" yaml:"longitude"`
	R7Cell         null.String       `boil:"r7_cell" json:"r7_cell,omitempty" toml:"r7_cell" yaml:"r7_cell,omitempty"`
	R8Cell         null.String       `boil:"r8_cell" json:"r8_cell,omitempty" toml:"r8_cell" yaml:"r8_cell,omitempty"`
	R9Cell         null.String       `boil:"r9_cell" json:"r9_cell,omitempty" toml:"r9_cell" yaml:"r9_cell,omitempty"`
	R10Cell        null.String       `boil:"r10_cell" json:"r10_cell,omitempty" toml:"r10_cell" yaml:"r10_cell,omitempty"`
	R7K1Neighbors  types.StringArray `boil:"r7_k1_neighbors" json:"r7_k1_neighbors,omitempty" toml:"r7_k1_neighbors" yaml:"r7_k1_neighbors,omitempty"`
	R8K1Neighbors  types.StringArray `boil:"r8_k1_neighbors" json:"r8_k1_neighbors,omitempty" toml:"r8_k1_neighbors" yaml:"r8_k1_neighbors,omitempty"`
	R8K2Neighbors  types.StringArray `boil:"r8_k2_neighbors" json:"r8_k2_neighbors,omitempty" toml:"r8_k2_neighbors" yaml:"r8_k2_neighbors,omitempty"`
	R9K1Neighbors  types.StringArray `boil:"r9_k1_neighbors" json:"r9_k1_neighbors,omitempty" toml:"r9_k1_neighbors" yaml:"r9_k1_neighbors,omitempty"`
	R9K2Neighbors  types.StringArray `boil:"r9_k2_neighbors" json:"r9_k2_neighbors,omitempty" toml:"r9_k2_neighbors" yaml:"r9_k2_neighbors,omitempty"`
	R10K1Neighbors types.StringArray `boil:"r10_k1_neighbors" json:"r10_k1_neighbors,omitempty" toml:"r10_k1_neighbors" yaml:"r10_k1_neighbors,omitempty"`
	R10K2Neighbors types.StringArray `boil:"r10_k2_neighbors" json:"r10_k2_neighbors,omitempty" toml:"r10_k2_neighbors" yaml:"r10_k2_neighbors,omitempty"`

	R *driverLocationR `boil:"-" json:"-" toml:"-" yaml:"-"`
	L driverLocationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

var DriverLocationColumns = struct {
	ID             string
	CreatedAt      string
	DriverID       string
	Latitude       string
	Longitude      string
	R7Cell         string
	R8Cell         string
	R9Cell         string
	R10Cell        string
	R7K1Neighbors  string
	R8K1Neighbors  string
	R8K2Neighbors  string
	R9K1Neighbors  string
	R9K2Neighbors  string
	R10K1Neighbors string
	R10K2Neighbors string
}{
	ID:             "id",
	CreatedAt:      "created_at",
	DriverID:       "driver_id",
	Latitude:       "latitude",
	Longitude:      "longitude",
	R7Cell:         "r7_cell",
	R8Cell:         "r8_cell",
	R9Cell:         "r9_cell",
	R10Cell:        "r10_cell",
	R7K1Neighbors:  "r7_k1_neighbors",
	R8K1Neighbors:  "r8_k1_neighbors",
	R8K2Neighbors:  "r8_k2_neighbors",
	R9K1Neighbors:  "r9_k1_neighbors",
	R9K2Neighbors:  "r9_k2_neighbors",
	R10K1Neighbors: "r10_k1_neighbors",
	R10K2Neighbors: "r10_k2_neighbors",
}

var DriverLocationTableColumns = struct {
	ID             string
	CreatedAt      string
	DriverID       string
	Latitude       string
	Longitude      string
	R7Cell         string
	R8Cell         string
	R9Cell         string
	R10Cell        string
	R7K1Neighbors  string
	R8K1Neighbors  string
	R8K2Neighbors  string
	R9K1Neighbors  string
	R9K2Neighbors  string
	R10K1Neighbors string
	R10K2Neighbors string
}{
	ID:             "driver_location.id",
	CreatedAt:      "driver_location.created_at",
	DriverID:       "driver_location.driver_id",
	Latitude:       "driver_location.latitude",
	Longitude:      "driver_location.longitude",
	R7Cell:         "driver_location.r7_cell",
	R8Cell:         "driver_location.r8_cell",
	R9Cell:         "driver_location.r9_cell",
	R10Cell:        "driver_location.r10_cell",
	R7K1Neighbors:  "driver_location.r7_k1_neighbors",
	R8K1Neighbors:  "driver_location.r8_k1_neighbors",
	R8K2Neighbors:  "driver_location.r8_k2_neighbors",
	R9K1Neighbors:  "driver_location.r9_k1_neighbors",
	R9K2Neighbors:  "driver_location.r9_k2_neighbors",
	R10K1Neighbors: "driver_location.r10_k1_neighbors",
	R10K2Neighbors: "driver_location.r10_k2_neighbors",
}

// Generated where

type whereHelperstring struct{ field string }

func (w whereHelperstring) EQ(x string) qm.QueryMod  { return qmhelper.Where(w.field, qmhelper.EQ, x) }
func (w whereHelperstring) NEQ(x string) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.NEQ, x) }
func (w whereHelperstring) LT(x string) qm.QueryMod  { return qmhelper.Where(w.field, qmhelper.LT, x) }
func (w whereHelperstring) LTE(x string) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LTE, x) }
func (w whereHelperstring) GT(x string) qm.QueryMod  { return qmhelper.Where(w.field, qmhelper.GT, x) }
func (w whereHelperstring) GTE(x string) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GTE, x) }
func (w whereHelperstring) IN(slice []string) qm.QueryMod {
	values := make([]interface{}, 0, len(slice))
	for _, value := range slice {
		values = append(values, value)
	}
	return qm.WhereIn(fmt.Sprintf("%s IN ?", w.field), values...)
}
func (w whereHelperstring) NIN(slice []string) qm.QueryMod {
	values := make([]interface{}, 0, len(slice))
	for _, value := range slice {
		values = append(values, value)
	}
	return qm.WhereNotIn(fmt.Sprintf("%s NOT IN ?", w.field), values...)
}

type whereHelpertime_Time struct{ field string }

func (w whereHelpertime_Time) EQ(x time.Time) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.EQ, x)
}
func (w whereHelpertime_Time) NEQ(x time.Time) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.NEQ, x)
}
func (w whereHelpertime_Time) LT(x time.Time) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.LT, x)
}
func (w whereHelpertime_Time) LTE(x time.Time) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.LTE, x)
}
func (w whereHelpertime_Time) GT(x time.Time) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.GT, x)
}
func (w whereHelpertime_Time) GTE(x time.Time) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.GTE, x)
}

type whereHelperfloat64 struct{ field string }

func (w whereHelperfloat64) EQ(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.EQ, x) }
func (w whereHelperfloat64) NEQ(x float64) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.NEQ, x)
}
func (w whereHelperfloat64) LT(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LT, x) }
func (w whereHelperfloat64) LTE(x float64) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.LTE, x)
}
func (w whereHelperfloat64) GT(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GT, x) }
func (w whereHelperfloat64) GTE(x float64) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.GTE, x)
}
func (w whereHelperfloat64) IN(slice []float64) qm.QueryMod {
	values := make([]interface{}, 0, len(slice))
	for _, value := range slice {
		values = append(values, value)
	}
	return qm.WhereIn(fmt.Sprintf("%s IN ?", w.field), values...)
}
func (w whereHelperfloat64) NIN(slice []float64) qm.QueryMod {
	values := make([]interface{}, 0, len(slice))
	for _, value := range slice {
		values = append(values, value)
	}
	return qm.WhereNotIn(fmt.Sprintf("%s NOT IN ?", w.field), values...)
}

type whereHelpernull_String struct{ field string }

func (w whereHelpernull_String) EQ(x null.String) qm.QueryMod {
	return qmhelper.WhereNullEQ(w.field, false, x)
}
func (w whereHelpernull_String) NEQ(x null.String) qm.QueryMod {
	return qmhelper.WhereNullEQ(w.field, true, x)
}
func (w whereHelpernull_String) LT(x null.String) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.LT, x)
}
func (w whereHelpernull_String) LTE(x null.String) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.LTE, x)
}
func (w whereHelpernull_String) GT(x null.String) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.GT, x)
}
func (w whereHelpernull_String) GTE(x null.String) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.GTE, x)
}

func (w whereHelpernull_String) IsNull() qm.QueryMod    { return qmhelper.WhereIsNull(w.field) }
func (w whereHelpernull_String) IsNotNull() qm.QueryMod { return qmhelper.WhereIsNotNull(w.field) }

type whereHelpertypes_StringArray struct{ field string }

func (w whereHelpertypes_StringArray) EQ(x types.StringArray) qm.QueryMod {
	return qmhelper.WhereNullEQ(w.field, false, x)
}
func (w whereHelpertypes_StringArray) NEQ(x types.StringArray) qm.QueryMod {
	return qmhelper.WhereNullEQ(w.field, true, x)
}
func (w whereHelpertypes_StringArray) LT(x types.StringArray) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.LT, x)
}
func (w whereHelpertypes_StringArray) LTE(x types.StringArray) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.LTE, x)
}
func (w whereHelpertypes_StringArray) GT(x types.StringArray) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.GT, x)
}
func (w whereHelpertypes_StringArray) GTE(x types.StringArray) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.GTE, x)
}

func (w whereHelpertypes_StringArray) IsNull() qm.QueryMod { return qmhelper.WhereIsNull(w.field) }
func (w whereHelpertypes_StringArray) IsNotNull() qm.QueryMod {
	return qmhelper.WhereIsNotNull(w.field)
}

var DriverLocationWhere = struct {
	ID             whereHelperstring
	CreatedAt      whereHelpertime_Time
	DriverID       whereHelperstring
	Latitude       whereHelperfloat64
	Longitude      whereHelperfloat64
	R7Cell         whereHelpernull_String
	R8Cell         whereHelpernull_String
	R9Cell         whereHelpernull_String
	R10Cell        whereHelpernull_String
	R7K1Neighbors  whereHelpertypes_StringArray
	R8K1Neighbors  whereHelpertypes_StringArray
	R8K2Neighbors  whereHelpertypes_StringArray
	R9K1Neighbors  whereHelpertypes_StringArray
	R9K2Neighbors  whereHelpertypes_StringArray
	R10K1Neighbors whereHelpertypes_StringArray
	R10K2Neighbors whereHelpertypes_StringArray
}{
	ID:             whereHelperstring{field: "\"driver_location\".\"id\""},
	CreatedAt:      whereHelpertime_Time{field: "\"driver_location\".\"created_at\""},
	DriverID:       whereHelperstring{field: "\"driver_location\".\"driver_id\""},
	Latitude:       whereHelperfloat64{field: "\"driver_location\".\"latitude\""},
	Longitude:      whereHelperfloat64{field: "\"driver_location\".\"longitude\""},
	R7Cell:         whereHelpernull_String{field: "\"driver_location\".\"r7_cell\""},
	R8Cell:         whereHelpernull_String{field: "\"driver_location\".\"r8_cell\""},
	R9Cell:         whereHelpernull_String{field: "\"driver_location\".\"r9_cell\""},
	R10Cell:        whereHelpernull_String{field: "\"driver_location\".\"r10_cell\""},
	R7K1Neighbors:  whereHelpertypes_StringArray{field: "\"driver_location\".\"r7_k1_neighbors\""},
	R8K1Neighbors:  whereHelpertypes_StringArray{field: "\"driver_location\".\"r8_k1_neighbors\""},
	R8K2Neighbors:  whereHelpertypes_StringArray{field: "\"driver_location\".\"r8_k2_neighbors\""},
	R9K1Neighbors:  whereHelpertypes_StringArray{field: "\"driver_location\".\"r9_k1_neighbors\""},
	R9K2Neighbors:  whereHelpertypes_StringArray{field: "\"driver_location\".\"r9_k2_neighbors\""},
	R10K1Neighbors: whereHelpertypes_StringArray{field: "\"driver_location\".\"r10_k1_neighbors\""},
	R10K2Neighbors: whereHelpertypes_StringArray{field: "\"driver_location\".\"r10_k2_neighbors\""},
}

// DriverLocationRels is where relationship names are stored.
var DriverLocationRels = struct {
}{}

// driverLocationR is where relationships are stored.
type driverLocationR struct {
}

// NewStruct creates a new relationship struct
func (*driverLocationR) NewStruct() *driverLocationR {
	return &driverLocationR{}
}

// driverLocationL is where Load methods for each relationship are stored.
type driverLocationL struct{}

var (
	driverLocationAllColumns            = []string{"id", "created_at", "driver_id", "latitude", "longitude", "r7_cell", "r8_cell", "r9_cell", "r10_cell", "r7_k1_neighbors", "r8_k1_neighbors", "r8_k2_neighbors", "r9_k1_neighbors", "r9_k2_neighbors", "r10_k1_neighbors", "r10_k2_neighbors"}
	driverLocationColumnsWithoutDefault = []string{"id", "driver_id", "latitude", "longitude"}
	driverLocationColumnsWithDefault    = []string{"created_at", "r7_cell", "r8_cell", "r9_cell", "r10_cell", "r7_k1_neighbors", "r8_k1_neighbors", "r8_k2_neighbors", "r9_k1_neighbors", "r9_k2_neighbors", "r10_k1_neighbors", "r10_k2_neighbors"}
	driverLocationPrimaryKeyColumns     = []string{"id"}
	driverLocationGeneratedColumns      = []string{}
)

type (
	// DriverLocationSlice is an alias for a slice of pointers to DriverLocation.
	// This should almost always be used instead of []DriverLocation.
	DriverLocationSlice []*DriverLocation
	// DriverLocationHook is the signature for custom DriverLocation hook methods
	DriverLocationHook func(context.Context, boil.ContextExecutor, *DriverLocation) error

	driverLocationQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	driverLocationType                 = reflect.TypeOf(&DriverLocation{})
	driverLocationMapping              = queries.MakeStructMapping(driverLocationType)
	driverLocationPrimaryKeyMapping, _ = queries.BindMapping(driverLocationType, driverLocationMapping, driverLocationPrimaryKeyColumns)
	driverLocationInsertCacheMut       sync.RWMutex
	driverLocationInsertCache          = make(map[string]insertCache)
	driverLocationUpdateCacheMut       sync.RWMutex
	driverLocationUpdateCache          = make(map[string]updateCache)
	driverLocationUpsertCacheMut       sync.RWMutex
	driverLocationUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force qmhelper dependency for where clause generation (which doesn't
	// always happen)
	_ = qmhelper.Where
)

var driverLocationAfterSelectHooks []DriverLocationHook

var driverLocationBeforeInsertHooks []DriverLocationHook
var driverLocationAfterInsertHooks []DriverLocationHook

var driverLocationBeforeUpdateHooks []DriverLocationHook
var driverLocationAfterUpdateHooks []DriverLocationHook

var driverLocationBeforeDeleteHooks []DriverLocationHook
var driverLocationAfterDeleteHooks []DriverLocationHook

var driverLocationBeforeUpsertHooks []DriverLocationHook
var driverLocationAfterUpsertHooks []DriverLocationHook

// doAfterSelectHooks executes all "after Select" hooks.
func (o *DriverLocation) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range driverLocationAfterSelectHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doBeforeInsertHooks executes all "before insert" hooks.
func (o *DriverLocation) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range driverLocationBeforeInsertHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doAfterInsertHooks executes all "after Insert" hooks.
func (o *DriverLocation) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range driverLocationAfterInsertHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doBeforeUpdateHooks executes all "before Update" hooks.
func (o *DriverLocation) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range driverLocationBeforeUpdateHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doAfterUpdateHooks executes all "after Update" hooks.
func (o *DriverLocation) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range driverLocationAfterUpdateHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doBeforeDeleteHooks executes all "before Delete" hooks.
func (o *DriverLocation) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range driverLocationBeforeDeleteHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doAfterDeleteHooks executes all "after Delete" hooks.
func (o *DriverLocation) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range driverLocationAfterDeleteHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doBeforeUpsertHooks executes all "before Upsert" hooks.
func (o *DriverLocation) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range driverLocationBeforeUpsertHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// doAfterUpsertHooks executes all "after Upsert" hooks.
func (o *DriverLocation) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
	if boil.HooksAreSkipped(ctx) {
		return nil
	}

	for _, hook := range driverLocationAfterUpsertHooks {
		if err := hook(ctx, exec, o); err != nil {
			return err
		}
	}

	return nil
}

// AddDriverLocationHook registers your hook function for all future operations.
func AddDriverLocationHook(hookPoint boil.HookPoint, driverLocationHook DriverLocationHook) {
	switch hookPoint {
	case boil.AfterSelectHook:
		driverLocationAfterSelectHooks = append(driverLocationAfterSelectHooks, driverLocationHook)
	case boil.BeforeInsertHook:
		driverLocationBeforeInsertHooks = append(driverLocationBeforeInsertHooks, driverLocationHook)
	case boil.AfterInsertHook:
		driverLocationAfterInsertHooks = append(driverLocationAfterInsertHooks, driverLocationHook)
	case boil.BeforeUpdateHook:
		driverLocationBeforeUpdateHooks = append(driverLocationBeforeUpdateHooks, driverLocationHook)
	case boil.AfterUpdateHook:
		driverLocationAfterUpdateHooks = append(driverLocationAfterUpdateHooks, driverLocationHook)
	case boil.BeforeDeleteHook:
		driverLocationBeforeDeleteHooks = append(driverLocationBeforeDeleteHooks, driverLocationHook)
	case boil.AfterDeleteHook:
		driverLocationAfterDeleteHooks = append(driverLocationAfterDeleteHooks, driverLocationHook)
	case boil.BeforeUpsertHook:
		driverLocationBeforeUpsertHooks = append(driverLocationBeforeUpsertHooks, driverLocationHook)
	case boil.AfterUpsertHook:
		driverLocationAfterUpsertHooks = append(driverLocationAfterUpsertHooks, driverLocationHook)
	}
}

// One returns a single driverLocation record from the query.
func (q driverLocationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*DriverLocation, error) {
	o := &DriverLocation{}

	queries.SetLimit(q.Query, 1)

	err := q.Bind(ctx, exec, o)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, sql.ErrNoRows
		}
		return nil, errors.Wrap(err, "models: failed to execute a one query for driver_location")
	}

	if err := o.doAfterSelectHooks(ctx, exec); err != nil {
		return o, err
	}

	return o, nil
}

// All returns all DriverLocation records from the query.
func (q driverLocationQuery) All(ctx context.Context, exec boil.ContextExecutor) (DriverLocationSlice, error) {
	var o []*DriverLocation

	err := q.Bind(ctx, exec, &o)
	if err != nil {
		return nil, errors.Wrap(err, "models: failed to assign all query results to DriverLocation slice")
	}

	if len(driverLocationAfterSelectHooks) != 0 {
		for _, obj := range o {
			if err := obj.doAfterSelectHooks(ctx, exec); err != nil {
				return o, err
			}
		}
	}

	return o, nil
}

// Count returns the count of all DriverLocation records in the query.
func (q driverLocationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	var count int64

	queries.SetSelect(q.Query, nil)
	queries.SetCount(q.Query)

	err := q.Query.QueryRowContext(ctx, exec).Scan(&count)
	if err != nil {
		return 0, errors.Wrap(err, "models: failed to count driver_location rows")
	}

	return count, nil
}

// Exists checks if the row exists in the table.
func (q driverLocationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) {
	var count int64

	queries.SetSelect(q.Query, nil)
	queries.SetCount(q.Query)
	queries.SetLimit(q.Query, 1)

	err := q.Query.QueryRowContext(ctx, exec).Scan(&count)
	if err != nil {
		return false, errors.Wrap(err, "models: failed to check if driver_location exists")
	}

	return count > 0, nil
}

// DriverLocations retrieves all the records using an executor.
func DriverLocations(mods ...qm.QueryMod) driverLocationQuery {
	mods = append(mods, qm.From("\"driver_location\""))
	q := NewQuery(mods...)
	if len(queries.GetSelect(q)) == 0 {
		queries.SetSelect(q, []string{"\"driver_location\".*"})
	}

	return driverLocationQuery{q}
}

// FindDriverLocation retrieves a single record by ID with an executor.
// If selectCols is empty Find will return all columns.
func FindDriverLocation(ctx context.Context, exec boil.ContextExecutor, iD string, selectCols ...string) (*DriverLocation, error) {
	driverLocationObj := &DriverLocation{}

	sel := "*"
	if len(selectCols) > 0 {
		sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",")
	}
	query := fmt.Sprintf(
		"select %s from \"driver_location\" where \"id\"=$1", sel,
	)

	q := queries.Raw(query, iD)

	err := q.Bind(ctx, exec, driverLocationObj)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, sql.ErrNoRows
		}
		return nil, errors.Wrap(err, "models: unable to select from driver_location")
	}

	if err = driverLocationObj.doAfterSelectHooks(ctx, exec); err != nil {
		return driverLocationObj, err
	}

	return driverLocationObj, nil
}

// Insert a single record using an executor.
// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.
func (o *DriverLocation) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error {
	if o == nil {
		return errors.New("models: no driver_location provided for insertion")
	}

	var err error
	if !boil.TimestampsAreSkipped(ctx) {
		currTime := time.Now().In(boil.GetLocation())

		if o.CreatedAt.IsZero() {
			o.CreatedAt = currTime
		}
	}

	if err := o.doBeforeInsertHooks(ctx, exec); err != nil {
		return err
	}

	nzDefaults := queries.NonZeroDefaultSet(driverLocationColumnsWithDefault, o)

	key := makeCacheKey(columns, nzDefaults)
	driverLocationInsertCacheMut.RLock()
	cache, cached := driverLocationInsertCache[key]
	driverLocationInsertCacheMut.RUnlock()

	if !cached {
		wl, returnColumns := columns.InsertColumnSet(
			driverLocationAllColumns,
			driverLocationColumnsWithDefault,
			driverLocationColumnsWithoutDefault,
			nzDefaults,
		)

		cache.valueMapping, err = queries.BindMapping(driverLocationType, driverLocationMapping, wl)
		if err != nil {
			return err
		}
		cache.retMapping, err = queries.BindMapping(driverLocationType, driverLocationMapping, returnColumns)
		if err != nil {
			return err
		}
		if len(wl) != 0 {
			cache.query = fmt.Sprintf("INSERT INTO \"driver_location\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1))
		} else {
			cache.query = "INSERT INTO \"driver_location\" %sDEFAULT VALUES%s"
		}

		var queryOutput, queryReturning string

		if len(cache.retMapping) != 0 {
			queryReturning = fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\""))
		}

		cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning)
	}

	value := reflect.Indirect(reflect.ValueOf(o))
	vals := queries.ValuesFromMapping(value, cache.valueMapping)

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, cache.query)
		fmt.Fprintln(writer, vals)
	}

	if len(cache.retMapping) != 0 {
		err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...)
	} else {
		_, err = exec.ExecContext(ctx, cache.query, vals...)
	}

	if err != nil {
		return errors.Wrap(err, "models: unable to insert into driver_location")
	}

	if !cached {
		driverLocationInsertCacheMut.Lock()
		driverLocationInsertCache[key] = cache
		driverLocationInsertCacheMut.Unlock()
	}

	return o.doAfterInsertHooks(ctx, exec)
}

// Update uses an executor to update the DriverLocation.
// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates.
// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.
func (o *DriverLocation) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) {
	var err error
	if err = o.doBeforeUpdateHooks(ctx, exec); err != nil {
		return 0, err
	}
	key := makeCacheKey(columns, nil)
	driverLocationUpdateCacheMut.RLock()
	cache, cached := driverLocationUpdateCache[key]
	driverLocationUpdateCacheMut.RUnlock()

	if !cached {
		wl := columns.UpdateColumnSet(
			driverLocationAllColumns,
			driverLocationPrimaryKeyColumns,
		)

		if !columns.IsWhitelist() {
			wl = strmangle.SetComplement(wl, []string{"created_at"})
		}
		if len(wl) == 0 {
			return 0, errors.New("models: unable to update driver_location, could not build whitelist")
		}

		cache.query = fmt.Sprintf("UPDATE \"driver_location\" SET %s WHERE %s",
			strmangle.SetParamNames("\"", "\"", 1, wl),
			strmangle.WhereClause("\"", "\"", len(wl)+1, driverLocationPrimaryKeyColumns),
		)
		cache.valueMapping, err = queries.BindMapping(driverLocationType, driverLocationMapping, append(wl, driverLocationPrimaryKeyColumns...))
		if err != nil {
			return 0, err
		}
	}

	values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping)

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, cache.query)
		fmt.Fprintln(writer, values)
	}
	var result sql.Result
	result, err = exec.ExecContext(ctx, cache.query, values...)
	if err != nil {
		return 0, errors.Wrap(err, "models: unable to update driver_location row")
	}

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "models: failed to get rows affected by update for driver_location")
	}

	if !cached {
		driverLocationUpdateCacheMut.Lock()
		driverLocationUpdateCache[key] = cache
		driverLocationUpdateCacheMut.Unlock()
	}

	return rowsAff, o.doAfterUpdateHooks(ctx, exec)
}

// UpdateAll updates all rows with the specified column values.
func (q driverLocationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) {
	queries.SetUpdate(q.Query, cols)

	result, err := q.Query.ExecContext(ctx, exec)
	if err != nil {
		return 0, errors.Wrap(err, "models: unable to update all for driver_location")
	}

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "models: unable to retrieve rows affected for driver_location")
	}

	return rowsAff, nil
}

// UpdateAll updates all rows with the specified column values, using an executor.
func (o DriverLocationSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) {
	ln := int64(len(o))
	if ln == 0 {
		return 0, nil
	}

	if len(cols) == 0 {
		return 0, errors.New("models: update all requires at least one column argument")
	}

	colNames := make([]string, len(cols))
	args := make([]interface{}, len(cols))

	i := 0
	for name, value := range cols {
		colNames[i] = name
		args[i] = value
		i++
	}

	// Append all of the primary key values for each column
	for _, obj := range o {
		pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), driverLocationPrimaryKeyMapping)
		args = append(args, pkeyArgs...)
	}

	sql := fmt.Sprintf("UPDATE \"driver_location\" SET %s WHERE %s",
		strmangle.SetParamNames("\"", "\"", 1, colNames),
		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, driverLocationPrimaryKeyColumns, len(o)))

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, sql)
		fmt.Fprintln(writer, args...)
	}
	result, err := exec.ExecContext(ctx, sql, args...)
	if err != nil {
		return 0, errors.Wrap(err, "models: unable to update all in driverLocation slice")
	}

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "models: unable to retrieve rows affected all in update all driverLocation")
	}
	return rowsAff, nil
}

// Upsert attempts an insert using an executor, and does an update or ignore on conflict.
// See boil.Columns documentation for how to properly use updateColumns and insertColumns.
func (o *DriverLocation) Upsert(ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error {
	if o == nil {
		return errors.New("models: no driver_location provided for upsert")
	}
	if !boil.TimestampsAreSkipped(ctx) {
		currTime := time.Now().In(boil.GetLocation())

		if o.CreatedAt.IsZero() {
			o.CreatedAt = currTime
		}
	}

	if err := o.doBeforeUpsertHooks(ctx, exec); err != nil {
		return err
	}

	nzDefaults := queries.NonZeroDefaultSet(driverLocationColumnsWithDefault, o)

	// Build cache key in-line uglily - mysql vs psql problems
	buf := strmangle.GetBuffer()
	if updateOnConflict {
		buf.WriteByte('t')
	} else {
		buf.WriteByte('f')
	}
	buf.WriteByte('.')
	for _, c := range conflictColumns {
		buf.WriteString(c)
	}
	buf.WriteByte('.')
	buf.WriteString(strconv.Itoa(updateColumns.Kind))
	for _, c := range updateColumns.Cols {
		buf.WriteString(c)
	}
	buf.WriteByte('.')
	buf.WriteString(strconv.Itoa(insertColumns.Kind))
	for _, c := range insertColumns.Cols {
		buf.WriteString(c)
	}
	buf.WriteByte('.')
	for _, c := range nzDefaults {
		buf.WriteString(c)
	}
	key := buf.String()
	strmangle.PutBuffer(buf)

	driverLocationUpsertCacheMut.RLock()
	cache, cached := driverLocationUpsertCache[key]
	driverLocationUpsertCacheMut.RUnlock()

	var err error

	if !cached {
		insert, ret := insertColumns.InsertColumnSet(
			driverLocationAllColumns,
			driverLocationColumnsWithDefault,
			driverLocationColumnsWithoutDefault,
			nzDefaults,
		)

		update := updateColumns.UpdateColumnSet(
			driverLocationAllColumns,
			driverLocationPrimaryKeyColumns,
		)

		if updateOnConflict && len(update) == 0 {
			return errors.New("models: unable to upsert driver_location, could not build update column list")
		}

		conflict := conflictColumns
		if len(conflict) == 0 {
			conflict = make([]string, len(driverLocationPrimaryKeyColumns))
			copy(conflict, driverLocationPrimaryKeyColumns)
		}
		cache.query = buildUpsertQueryPostgres(dialect, "\"driver_location\"", updateOnConflict, ret, update, conflict, insert)

		cache.valueMapping, err = queries.BindMapping(driverLocationType, driverLocationMapping, insert)
		if err != nil {
			return err
		}
		if len(ret) != 0 {
			cache.retMapping, err = queries.BindMapping(driverLocationType, driverLocationMapping, ret)
			if err != nil {
				return err
			}
		}
	}

	value := reflect.Indirect(reflect.ValueOf(o))
	vals := queries.ValuesFromMapping(value, cache.valueMapping)
	var returns []interface{}
	if len(cache.retMapping) != 0 {
		returns = queries.PtrsFromMapping(value, cache.retMapping)
	}

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, cache.query)
		fmt.Fprintln(writer, vals)
	}
	if len(cache.retMapping) != 0 {
		err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(returns...)
		if errors.Is(err, sql.ErrNoRows) {
			err = nil // Postgres doesn't return anything when there's no update
		}
	} else {
		_, err = exec.ExecContext(ctx, cache.query, vals...)
	}
	if err != nil {
		return errors.Wrap(err, "models: unable to upsert driver_location")
	}

	if !cached {
		driverLocationUpsertCacheMut.Lock()
		driverLocationUpsertCache[key] = cache
		driverLocationUpsertCacheMut.Unlock()
	}

	return o.doAfterUpsertHooks(ctx, exec)
}

// Delete deletes a single DriverLocation record with an executor.
// Delete will match against the primary key column to find the record to delete.
func (o *DriverLocation) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	if o == nil {
		return 0, errors.New("models: no DriverLocation provided for delete")
	}

	if err := o.doBeforeDeleteHooks(ctx, exec); err != nil {
		return 0, err
	}

	args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), driverLocationPrimaryKeyMapping)
	sql := "DELETE FROM \"driver_location\" WHERE \"id\"=$1"

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, sql)
		fmt.Fprintln(writer, args...)
	}
	result, err := exec.ExecContext(ctx, sql, args...)
	if err != nil {
		return 0, errors.Wrap(err, "models: unable to delete from driver_location")
	}

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "models: failed to get rows affected by delete for driver_location")
	}

	if err := o.doAfterDeleteHooks(ctx, exec); err != nil {
		return 0, err
	}

	return rowsAff, nil
}

// DeleteAll deletes all matching rows.
func (q driverLocationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	if q.Query == nil {
		return 0, errors.New("models: no driverLocationQuery provided for delete all")
	}

	queries.SetDelete(q.Query)

	result, err := q.Query.ExecContext(ctx, exec)
	if err != nil {
		return 0, errors.Wrap(err, "models: unable to delete all from driver_location")
	}

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for driver_location")
	}

	return rowsAff, nil
}

// DeleteAll deletes all rows in the slice, using an executor.
func (o DriverLocationSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	if len(o) == 0 {
		return 0, nil
	}

	if len(driverLocationBeforeDeleteHooks) != 0 {
		for _, obj := range o {
			if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil {
				return 0, err
			}
		}
	}

	var args []interface{}
	for _, obj := range o {
		pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), driverLocationPrimaryKeyMapping)
		args = append(args, pkeyArgs...)
	}

	sql := "DELETE FROM \"driver_location\" WHERE " +
		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, driverLocationPrimaryKeyColumns, len(o))

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, sql)
		fmt.Fprintln(writer, args)
	}
	result, err := exec.ExecContext(ctx, sql, args...)
	if err != nil {
		return 0, errors.Wrap(err, "models: unable to delete all from driverLocation slice")
	}

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for driver_location")
	}

	if len(driverLocationAfterDeleteHooks) != 0 {
		for _, obj := range o {
			if err := obj.doAfterDeleteHooks(ctx, exec); err != nil {
				return 0, err
			}
		}
	}

	return rowsAff, nil
}

// Reload refetches the object from the database
// using the primary keys with an executor.
func (o *DriverLocation) Reload(ctx context.Context, exec boil.ContextExecutor) error {
	ret, err := FindDriverLocation(ctx, exec, o.ID)
	if err != nil {
		return err
	}

	*o = *ret
	return nil
}

// ReloadAll refetches every row with matching primary key column values
// and overwrites the original object slice with the newly updated slice.
func (o *DriverLocationSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error {
	if o == nil || len(*o) == 0 {
		return nil
	}

	slice := DriverLocationSlice{}
	var args []interface{}
	for _, obj := range *o {
		pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), driverLocationPrimaryKeyMapping)
		args = append(args, pkeyArgs...)
	}

	sql := "SELECT \"driver_location\".* FROM \"driver_location\" WHERE " +
		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, driverLocationPrimaryKeyColumns, len(*o))

	q := queries.Raw(sql, args...)

	err := q.Bind(ctx, exec, &slice)
	if err != nil {
		return errors.Wrap(err, "models: unable to reload all in DriverLocationSlice")
	}

	*o = slice

	return nil
}

// DriverLocationExists checks if the DriverLocation row exists.
func DriverLocationExists(ctx context.Context, exec boil.ContextExecutor, iD string) (bool, error) {
	var exists bool
	sql := "select exists(select 1 from \"driver_location\" where \"id\"=$1 limit 1)"

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, sql)
		fmt.Fprintln(writer, iD)
	}
	row := exec.QueryRowContext(ctx, sql, iD)

	err := row.Scan(&exists)
	if err != nil {
		return false, errors.Wrap(err, "models: unable to check if driver_location exists")
	}

	return exists, nil
}