rewards.go

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

// Reward is an object representing the database table.
type Reward struct {
	IssuanceWeek        int           `boil:"issuance_week" json:"issuance_week" toml:"issuance_week" yaml:"issuance_week"`
	VehicleID           int           `boil:"vehicle_id" json:"vehicle_id" toml:"vehicle_id" yaml:"vehicle_id"`
	ConnectionStreak    null.Int      `boil:"connection_streak" json:"connection_streak,omitempty" toml:"connection_streak" yaml:"connection_streak,omitempty"`
	StreakEarnings      types.Decimal `boil:"streak_earnings" json:"streak_earnings" toml:"streak_earnings" yaml:"streak_earnings"`
	AftermarketTokenID  null.Int      `boil:"aftermarket_token_id" json:"aftermarket_token_id,omitempty" toml:"aftermarket_token_id" yaml:"aftermarket_token_id,omitempty"`
	AftermarketEarnings types.Decimal `boil:"aftermarket_earnings" json:"aftermarket_earnings" toml:"aftermarket_earnings" yaml:"aftermarket_earnings"`
	SyntheticTokenID    null.Int      `boil:"synthetic_token_id" json:"synthetic_token_id,omitempty" toml:"synthetic_token_id" yaml:"synthetic_token_id,omitempty"`
	SyntheticEarnings   types.Decimal `boil:"synthetic_earnings" json:"synthetic_earnings" toml:"synthetic_earnings" yaml:"synthetic_earnings"`
	ReceivedByAddress   null.Bytes    `boil:"received_by_address" json:"received_by_address,omitempty" toml:"received_by_address" yaml:"received_by_address,omitempty"`
	EarnedAt            time.Time     `boil:"earned_at" json:"earned_at" toml:"earned_at" yaml:"earned_at"`

	R *rewardR `boil:"-" json:"-" toml:"-" yaml:"-"`
	L rewardL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

var RewardColumns = struct {
	IssuanceWeek        string
	VehicleID           string
	ConnectionStreak    string
	StreakEarnings      string
	AftermarketTokenID  string
	AftermarketEarnings string
	SyntheticTokenID    string
	SyntheticEarnings   string
	ReceivedByAddress   string
	EarnedAt            string
}{
	IssuanceWeek:        "issuance_week",
	VehicleID:           "vehicle_id",
	ConnectionStreak:    "connection_streak",
	StreakEarnings:      "streak_earnings",
	AftermarketTokenID:  "aftermarket_token_id",
	AftermarketEarnings: "aftermarket_earnings",
	SyntheticTokenID:    "synthetic_token_id",
	SyntheticEarnings:   "synthetic_earnings",
	ReceivedByAddress:   "received_by_address",
	EarnedAt:            "earned_at",
}

var RewardTableColumns = struct {
	IssuanceWeek        string
	VehicleID           string
	ConnectionStreak    string
	StreakEarnings      string
	AftermarketTokenID  string
	AftermarketEarnings string
	SyntheticTokenID    string
	SyntheticEarnings   string
	ReceivedByAddress   string
	EarnedAt            string
}{
	IssuanceWeek:        "rewards.issuance_week",
	VehicleID:           "rewards.vehicle_id",
	ConnectionStreak:    "rewards.connection_streak",
	StreakEarnings:      "rewards.streak_earnings",
	AftermarketTokenID:  "rewards.aftermarket_token_id",
	AftermarketEarnings: "rewards.aftermarket_earnings",
	SyntheticTokenID:    "rewards.synthetic_token_id",
	SyntheticEarnings:   "rewards.synthetic_earnings",
	ReceivedByAddress:   "rewards.received_by_address",
	EarnedAt:            "rewards.earned_at",
}

// Generated where

type whereHelpertypes_Decimal struct{ field string }

func (w whereHelpertypes_Decimal) EQ(x types.Decimal) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.EQ, x)
}
func (w whereHelpertypes_Decimal) NEQ(x types.Decimal) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.NEQ, x)
}
func (w whereHelpertypes_Decimal) LT(x types.Decimal) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.LT, x)
}
func (w whereHelpertypes_Decimal) LTE(x types.Decimal) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.LTE, x)
}
func (w whereHelpertypes_Decimal) GT(x types.Decimal) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.GT, x)
}
func (w whereHelpertypes_Decimal) GTE(x types.Decimal) qm.QueryMod {
	return qmhelper.Where(w.field, qmhelper.GTE, x)
}

type whereHelpernull_Bytes struct{ field string }

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

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

var RewardWhere = struct {
	IssuanceWeek        whereHelperint
	VehicleID           whereHelperint
	ConnectionStreak    whereHelpernull_Int
	StreakEarnings      whereHelpertypes_Decimal
	AftermarketTokenID  whereHelpernull_Int
	AftermarketEarnings whereHelpertypes_Decimal
	SyntheticTokenID    whereHelpernull_Int
	SyntheticEarnings   whereHelpertypes_Decimal
	ReceivedByAddress   whereHelpernull_Bytes
	EarnedAt            whereHelpertime_Time
}{
	IssuanceWeek:        whereHelperint{field: "\"identity_api\".\"rewards\".\"issuance_week\""},
	VehicleID:           whereHelperint{field: "\"identity_api\".\"rewards\".\"vehicle_id\""},
	ConnectionStreak:    whereHelpernull_Int{field: "\"identity_api\".\"rewards\".\"connection_streak\""},
	StreakEarnings:      whereHelpertypes_Decimal{field: "\"identity_api\".\"rewards\".\"streak_earnings\""},
	AftermarketTokenID:  whereHelpernull_Int{field: "\"identity_api\".\"rewards\".\"aftermarket_token_id\""},
	AftermarketEarnings: whereHelpertypes_Decimal{field: "\"identity_api\".\"rewards\".\"aftermarket_earnings\""},
	SyntheticTokenID:    whereHelpernull_Int{field: "\"identity_api\".\"rewards\".\"synthetic_token_id\""},
	SyntheticEarnings:   whereHelpertypes_Decimal{field: "\"identity_api\".\"rewards\".\"synthetic_earnings\""},
	ReceivedByAddress:   whereHelpernull_Bytes{field: "\"identity_api\".\"rewards\".\"received_by_address\""},
	EarnedAt:            whereHelpertime_Time{field: "\"identity_api\".\"rewards\".\"earned_at\""},
}

// RewardRels is where relationship names are stored.
var RewardRels = struct {
	AftermarketToken string
	SyntheticToken   string
	Vehicle          string
}{
	AftermarketToken: "AftermarketToken",
	SyntheticToken:   "SyntheticToken",
	Vehicle:          "Vehicle",
}

// rewardR is where relationships are stored.
type rewardR struct {
	AftermarketToken *AftermarketDevice `boil:"AftermarketToken" json:"AftermarketToken" toml:"AftermarketToken" yaml:"AftermarketToken"`
	SyntheticToken   *SyntheticDevice   `boil:"SyntheticToken" json:"SyntheticToken" toml:"SyntheticToken" yaml:"SyntheticToken"`
	Vehicle          *Vehicle           `boil:"Vehicle" json:"Vehicle" toml:"Vehicle" yaml:"Vehicle"`
}

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

func (r *rewardR) GetAftermarketToken() *AftermarketDevice {
	if r == nil {
		return nil
	}
	return r.AftermarketToken
}

func (r *rewardR) GetSyntheticToken() *SyntheticDevice {
	if r == nil {
		return nil
	}
	return r.SyntheticToken
}

func (r *rewardR) GetVehicle() *Vehicle {
	if r == nil {
		return nil
	}
	return r.Vehicle
}

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

var (
	rewardAllColumns            = []string{"issuance_week", "vehicle_id", "connection_streak", "streak_earnings", "aftermarket_token_id", "aftermarket_earnings", "synthetic_token_id", "synthetic_earnings", "received_by_address", "earned_at"}
	rewardColumnsWithoutDefault = []string{"issuance_week", "vehicle_id", "earned_at"}
	rewardColumnsWithDefault    = []string{"connection_streak", "streak_earnings", "aftermarket_token_id", "aftermarket_earnings", "synthetic_token_id", "synthetic_earnings", "received_by_address"}
	rewardPrimaryKeyColumns     = []string{"issuance_week", "vehicle_id"}
	rewardGeneratedColumns      = []string{}
)

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

	rewardQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	rewardType                 = reflect.TypeOf(&Reward{})
	rewardMapping              = queries.MakeStructMapping(rewardType)
	rewardPrimaryKeyMapping, _ = queries.BindMapping(rewardType, rewardMapping, rewardPrimaryKeyColumns)
	rewardInsertCacheMut       sync.RWMutex
	rewardInsertCache          = make(map[string]insertCache)
	rewardUpdateCacheMut       sync.RWMutex
	rewardUpdateCache          = make(map[string]updateCache)
	rewardUpsertCacheMut       sync.RWMutex
	rewardUpsertCache          = 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 rewardAfterSelectMu sync.Mutex
var rewardAfterSelectHooks []RewardHook

var rewardBeforeInsertMu sync.Mutex
var rewardBeforeInsertHooks []RewardHook
var rewardAfterInsertMu sync.Mutex
var rewardAfterInsertHooks []RewardHook

var rewardBeforeUpdateMu sync.Mutex
var rewardBeforeUpdateHooks []RewardHook
var rewardAfterUpdateMu sync.Mutex
var rewardAfterUpdateHooks []RewardHook

var rewardBeforeDeleteMu sync.Mutex
var rewardBeforeDeleteHooks []RewardHook
var rewardAfterDeleteMu sync.Mutex
var rewardAfterDeleteHooks []RewardHook

var rewardBeforeUpsertMu sync.Mutex
var rewardBeforeUpsertHooks []RewardHook
var rewardAfterUpsertMu sync.Mutex
var rewardAfterUpsertHooks []RewardHook

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

// AddRewardHook registers your hook function for all future operations.
func AddRewardHook(hookPoint boil.HookPoint, rewardHook RewardHook) {
	switch hookPoint {
	case boil.AfterSelectHook:
		rewardAfterSelectMu.Lock()
		rewardAfterSelectHooks = append(rewardAfterSelectHooks, rewardHook)
		rewardAfterSelectMu.Unlock()
	case boil.BeforeInsertHook:
		rewardBeforeInsertMu.Lock()
		rewardBeforeInsertHooks = append(rewardBeforeInsertHooks, rewardHook)
		rewardBeforeInsertMu.Unlock()
	case boil.AfterInsertHook:
		rewardAfterInsertMu.Lock()
		rewardAfterInsertHooks = append(rewardAfterInsertHooks, rewardHook)
		rewardAfterInsertMu.Unlock()
	case boil.BeforeUpdateHook:
		rewardBeforeUpdateMu.Lock()
		rewardBeforeUpdateHooks = append(rewardBeforeUpdateHooks, rewardHook)
		rewardBeforeUpdateMu.Unlock()
	case boil.AfterUpdateHook:
		rewardAfterUpdateMu.Lock()
		rewardAfterUpdateHooks = append(rewardAfterUpdateHooks, rewardHook)
		rewardAfterUpdateMu.Unlock()
	case boil.BeforeDeleteHook:
		rewardBeforeDeleteMu.Lock()
		rewardBeforeDeleteHooks = append(rewardBeforeDeleteHooks, rewardHook)
		rewardBeforeDeleteMu.Unlock()
	case boil.AfterDeleteHook:
		rewardAfterDeleteMu.Lock()
		rewardAfterDeleteHooks = append(rewardAfterDeleteHooks, rewardHook)
		rewardAfterDeleteMu.Unlock()
	case boil.BeforeUpsertHook:
		rewardBeforeUpsertMu.Lock()
		rewardBeforeUpsertHooks = append(rewardBeforeUpsertHooks, rewardHook)
		rewardBeforeUpsertMu.Unlock()
	case boil.AfterUpsertHook:
		rewardAfterUpsertMu.Lock()
		rewardAfterUpsertHooks = append(rewardAfterUpsertHooks, rewardHook)
		rewardAfterUpsertMu.Unlock()
	}
}

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

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

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

	return o, nil
}

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

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

	if len(rewardAfterSelectHooks) != 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 Reward records in the query.
func (q rewardQuery) 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 rewards rows")
	}

	return count, nil
}

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

	return count > 0, nil
}

// AftermarketToken pointed to by the foreign key.
func (o *Reward) AftermarketToken(mods ...qm.QueryMod) aftermarketDeviceQuery {
	queryMods := []qm.QueryMod{
		qm.Where("\"id\" = ?", o.AftermarketTokenID),
	}

	queryMods = append(queryMods, mods...)

	return AftermarketDevices(queryMods...)
}

// SyntheticToken pointed to by the foreign key.
func (o *Reward) SyntheticToken(mods ...qm.QueryMod) syntheticDeviceQuery {
	queryMods := []qm.QueryMod{
		qm.Where("\"id\" = ?", o.SyntheticTokenID),
	}

	queryMods = append(queryMods, mods...)

	return SyntheticDevices(queryMods...)
}

// Vehicle pointed to by the foreign key.
func (o *Reward) Vehicle(mods ...qm.QueryMod) vehicleQuery {
	queryMods := []qm.QueryMod{
		qm.Where("\"id\" = ?", o.VehicleID),
	}

	queryMods = append(queryMods, mods...)

	return Vehicles(queryMods...)
}

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

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &rewardR{}
		}
		if !queries.IsNil(object.AftermarketTokenID) {
			args[object.AftermarketTokenID] = struct{}{}
		}

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

			if !queries.IsNil(obj.AftermarketTokenID) {
				args[obj.AftermarketTokenID] = struct{}{}
			}

		}
	}

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

	argsSlice := make([]interface{}, len(args))
	i := 0
	for arg := range args {
		argsSlice[i] = arg
		i++
	}

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

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

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

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

	if len(aftermarketDeviceAfterSelectHooks) != 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.AftermarketToken = foreign
		if foreign.R == nil {
			foreign.R = &aftermarketDeviceR{}
		}
		foreign.R.AftermarketTokenRewards = append(foreign.R.AftermarketTokenRewards, object)
		return nil
	}

	for _, local := range slice {
		for _, foreign := range resultSlice {
			if queries.Equal(local.AftermarketTokenID, foreign.ID) {
				local.R.AftermarketToken = foreign
				if foreign.R == nil {
					foreign.R = &aftermarketDeviceR{}
				}
				foreign.R.AftermarketTokenRewards = append(foreign.R.AftermarketTokenRewards, local)
				break
			}
		}
	}

	return nil
}

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

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &rewardR{}
		}
		if !queries.IsNil(object.SyntheticTokenID) {
			args[object.SyntheticTokenID] = struct{}{}
		}

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

			if !queries.IsNil(obj.SyntheticTokenID) {
				args[obj.SyntheticTokenID] = struct{}{}
			}

		}
	}

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

	argsSlice := make([]interface{}, len(args))
	i := 0
	for arg := range args {
		argsSlice[i] = arg
		i++
	}

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

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

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

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

	if len(syntheticDeviceAfterSelectHooks) != 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.SyntheticToken = foreign
		if foreign.R == nil {
			foreign.R = &syntheticDeviceR{}
		}
		foreign.R.SyntheticTokenRewards = append(foreign.R.SyntheticTokenRewards, object)
		return nil
	}

	for _, local := range slice {
		for _, foreign := range resultSlice {
			if queries.Equal(local.SyntheticTokenID, foreign.ID) {
				local.R.SyntheticToken = foreign
				if foreign.R == nil {
					foreign.R = &syntheticDeviceR{}
				}
				foreign.R.SyntheticTokenRewards = append(foreign.R.SyntheticTokenRewards, local)
				break
			}
		}
	}

	return nil
}

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

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &rewardR{}
		}
		args[object.VehicleID] = struct{}{}

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

			args[obj.VehicleID] = struct{}{}

		}
	}

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

	argsSlice := make([]interface{}, len(args))
	i := 0
	for arg := range args {
		argsSlice[i] = arg
		i++
	}

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

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

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

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

	if len(vehicleAfterSelectHooks) != 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.Vehicle = foreign
		if foreign.R == nil {
			foreign.R = &vehicleR{}
		}
		foreign.R.Rewards = append(foreign.R.Rewards, object)
		return nil
	}

	for _, local := range slice {
		for _, foreign := range resultSlice {
			if local.VehicleID == foreign.ID {
				local.R.Vehicle = foreign
				if foreign.R == nil {
					foreign.R = &vehicleR{}
				}
				foreign.R.Rewards = append(foreign.R.Rewards, local)
				break
			}
		}
	}

	return nil
}

// SetAftermarketToken of the reward to the related item.
// Sets o.R.AftermarketToken to related.
// Adds o to related.R.AftermarketTokenRewards.
func (o *Reward) SetAftermarketToken(ctx context.Context, exec boil.ContextExecutor, insert bool, related *AftermarketDevice) 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 \"identity_api\".\"rewards\" SET %s WHERE %s",
		strmangle.SetParamNames("\"", "\"", 1, []string{"aftermarket_token_id"}),
		strmangle.WhereClause("\"", "\"", 2, rewardPrimaryKeyColumns),
	)
	values := []interface{}{related.ID, o.IssuanceWeek, o.VehicleID}

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

	queries.Assign(&o.AftermarketTokenID, related.ID)
	if o.R == nil {
		o.R = &rewardR{
			AftermarketToken: related,
		}
	} else {
		o.R.AftermarketToken = related
	}

	if related.R == nil {
		related.R = &aftermarketDeviceR{
			AftermarketTokenRewards: RewardSlice{o},
		}
	} else {
		related.R.AftermarketTokenRewards = append(related.R.AftermarketTokenRewards, o)
	}

	return nil
}

// RemoveAftermarketToken relationship.
// Sets o.R.AftermarketToken to nil.
// Removes o from all passed in related items' relationships struct.
func (o *Reward) RemoveAftermarketToken(ctx context.Context, exec boil.ContextExecutor, related *AftermarketDevice) error {
	var err error

	queries.SetScanner(&o.AftermarketTokenID, nil)
	if _, err = o.Update(ctx, exec, boil.Whitelist("aftermarket_token_id")); err != nil {
		return errors.Wrap(err, "failed to update local table")
	}

	if o.R != nil {
		o.R.AftermarketToken = nil
	}
	if related == nil || related.R == nil {
		return nil
	}

	for i, ri := range related.R.AftermarketTokenRewards {
		if queries.Equal(o.AftermarketTokenID, ri.AftermarketTokenID) {
			continue
		}

		ln := len(related.R.AftermarketTokenRewards)
		if ln > 1 && i < ln-1 {
			related.R.AftermarketTokenRewards[i] = related.R.AftermarketTokenRewards[ln-1]
		}
		related.R.AftermarketTokenRewards = related.R.AftermarketTokenRewards[:ln-1]
		break
	}
	return nil
}

// SetSyntheticToken of the reward to the related item.
// Sets o.R.SyntheticToken to related.
// Adds o to related.R.SyntheticTokenRewards.
func (o *Reward) SetSyntheticToken(ctx context.Context, exec boil.ContextExecutor, insert bool, related *SyntheticDevice) 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 \"identity_api\".\"rewards\" SET %s WHERE %s",
		strmangle.SetParamNames("\"", "\"", 1, []string{"synthetic_token_id"}),
		strmangle.WhereClause("\"", "\"", 2, rewardPrimaryKeyColumns),
	)
	values := []interface{}{related.ID, o.IssuanceWeek, o.VehicleID}

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

	queries.Assign(&o.SyntheticTokenID, related.ID)
	if o.R == nil {
		o.R = &rewardR{
			SyntheticToken: related,
		}
	} else {
		o.R.SyntheticToken = related
	}

	if related.R == nil {
		related.R = &syntheticDeviceR{
			SyntheticTokenRewards: RewardSlice{o},
		}
	} else {
		related.R.SyntheticTokenRewards = append(related.R.SyntheticTokenRewards, o)
	}

	return nil
}

// RemoveSyntheticToken relationship.
// Sets o.R.SyntheticToken to nil.
// Removes o from all passed in related items' relationships struct.
func (o *Reward) RemoveSyntheticToken(ctx context.Context, exec boil.ContextExecutor, related *SyntheticDevice) error {
	var err error

	queries.SetScanner(&o.SyntheticTokenID, nil)
	if _, err = o.Update(ctx, exec, boil.Whitelist("synthetic_token_id")); err != nil {
		return errors.Wrap(err, "failed to update local table")
	}

	if o.R != nil {
		o.R.SyntheticToken = nil
	}
	if related == nil || related.R == nil {
		return nil
	}

	for i, ri := range related.R.SyntheticTokenRewards {
		if queries.Equal(o.SyntheticTokenID, ri.SyntheticTokenID) {
			continue
		}

		ln := len(related.R.SyntheticTokenRewards)
		if ln > 1 && i < ln-1 {
			related.R.SyntheticTokenRewards[i] = related.R.SyntheticTokenRewards[ln-1]
		}
		related.R.SyntheticTokenRewards = related.R.SyntheticTokenRewards[:ln-1]
		break
	}
	return nil
}

// SetVehicle of the reward to the related item.
// Sets o.R.Vehicle to related.
// Adds o to related.R.Rewards.
func (o *Reward) SetVehicle(ctx context.Context, exec boil.ContextExecutor, insert bool, related *Vehicle) 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 \"identity_api\".\"rewards\" SET %s WHERE %s",
		strmangle.SetParamNames("\"", "\"", 1, []string{"vehicle_id"}),
		strmangle.WhereClause("\"", "\"", 2, rewardPrimaryKeyColumns),
	)
	values := []interface{}{related.ID, o.IssuanceWeek, o.VehicleID}

	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.VehicleID = related.ID
	if o.R == nil {
		o.R = &rewardR{
			Vehicle: related,
		}
	} else {
		o.R.Vehicle = related
	}

	if related.R == nil {
		related.R = &vehicleR{
			Rewards: RewardSlice{o},
		}
	} else {
		related.R.Rewards = append(related.R.Rewards, o)
	}

	return nil
}

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

	return rewardQuery{q}
}

// FindReward retrieves a single record by ID with an executor.
// If selectCols is empty Find will return all columns.
func FindReward(ctx context.Context, exec boil.ContextExecutor, issuanceWeek int, vehicleID int, selectCols ...string) (*Reward, error) {
	rewardObj := &Reward{}

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

	q := queries.Raw(query, issuanceWeek, vehicleID)

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

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

	return rewardObj, nil
}

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

	var err error

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

	nzDefaults := queries.NonZeroDefaultSet(rewardColumnsWithDefault, o)

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

	if !cached {
		wl, returnColumns := columns.InsertColumnSet(
			rewardAllColumns,
			rewardColumnsWithDefault,
			rewardColumnsWithoutDefault,
			nzDefaults,
		)

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

	if !cached {
		rewardInsertCacheMut.Lock()
		rewardInsertCache[key] = cache
		rewardInsertCacheMut.Unlock()
	}

	return o.doAfterInsertHooks(ctx, exec)
}

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

	if !cached {
		wl := columns.UpdateColumnSet(
			rewardAllColumns,
			rewardPrimaryKeyColumns,
		)

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

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

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

	if !cached {
		rewardUpdateCacheMut.Lock()
		rewardUpdateCache[key] = cache
		rewardUpdateCacheMut.Unlock()
	}

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

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

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

	return rowsAff, nil
}

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

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

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

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

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

	rewardUpsertCacheMut.RLock()
	cache, cached := rewardUpsertCache[key]
	rewardUpsertCacheMut.RUnlock()

	var err error

	if !cached {
		insert, _ := insertColumns.InsertColumnSet(
			rewardAllColumns,
			rewardColumnsWithDefault,
			rewardColumnsWithoutDefault,
			nzDefaults,
		)

		update := updateColumns.UpdateColumnSet(
			rewardAllColumns,
			rewardPrimaryKeyColumns,
		)

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

		ret := strmangle.SetComplement(rewardAllColumns, strmangle.SetIntersect(insert, update))

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

			conflict = make([]string, len(rewardPrimaryKeyColumns))
			copy(conflict, rewardPrimaryKeyColumns)
		}
		cache.query = buildUpsertQueryPostgres(dialect, "\"identity_api\".\"rewards\"", updateOnConflict, ret, update, conflict, insert, opts...)

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

	if !cached {
		rewardUpsertCacheMut.Lock()
		rewardUpsertCache[key] = cache
		rewardUpsertCacheMut.Unlock()
	}

	return o.doAfterUpsertHooks(ctx, exec)
}

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

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

	args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), rewardPrimaryKeyMapping)
	sql := "DELETE FROM \"identity_api\".\"rewards\" WHERE \"issuance_week\"=$1 AND \"vehicle_id\"=$2"

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

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

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

	return rowsAff, nil
}

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

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

	return rowsAff, nil
}

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

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

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

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

	if len(rewardAfterDeleteHooks) != 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 *Reward) Reload(ctx context.Context, exec boil.ContextExecutor) error {
	ret, err := FindReward(ctx, exec, o.IssuanceWeek, o.VehicleID)
	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 *RewardSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error {
	if o == nil || len(*o) == 0 {
		return nil
	}

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

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

	*o = slice

	return nil
}

// RewardExists checks if the Reward row exists.
func RewardExists(ctx context.Context, exec boil.ContextExecutor, issuanceWeek int, vehicleID int) (bool, error) {
	var exists bool
	sql := "select exists(select 1 from \"identity_api\".\"rewards\" where \"issuance_week\"=$1 AND \"vehicle_id\"=$2 limit 1)"

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

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

	return exists, nil
}

// Exists checks if the Reward row exists.
func (o *Reward) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) {
	return RewardExists(ctx, exec, o.IssuanceWeek, o.VehicleID)
}