sessions_open.go

// Code generated by SQLBoiler 4.14.1 (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/strmangle"
)

// SessionsOpen is an object representing the database table.
type SessionsOpen struct {
	ID                    int         `boil:"id" json:"id" toml:"id" yaml:"id"`
	PeerID                int         `boil:"peer_id" json:"peer_id" toml:"peer_id" yaml:"peer_id"`
	FirstSuccessfulVisit  time.Time   `boil:"first_successful_visit" json:"first_successful_visit" toml:"first_successful_visit" yaml:"first_successful_visit"`
	LastSuccessfulVisit   time.Time   `boil:"last_successful_visit" json:"last_successful_visit" toml:"last_successful_visit" yaml:"last_successful_visit"`
	NextVisitDueAt        time.Time   `boil:"next_visit_due_at" json:"next_visit_due_at" toml:"next_visit_due_at" yaml:"next_visit_due_at"`
	FirstFailedVisit      null.Time   `boil:"first_failed_visit" json:"first_failed_visit,omitempty" toml:"first_failed_visit" yaml:"first_failed_visit,omitempty"`
	LastFailedVisit       null.Time   `boil:"last_failed_visit" json:"last_failed_visit,omitempty" toml:"last_failed_visit" yaml:"last_failed_visit,omitempty"`
	LastVisitedAt         time.Time   `boil:"last_visited_at" json:"last_visited_at" toml:"last_visited_at" yaml:"last_visited_at"`
	UpdatedAt             time.Time   `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"`
	CreatedAt             time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
	SuccessfulVisitsCount int         `boil:"successful_visits_count" json:"successful_visits_count" toml:"successful_visits_count" yaml:"successful_visits_count"`
	RecoveredCount        int         `boil:"recovered_count" json:"recovered_count" toml:"recovered_count" yaml:"recovered_count"`
	State                 string      `boil:"state" json:"state" toml:"state" yaml:"state"`
	FailedVisitsCount     int16       `boil:"failed_visits_count" json:"failed_visits_count" toml:"failed_visits_count" yaml:"failed_visits_count"`
	FinishReason          null.String `boil:"finish_reason" json:"finish_reason,omitempty" toml:"finish_reason" yaml:"finish_reason,omitempty"`
	Uptime                string      `boil:"uptime" json:"uptime" toml:"uptime" yaml:"uptime"`

	R *sessionsOpenR `boil:"-" json:"-" toml:"-" yaml:"-"`
	L sessionsOpenL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

var SessionsOpenColumns = struct {
	ID                    string
	PeerID                string
	FirstSuccessfulVisit  string
	LastSuccessfulVisit   string
	NextVisitDueAt        string
	FirstFailedVisit      string
	LastFailedVisit       string
	LastVisitedAt         string
	UpdatedAt             string
	CreatedAt             string
	SuccessfulVisitsCount string
	RecoveredCount        string
	State                 string
	FailedVisitsCount     string
	FinishReason          string
	Uptime                string
}{
	ID:                    "id",
	PeerID:                "peer_id",
	FirstSuccessfulVisit:  "first_successful_visit",
	LastSuccessfulVisit:   "last_successful_visit",
	NextVisitDueAt:        "next_visit_due_at",
	FirstFailedVisit:      "first_failed_visit",
	LastFailedVisit:       "last_failed_visit",
	LastVisitedAt:         "last_visited_at",
	UpdatedAt:             "updated_at",
	CreatedAt:             "created_at",
	SuccessfulVisitsCount: "successful_visits_count",
	RecoveredCount:        "recovered_count",
	State:                 "state",
	FailedVisitsCount:     "failed_visits_count",
	FinishReason:          "finish_reason",
	Uptime:                "uptime",
}

var SessionsOpenTableColumns = struct {
	ID                    string
	PeerID                string
	FirstSuccessfulVisit  string
	LastSuccessfulVisit   string
	NextVisitDueAt        string
	FirstFailedVisit      string
	LastFailedVisit       string
	LastVisitedAt         string
	UpdatedAt             string
	CreatedAt             string
	SuccessfulVisitsCount string
	RecoveredCount        string
	State                 string
	FailedVisitsCount     string
	FinishReason          string
	Uptime                string
}{
	ID:                    "sessions_open.id",
	PeerID:                "sessions_open.peer_id",
	FirstSuccessfulVisit:  "sessions_open.first_successful_visit",
	LastSuccessfulVisit:   "sessions_open.last_successful_visit",
	NextVisitDueAt:        "sessions_open.next_visit_due_at",
	FirstFailedVisit:      "sessions_open.first_failed_visit",
	LastFailedVisit:       "sessions_open.last_failed_visit",
	LastVisitedAt:         "sessions_open.last_visited_at",
	UpdatedAt:             "sessions_open.updated_at",
	CreatedAt:             "sessions_open.created_at",
	SuccessfulVisitsCount: "sessions_open.successful_visits_count",
	RecoveredCount:        "sessions_open.recovered_count",
	State:                 "sessions_open.state",
	FailedVisitsCount:     "sessions_open.failed_visits_count",
	FinishReason:          "sessions_open.finish_reason",
	Uptime:                "sessions_open.uptime",
}

// Generated where

var SessionsOpenWhere = struct {
	ID                    whereHelperint
	PeerID                whereHelperint
	FirstSuccessfulVisit  whereHelpertime_Time
	LastSuccessfulVisit   whereHelpertime_Time
	NextVisitDueAt        whereHelpertime_Time
	FirstFailedVisit      whereHelpernull_Time
	LastFailedVisit       whereHelpernull_Time
	LastVisitedAt         whereHelpertime_Time
	UpdatedAt             whereHelpertime_Time
	CreatedAt             whereHelpertime_Time
	SuccessfulVisitsCount whereHelperint
	RecoveredCount        whereHelperint
	State                 whereHelperstring
	FailedVisitsCount     whereHelperint16
	FinishReason          whereHelpernull_String
	Uptime                whereHelperstring
}{
	ID:                    whereHelperint{field: "\"sessions_open\".\"id\""},
	PeerID:                whereHelperint{field: "\"sessions_open\".\"peer_id\""},
	FirstSuccessfulVisit:  whereHelpertime_Time{field: "\"sessions_open\".\"first_successful_visit\""},
	LastSuccessfulVisit:   whereHelpertime_Time{field: "\"sessions_open\".\"last_successful_visit\""},
	NextVisitDueAt:        whereHelpertime_Time{field: "\"sessions_open\".\"next_visit_due_at\""},
	FirstFailedVisit:      whereHelpernull_Time{field: "\"sessions_open\".\"first_failed_visit\""},
	LastFailedVisit:       whereHelpernull_Time{field: "\"sessions_open\".\"last_failed_visit\""},
	LastVisitedAt:         whereHelpertime_Time{field: "\"sessions_open\".\"last_visited_at\""},
	UpdatedAt:             whereHelpertime_Time{field: "\"sessions_open\".\"updated_at\""},
	CreatedAt:             whereHelpertime_Time{field: "\"sessions_open\".\"created_at\""},
	SuccessfulVisitsCount: whereHelperint{field: "\"sessions_open\".\"successful_visits_count\""},
	RecoveredCount:        whereHelperint{field: "\"sessions_open\".\"recovered_count\""},
	State:                 whereHelperstring{field: "\"sessions_open\".\"state\""},
	FailedVisitsCount:     whereHelperint16{field: "\"sessions_open\".\"failed_visits_count\""},
	FinishReason:          whereHelpernull_String{field: "\"sessions_open\".\"finish_reason\""},
	Uptime:                whereHelperstring{field: "\"sessions_open\".\"uptime\""},
}

// SessionsOpenRels is where relationship names are stored.
var SessionsOpenRels = struct {
	Peer string
}{
	Peer: "Peer",
}

// sessionsOpenR is where relationships are stored.
type sessionsOpenR struct {
	Peer *Peer `boil:"Peer" json:"Peer" toml:"Peer" yaml:"Peer"`
}

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

func (r *sessionsOpenR) GetPeer() *Peer {
	if r == nil {
		return nil
	}
	return r.Peer
}

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

var (
	sessionsOpenAllColumns            = []string{"id", "peer_id", "first_successful_visit", "last_successful_visit", "next_visit_due_at", "first_failed_visit", "last_failed_visit", "last_visited_at", "updated_at", "created_at", "successful_visits_count", "recovered_count", "state", "failed_visits_count", "finish_reason", "uptime"}
	sessionsOpenColumnsWithoutDefault = []string{"peer_id", "first_successful_visit", "last_successful_visit", "next_visit_due_at", "last_visited_at", "updated_at", "created_at", "successful_visits_count", "recovered_count", "state", "failed_visits_count", "uptime"}
	sessionsOpenColumnsWithDefault    = []string{"id", "first_failed_visit", "last_failed_visit", "finish_reason"}
	sessionsOpenPrimaryKeyColumns     = []string{"id", "state", "last_visited_at"}
	sessionsOpenGeneratedColumns      = []string{}
)

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

	sessionsOpenQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	sessionsOpenType                 = reflect.TypeOf(&SessionsOpen{})
	sessionsOpenMapping              = queries.MakeStructMapping(sessionsOpenType)
	sessionsOpenPrimaryKeyMapping, _ = queries.BindMapping(sessionsOpenType, sessionsOpenMapping, sessionsOpenPrimaryKeyColumns)
	sessionsOpenInsertCacheMut       sync.RWMutex
	sessionsOpenInsertCache          = make(map[string]insertCache)
	sessionsOpenUpdateCacheMut       sync.RWMutex
	sessionsOpenUpdateCache          = make(map[string]updateCache)
	sessionsOpenUpsertCacheMut       sync.RWMutex
	sessionsOpenUpsertCache          = 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 sessionsOpenAfterSelectHooks []SessionsOpenHook

var sessionsOpenBeforeInsertHooks []SessionsOpenHook
var sessionsOpenAfterInsertHooks []SessionsOpenHook

var sessionsOpenBeforeUpdateHooks []SessionsOpenHook
var sessionsOpenAfterUpdateHooks []SessionsOpenHook

var sessionsOpenBeforeDeleteHooks []SessionsOpenHook
var sessionsOpenAfterDeleteHooks []SessionsOpenHook

var sessionsOpenBeforeUpsertHooks []SessionsOpenHook
var sessionsOpenAfterUpsertHooks []SessionsOpenHook

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

// AddSessionsOpenHook registers your hook function for all future operations.
func AddSessionsOpenHook(hookPoint boil.HookPoint, sessionsOpenHook SessionsOpenHook) {
	switch hookPoint {
	case boil.AfterSelectHook:
		sessionsOpenAfterSelectHooks = append(sessionsOpenAfterSelectHooks, sessionsOpenHook)
	case boil.BeforeInsertHook:
		sessionsOpenBeforeInsertHooks = append(sessionsOpenBeforeInsertHooks, sessionsOpenHook)
	case boil.AfterInsertHook:
		sessionsOpenAfterInsertHooks = append(sessionsOpenAfterInsertHooks, sessionsOpenHook)
	case boil.BeforeUpdateHook:
		sessionsOpenBeforeUpdateHooks = append(sessionsOpenBeforeUpdateHooks, sessionsOpenHook)
	case boil.AfterUpdateHook:
		sessionsOpenAfterUpdateHooks = append(sessionsOpenAfterUpdateHooks, sessionsOpenHook)
	case boil.BeforeDeleteHook:
		sessionsOpenBeforeDeleteHooks = append(sessionsOpenBeforeDeleteHooks, sessionsOpenHook)
	case boil.AfterDeleteHook:
		sessionsOpenAfterDeleteHooks = append(sessionsOpenAfterDeleteHooks, sessionsOpenHook)
	case boil.BeforeUpsertHook:
		sessionsOpenBeforeUpsertHooks = append(sessionsOpenBeforeUpsertHooks, sessionsOpenHook)
	case boil.AfterUpsertHook:
		sessionsOpenAfterUpsertHooks = append(sessionsOpenAfterUpsertHooks, sessionsOpenHook)
	}
}

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

	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 sessions_open")
	}

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

	return o, nil
}

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

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

	if len(sessionsOpenAfterSelectHooks) != 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 SessionsOpen records in the query.
func (q sessionsOpenQuery) 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 sessions_open rows")
	}

	return count, nil
}

// Exists checks if the row exists in the table.
func (q sessionsOpenQuery) 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 sessions_open exists")
	}

	return count > 0, nil
}

// Peer pointed to by the foreign key.
func (o *SessionsOpen) Peer(mods ...qm.QueryMod) peerQuery {
	queryMods := []qm.QueryMod{
		qm.Where("\"id\" = ?", o.PeerID),
	}

	queryMods = append(queryMods, mods...)

	return Peers(queryMods...)
}

// LoadPeer allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for an N-1 relationship.
func (sessionsOpenL) LoadPeer(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSessionsOpen interface{}, mods queries.Applicator) error {
	var slice []*SessionsOpen
	var object *SessionsOpen

	if singular {
		var ok bool
		object, ok = maybeSessionsOpen.(*SessionsOpen)
		if !ok {
			object = new(SessionsOpen)
			ok = queries.SetFromEmbeddedStruct(&object, &maybeSessionsOpen)
			if !ok {
				return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", object, maybeSessionsOpen))
			}
		}
	} else {
		s, ok := maybeSessionsOpen.(*[]*SessionsOpen)
		if ok {
			slice = *s
		} else {
			ok = queries.SetFromEmbeddedStruct(&slice, maybeSessionsOpen)
			if !ok {
				return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", slice, maybeSessionsOpen))
			}
		}
	}

	args := make([]interface{}, 0, 1)
	if singular {
		if object.R == nil {
			object.R = &sessionsOpenR{}
		}
		args = append(args, object.PeerID)

	} else {
	Outer:
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &sessionsOpenR{}
			}

			for _, a := range args {
				if a == obj.PeerID {
					continue Outer
				}
			}

			args = append(args, obj.PeerID)

		}
	}

	if len(args) == 0 {
		return nil
	}

	query := NewQuery(
		qm.From(`peers`),
		qm.WhereIn(`peers.id in ?`, args...),
	)
	if mods != nil {
		mods.Apply(query)
	}

	results, err := query.QueryContext(ctx, e)
	if err != nil {
		return errors.Wrap(err, "failed to eager load Peer")
	}

	var resultSlice []*Peer
	if err = queries.Bind(results, &resultSlice); err != nil {
		return errors.Wrap(err, "failed to bind eager loaded slice Peer")
	}

	if err = results.Close(); err != nil {
		return errors.Wrap(err, "failed to close results of eager load for peers")
	}
	if err = results.Err(); err != nil {
		return errors.Wrap(err, "error occurred during iteration of eager loaded relations for peers")
	}

	if len(peerAfterSelectHooks) != 0 {
		for _, obj := range resultSlice {
			if err := obj.doAfterSelectHooks(ctx, e); err != nil {
				return err
			}
		}
	}

	if len(resultSlice) == 0 {
		return nil
	}

	if singular {
		foreign := resultSlice[0]
		object.R.Peer = foreign
		if foreign.R == nil {
			foreign.R = &peerR{}
		}
		foreign.R.SessionsOpen = object
		return nil
	}

	for _, local := range slice {
		for _, foreign := range resultSlice {
			if local.PeerID == foreign.ID {
				local.R.Peer = foreign
				if foreign.R == nil {
					foreign.R = &peerR{}
				}
				foreign.R.SessionsOpen = local
				break
			}
		}
	}

	return nil
}

// SetPeer of the sessionsOpen to the related item.
// Sets o.R.Peer to related.
// Adds o to related.R.SessionsOpen.
func (o *SessionsOpen) SetPeer(ctx context.Context, exec boil.ContextExecutor, insert bool, related *Peer) error {
	var err error
	if insert {
		if err = related.Insert(ctx, exec, boil.Infer()); err != nil {
			return errors.Wrap(err, "failed to insert into foreign table")
		}
	}

	updateQuery := fmt.Sprintf(
		"UPDATE \"sessions_open\" SET %s WHERE %s",
		strmangle.SetParamNames("\"", "\"", 1, []string{"peer_id"}),
		strmangle.WhereClause("\"", "\"", 2, sessionsOpenPrimaryKeyColumns),
	)
	values := []interface{}{related.ID, o.ID, o.State, o.LastVisitedAt}

	if boil.IsDebug(ctx) {
		writer := boil.DebugWriterFrom(ctx)
		fmt.Fprintln(writer, updateQuery)
		fmt.Fprintln(writer, values)
	}
	if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil {
		return errors.Wrap(err, "failed to update local table")
	}

	o.PeerID = related.ID
	if o.R == nil {
		o.R = &sessionsOpenR{
			Peer: related,
		}
	} else {
		o.R.Peer = related
	}

	if related.R == nil {
		related.R = &peerR{
			SessionsOpen: o,
		}
	} else {
		related.R.SessionsOpen = o
	}

	return nil
}

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

	return sessionsOpenQuery{q}
}

// FindSessionsOpen retrieves a single record by ID with an executor.
// If selectCols is empty Find will return all columns.
func FindSessionsOpen(ctx context.Context, exec boil.ContextExecutor, iD int, state string, lastVisitedAt time.Time, selectCols ...string) (*SessionsOpen, error) {
	sessionsOpenObj := &SessionsOpen{}

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

	q := queries.Raw(query, iD, state, lastVisitedAt)

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

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

	return sessionsOpenObj, nil
}

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

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

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

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

	nzDefaults := queries.NonZeroDefaultSet(sessionsOpenColumnsWithDefault, o)

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

	if !cached {
		wl, returnColumns := columns.InsertColumnSet(
			sessionsOpenAllColumns,
			sessionsOpenColumnsWithDefault,
			sessionsOpenColumnsWithoutDefault,
			nzDefaults,
		)

		cache.valueMapping, err = queries.BindMapping(sessionsOpenType, sessionsOpenMapping, wl)
		if err != nil {
			return err
		}
		cache.retMapping, err = queries.BindMapping(sessionsOpenType, sessionsOpenMapping, returnColumns)
		if err != nil {
			return err
		}
		if len(wl) != 0 {
			cache.query = fmt.Sprintf("INSERT INTO \"sessions_open\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1))
		} else {
			cache.query = "INSERT INTO \"sessions_open\" %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 sessions_open")
	}

	if !cached {
		sessionsOpenInsertCacheMut.Lock()
		sessionsOpenInsertCache[key] = cache
		sessionsOpenInsertCacheMut.Unlock()
	}

	return o.doAfterInsertHooks(ctx, exec)
}

// Update uses an executor to update the SessionsOpen.
// 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 *SessionsOpen) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) {
	if !boil.TimestampsAreSkipped(ctx) {
		currTime := time.Now().In(boil.GetLocation())

		o.UpdatedAt = currTime
	}

	var err error
	if err = o.doBeforeUpdateHooks(ctx, exec); err != nil {
		return 0, err
	}
	key := makeCacheKey(columns, nil)
	sessionsOpenUpdateCacheMut.RLock()
	cache, cached := sessionsOpenUpdateCache[key]
	sessionsOpenUpdateCacheMut.RUnlock()

	if !cached {
		wl := columns.UpdateColumnSet(
			sessionsOpenAllColumns,
			sessionsOpenPrimaryKeyColumns,
		)

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

		cache.query = fmt.Sprintf("UPDATE \"sessions_open\" SET %s WHERE %s",
			strmangle.SetParamNames("\"", "\"", 1, wl),
			strmangle.WhereClause("\"", "\"", len(wl)+1, sessionsOpenPrimaryKeyColumns),
		)
		cache.valueMapping, err = queries.BindMapping(sessionsOpenType, sessionsOpenMapping, append(wl, sessionsOpenPrimaryKeyColumns...))
		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 sessions_open row")
	}

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

	if !cached {
		sessionsOpenUpdateCacheMut.Lock()
		sessionsOpenUpdateCache[key] = cache
		sessionsOpenUpdateCacheMut.Unlock()
	}

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

// UpdateAll updates all rows with the specified column values.
func (q sessionsOpenQuery) 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 sessions_open")
	}

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

	return rowsAff, nil
}

// UpdateAll updates all rows with the specified column values, using an executor.
func (o SessionsOpenSlice) 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)), sessionsOpenPrimaryKeyMapping)
		args = append(args, pkeyArgs...)
	}

	sql := fmt.Sprintf("UPDATE \"sessions_open\" SET %s WHERE %s",
		strmangle.SetParamNames("\"", "\"", 1, colNames),
		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, sessionsOpenPrimaryKeyColumns, 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 sessionsOpen slice")
	}

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "models: unable to retrieve rows affected all in update all sessionsOpen")
	}
	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 *SessionsOpen) Upsert(ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error {
	if o == nil {
		return errors.New("models: no sessions_open provided for upsert")
	}
	if !boil.TimestampsAreSkipped(ctx) {
		currTime := time.Now().In(boil.GetLocation())

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

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

	nzDefaults := queries.NonZeroDefaultSet(sessionsOpenColumnsWithDefault, 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)

	sessionsOpenUpsertCacheMut.RLock()
	cache, cached := sessionsOpenUpsertCache[key]
	sessionsOpenUpsertCacheMut.RUnlock()

	var err error

	if !cached {
		insert, ret := insertColumns.InsertColumnSet(
			sessionsOpenAllColumns,
			sessionsOpenColumnsWithDefault,
			sessionsOpenColumnsWithoutDefault,
			nzDefaults,
		)

		update := updateColumns.UpdateColumnSet(
			sessionsOpenAllColumns,
			sessionsOpenPrimaryKeyColumns,
		)

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

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

		cache.valueMapping, err = queries.BindMapping(sessionsOpenType, sessionsOpenMapping, insert)
		if err != nil {
			return err
		}
		if len(ret) != 0 {
			cache.retMapping, err = queries.BindMapping(sessionsOpenType, sessionsOpenMapping, 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 sessions_open")
	}

	if !cached {
		sessionsOpenUpsertCacheMut.Lock()
		sessionsOpenUpsertCache[key] = cache
		sessionsOpenUpsertCacheMut.Unlock()
	}

	return o.doAfterUpsertHooks(ctx, exec)
}

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

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

	args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), sessionsOpenPrimaryKeyMapping)
	sql := "DELETE FROM \"sessions_open\" WHERE \"id\"=$1 AND \"state\"=$2 AND \"last_visited_at\"=$3"

	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 sessions_open")
	}

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

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

	return rowsAff, nil
}

// DeleteAll deletes all matching rows.
func (q sessionsOpenQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	if q.Query == nil {
		return 0, errors.New("models: no sessionsOpenQuery 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 sessions_open")
	}

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

	return rowsAff, nil
}

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

	if len(sessionsOpenBeforeDeleteHooks) != 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)), sessionsOpenPrimaryKeyMapping)
		args = append(args, pkeyArgs...)
	}

	sql := "DELETE FROM \"sessions_open\" WHERE " +
		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, sessionsOpenPrimaryKeyColumns, 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 sessionsOpen slice")
	}

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

	if len(sessionsOpenAfterDeleteHooks) != 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 *SessionsOpen) Reload(ctx context.Context, exec boil.ContextExecutor) error {
	ret, err := FindSessionsOpen(ctx, exec, o.ID, o.State, o.LastVisitedAt)
	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 *SessionsOpenSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error {
	if o == nil || len(*o) == 0 {
		return nil
	}

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

	sql := "SELECT \"sessions_open\".* FROM \"sessions_open\" WHERE " +
		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, sessionsOpenPrimaryKeyColumns, 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 SessionsOpenSlice")
	}

	*o = slice

	return nil
}

// SessionsOpenExists checks if the SessionsOpen row exists.
func SessionsOpenExists(ctx context.Context, exec boil.ContextExecutor, iD int, state string, lastVisitedAt time.Time) (bool, error) {
	var exists bool
	sql := "select exists(select 1 from \"sessions_open\" where \"id\"=$1 AND \"state\"=$2 AND \"last_visited_at\"=$3 limit 1)"

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

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

	return exists, nil
}

// Exists checks if the SessionsOpen row exists.
func (o *SessionsOpen) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) {
	return SessionsOpenExists(ctx, exec, o.ID, o.State, o.LastVisitedAt)
}