sessions_closed.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"
)

// SessionsClosed is an object representing the database table.
type SessionsClosed 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        null.Time `boil:"next_visit_due_at" json:"next_visit_due_at,omitempty" toml:"next_visit_due_at" yaml:"next_visit_due_at,omitempty"`
	FirstFailedVisit      time.Time `boil:"first_failed_visit" json:"first_failed_visit" toml:"first_failed_visit" yaml:"first_failed_visit"`
	LastFailedVisit       time.Time `boil:"last_failed_visit" json:"last_failed_visit" toml:"last_failed_visit" yaml:"last_failed_visit"`
	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          string    `boil:"finish_reason" json:"finish_reason" toml:"finish_reason" yaml:"finish_reason"`
	Uptime                string    `boil:"uptime" json:"uptime" toml:"uptime" yaml:"uptime"`

	R *sessionsClosedR `boil:"-" json:"-" toml:"-" yaml:"-"`
	L sessionsClosedL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

var SessionsClosedColumns = 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 SessionsClosedTableColumns = 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_closed.id",
	PeerID:                "sessions_closed.peer_id",
	FirstSuccessfulVisit:  "sessions_closed.first_successful_visit",
	LastSuccessfulVisit:   "sessions_closed.last_successful_visit",
	NextVisitDueAt:        "sessions_closed.next_visit_due_at",
	FirstFailedVisit:      "sessions_closed.first_failed_visit",
	LastFailedVisit:       "sessions_closed.last_failed_visit",
	LastVisitedAt:         "sessions_closed.last_visited_at",
	UpdatedAt:             "sessions_closed.updated_at",
	CreatedAt:             "sessions_closed.created_at",
	SuccessfulVisitsCount: "sessions_closed.successful_visits_count",
	RecoveredCount:        "sessions_closed.recovered_count",
	State:                 "sessions_closed.state",
	FailedVisitsCount:     "sessions_closed.failed_visits_count",
	FinishReason:          "sessions_closed.finish_reason",
	Uptime:                "sessions_closed.uptime",
}

// Generated where

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

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

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

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

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

var (
	sessionsClosedAllColumns            = []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"}
	sessionsClosedColumnsWithoutDefault = []string{"id", "peer_id", "first_successful_visit", "last_successful_visit", "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"}
	sessionsClosedColumnsWithDefault    = []string{"next_visit_due_at"}
	sessionsClosedPrimaryKeyColumns     = []string{"id", "state", "last_visited_at"}
	sessionsClosedGeneratedColumns      = []string{}
)

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

	sessionsClosedQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	sessionsClosedType                 = reflect.TypeOf(&SessionsClosed{})
	sessionsClosedMapping              = queries.MakeStructMapping(sessionsClosedType)
	sessionsClosedPrimaryKeyMapping, _ = queries.BindMapping(sessionsClosedType, sessionsClosedMapping, sessionsClosedPrimaryKeyColumns)
	sessionsClosedInsertCacheMut       sync.RWMutex
	sessionsClosedInsertCache          = make(map[string]insertCache)
	sessionsClosedUpdateCacheMut       sync.RWMutex
	sessionsClosedUpdateCache          = make(map[string]updateCache)
	sessionsClosedUpsertCacheMut       sync.RWMutex
	sessionsClosedUpsertCache          = 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 sessionsClosedAfterSelectHooks []SessionsClosedHook

var sessionsClosedBeforeInsertHooks []SessionsClosedHook
var sessionsClosedAfterInsertHooks []SessionsClosedHook

var sessionsClosedBeforeUpdateHooks []SessionsClosedHook
var sessionsClosedAfterUpdateHooks []SessionsClosedHook

var sessionsClosedBeforeDeleteHooks []SessionsClosedHook
var sessionsClosedAfterDeleteHooks []SessionsClosedHook

var sessionsClosedBeforeUpsertHooks []SessionsClosedHook
var sessionsClosedAfterUpsertHooks []SessionsClosedHook

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

// AddSessionsClosedHook registers your hook function for all future operations.
func AddSessionsClosedHook(hookPoint boil.HookPoint, sessionsClosedHook SessionsClosedHook) {
	switch hookPoint {
	case boil.AfterSelectHook:
		sessionsClosedAfterSelectHooks = append(sessionsClosedAfterSelectHooks, sessionsClosedHook)
	case boil.BeforeInsertHook:
		sessionsClosedBeforeInsertHooks = append(sessionsClosedBeforeInsertHooks, sessionsClosedHook)
	case boil.AfterInsertHook:
		sessionsClosedAfterInsertHooks = append(sessionsClosedAfterInsertHooks, sessionsClosedHook)
	case boil.BeforeUpdateHook:
		sessionsClosedBeforeUpdateHooks = append(sessionsClosedBeforeUpdateHooks, sessionsClosedHook)
	case boil.AfterUpdateHook:
		sessionsClosedAfterUpdateHooks = append(sessionsClosedAfterUpdateHooks, sessionsClosedHook)
	case boil.BeforeDeleteHook:
		sessionsClosedBeforeDeleteHooks = append(sessionsClosedBeforeDeleteHooks, sessionsClosedHook)
	case boil.AfterDeleteHook:
		sessionsClosedAfterDeleteHooks = append(sessionsClosedAfterDeleteHooks, sessionsClosedHook)
	case boil.BeforeUpsertHook:
		sessionsClosedBeforeUpsertHooks = append(sessionsClosedBeforeUpsertHooks, sessionsClosedHook)
	case boil.AfterUpsertHook:
		sessionsClosedAfterUpsertHooks = append(sessionsClosedAfterUpsertHooks, sessionsClosedHook)
	}
}

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

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

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

	return o, nil
}

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

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

	if len(sessionsClosedAfterSelectHooks) != 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 SessionsClosed records in the query.
func (q sessionsClosedQuery) 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_closed rows")
	}

	return count, nil
}

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

	return count > 0, nil
}

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

	return sessionsClosedQuery{q}
}

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

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

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

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

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

	return sessionsClosedObj, nil
}

// Insert a single record using an executor.
// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.
func (o *SessionsClosed) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error {
	if o == nil {
		return errors.New("models: no sessions_closed 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(sessionsClosedColumnsWithDefault, o)

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

	if !cached {
		wl, returnColumns := columns.InsertColumnSet(
			sessionsClosedAllColumns,
			sessionsClosedColumnsWithDefault,
			sessionsClosedColumnsWithoutDefault,
			nzDefaults,
		)

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

	if !cached {
		sessionsClosedInsertCacheMut.Lock()
		sessionsClosedInsertCache[key] = cache
		sessionsClosedInsertCacheMut.Unlock()
	}

	return o.doAfterInsertHooks(ctx, exec)
}

// Update uses an executor to update the SessionsClosed.
// 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 *SessionsClosed) 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)
	sessionsClosedUpdateCacheMut.RLock()
	cache, cached := sessionsClosedUpdateCache[key]
	sessionsClosedUpdateCacheMut.RUnlock()

	if !cached {
		wl := columns.UpdateColumnSet(
			sessionsClosedAllColumns,
			sessionsClosedPrimaryKeyColumns,
		)

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

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

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

	if !cached {
		sessionsClosedUpdateCacheMut.Lock()
		sessionsClosedUpdateCache[key] = cache
		sessionsClosedUpdateCacheMut.Unlock()
	}

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

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

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

	return rowsAff, nil
}

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

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

	rowsAff, err := result.RowsAffected()
	if err != nil {
		return 0, errors.Wrap(err, "models: unable to retrieve rows affected all in update all sessionsClosed")
	}
	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 *SessionsClosed) 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_closed 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(sessionsClosedColumnsWithDefault, 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)

	sessionsClosedUpsertCacheMut.RLock()
	cache, cached := sessionsClosedUpsertCache[key]
	sessionsClosedUpsertCacheMut.RUnlock()

	var err error

	if !cached {
		insert, ret := insertColumns.InsertColumnSet(
			sessionsClosedAllColumns,
			sessionsClosedColumnsWithDefault,
			sessionsClosedColumnsWithoutDefault,
			nzDefaults,
		)

		update := updateColumns.UpdateColumnSet(
			sessionsClosedAllColumns,
			sessionsClosedPrimaryKeyColumns,
		)

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

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

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

	if !cached {
		sessionsClosedUpsertCacheMut.Lock()
		sessionsClosedUpsertCache[key] = cache
		sessionsClosedUpsertCacheMut.Unlock()
	}

	return o.doAfterUpsertHooks(ctx, exec)
}

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

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

	args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), sessionsClosedPrimaryKeyMapping)
	sql := "DELETE FROM \"sessions_closed\" 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_closed")
	}

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

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

	return rowsAff, nil
}

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

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

	return rowsAff, nil
}

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

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

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

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

	if len(sessionsClosedAfterDeleteHooks) != 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 *SessionsClosed) Reload(ctx context.Context, exec boil.ContextExecutor) error {
	ret, err := FindSessionsClosed(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 *SessionsClosedSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error {
	if o == nil || len(*o) == 0 {
		return nil
	}

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

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

	*o = slice

	return nil
}

// SessionsClosedExists checks if the SessionsClosed row exists.
func SessionsClosedExists(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_closed\" 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_closed exists")
	}

	return exists, nil
}

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