channel.go

// Code generated by SQLBoiler 4.16.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 model

import (
	"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"
)

// Channel is an object representing the database table.
type Channel struct {
	ClaimID             string      `boil:"claim_id" json:"claim_id" toml:"claim_id" yaml:"claim_id"`
	Name                string      `boil:"name" json:"name" toml:"name" yaml:"name"`
	IsSpammer           null.Bool   `boil:"is_spammer" json:"is_spammer,omitempty" toml:"is_spammer" yaml:"is_spammer,omitempty"`
	BlockedListInviteID null.Uint64 `boil:"blocked_list_invite_id" json:"blocked_list_invite_id,omitempty" toml:"blocked_list_invite_id" yaml:"blocked_list_invite_id,omitempty"`
	BlockedListID       null.Uint64 `boil:"blocked_list_id" json:"blocked_list_id,omitempty" toml:"blocked_list_id" yaml:"blocked_list_id,omitempty"`
	Sub                 null.String `boil:"sub" json:"sub,omitempty" toml:"sub" yaml:"sub,omitempty"`
	CreatedAt           time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
	UpdatedAt           time.Time   `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"`

	R *channelR `boil:"-" json:"-" toml:"-" yaml:"-"`
	L channelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

var ChannelColumns = struct {
	ClaimID             string
	Name                string
	IsSpammer           string
	BlockedListInviteID string
	BlockedListID       string
	Sub                 string
	CreatedAt           string
	UpdatedAt           string
}{
	ClaimID:             "claim_id",
	Name:                "name",
	IsSpammer:           "is_spammer",
	BlockedListInviteID: "blocked_list_invite_id",
	BlockedListID:       "blocked_list_id",
	Sub:                 "sub",
	CreatedAt:           "created_at",
	UpdatedAt:           "updated_at",
}

var ChannelTableColumns = struct {
	ClaimID             string
	Name                string
	IsSpammer           string
	BlockedListInviteID string
	BlockedListID       string
	Sub                 string
	CreatedAt           string
	UpdatedAt           string
}{
	ClaimID:             "channel.claim_id",
	Name:                "channel.name",
	IsSpammer:           "channel.is_spammer",
	BlockedListInviteID: "channel.blocked_list_invite_id",
	BlockedListID:       "channel.blocked_list_id",
	Sub:                 "channel.sub",
	CreatedAt:           "channel.created_at",
	UpdatedAt:           "channel.updated_at",
}

// Generated where

var ChannelWhere = struct {
	ClaimID             whereHelperstring
	Name                whereHelperstring
	IsSpammer           whereHelpernull_Bool
	BlockedListInviteID whereHelpernull_Uint64
	BlockedListID       whereHelpernull_Uint64
	Sub                 whereHelpernull_String
	CreatedAt           whereHelpertime_Time
	UpdatedAt           whereHelpertime_Time
}{
	ClaimID:             whereHelperstring{field: "`channel`.`claim_id`"},
	Name:                whereHelperstring{field: "`channel`.`name`"},
	IsSpammer:           whereHelpernull_Bool{field: "`channel`.`is_spammer`"},
	BlockedListInviteID: whereHelpernull_Uint64{field: "`channel`.`blocked_list_invite_id`"},
	BlockedListID:       whereHelpernull_Uint64{field: "`channel`.`blocked_list_id`"},
	Sub:                 whereHelpernull_String{field: "`channel`.`sub`"},
	CreatedAt:           whereHelpertime_Time{field: "`channel`.`created_at`"},
	UpdatedAt:           whereHelpertime_Time{field: "`channel`.`updated_at`"},
}

// ChannelRels is where relationship names are stored.
var ChannelRels = struct {
	BlockedListInvite                       string
	BlockedList                             string
	BlockedChannelBlockedEntries            string
	CreatorChannelBlockedEntries            string
	DelegatedModeratorChannelBlockedEntries string
	BlockedLists                            string
	InviterChannelBlockedListInvites        string
	InvitedChannelBlockedListInvites        string
	Comments                                string
	CreatorChannelCreatorSettings           string
	ModChannelDelegatedModerators           string
	CreatorChannelDelegatedModerators       string
	ModChannelModerators                    string
	Reactions                               string
}{
	BlockedListInvite:                       "BlockedListInvite",
	BlockedList:                             "BlockedList",
	BlockedChannelBlockedEntries:            "BlockedChannelBlockedEntries",
	CreatorChannelBlockedEntries:            "CreatorChannelBlockedEntries",
	DelegatedModeratorChannelBlockedEntries: "DelegatedModeratorChannelBlockedEntries",
	BlockedLists:                            "BlockedLists",
	InviterChannelBlockedListInvites:        "InviterChannelBlockedListInvites",
	InvitedChannelBlockedListInvites:        "InvitedChannelBlockedListInvites",
	Comments:                                "Comments",
	CreatorChannelCreatorSettings:           "CreatorChannelCreatorSettings",
	ModChannelDelegatedModerators:           "ModChannelDelegatedModerators",
	CreatorChannelDelegatedModerators:       "CreatorChannelDelegatedModerators",
	ModChannelModerators:                    "ModChannelModerators",
	Reactions:                               "Reactions",
}

// channelR is where relationships are stored.
type channelR struct {
	BlockedListInvite                       *BlockedList            `boil:"BlockedListInvite" json:"BlockedListInvite" toml:"BlockedListInvite" yaml:"BlockedListInvite"`
	BlockedList                             *BlockedList            `boil:"BlockedList" json:"BlockedList" toml:"BlockedList" yaml:"BlockedList"`
	BlockedChannelBlockedEntries            BlockedEntrySlice       `boil:"BlockedChannelBlockedEntries" json:"BlockedChannelBlockedEntries" toml:"BlockedChannelBlockedEntries" yaml:"BlockedChannelBlockedEntries"`
	CreatorChannelBlockedEntries            BlockedEntrySlice       `boil:"CreatorChannelBlockedEntries" json:"CreatorChannelBlockedEntries" toml:"CreatorChannelBlockedEntries" yaml:"CreatorChannelBlockedEntries"`
	DelegatedModeratorChannelBlockedEntries BlockedEntrySlice       `boil:"DelegatedModeratorChannelBlockedEntries" json:"DelegatedModeratorChannelBlockedEntries" toml:"DelegatedModeratorChannelBlockedEntries" yaml:"DelegatedModeratorChannelBlockedEntries"`
	BlockedLists                            BlockedListSlice        `boil:"BlockedLists" json:"BlockedLists" toml:"BlockedLists" yaml:"BlockedLists"`
	InviterChannelBlockedListInvites        BlockedListInviteSlice  `boil:"InviterChannelBlockedListInvites" json:"InviterChannelBlockedListInvites" toml:"InviterChannelBlockedListInvites" yaml:"InviterChannelBlockedListInvites"`
	InvitedChannelBlockedListInvites        BlockedListInviteSlice  `boil:"InvitedChannelBlockedListInvites" json:"InvitedChannelBlockedListInvites" toml:"InvitedChannelBlockedListInvites" yaml:"InvitedChannelBlockedListInvites"`
	Comments                                CommentSlice            `boil:"Comments" json:"Comments" toml:"Comments" yaml:"Comments"`
	CreatorChannelCreatorSettings           CreatorSettingSlice     `boil:"CreatorChannelCreatorSettings" json:"CreatorChannelCreatorSettings" toml:"CreatorChannelCreatorSettings" yaml:"CreatorChannelCreatorSettings"`
	ModChannelDelegatedModerators           DelegatedModeratorSlice `boil:"ModChannelDelegatedModerators" json:"ModChannelDelegatedModerators" toml:"ModChannelDelegatedModerators" yaml:"ModChannelDelegatedModerators"`
	CreatorChannelDelegatedModerators       DelegatedModeratorSlice `boil:"CreatorChannelDelegatedModerators" json:"CreatorChannelDelegatedModerators" toml:"CreatorChannelDelegatedModerators" yaml:"CreatorChannelDelegatedModerators"`
	ModChannelModerators                    ModeratorSlice          `boil:"ModChannelModerators" json:"ModChannelModerators" toml:"ModChannelModerators" yaml:"ModChannelModerators"`
	Reactions                               ReactionSlice           `boil:"Reactions" json:"Reactions" toml:"Reactions" yaml:"Reactions"`
}

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

func (r *channelR) GetBlockedListInvite() *BlockedList {
	if r == nil {
		return nil
	}
	return r.BlockedListInvite
}

func (r *channelR) GetBlockedList() *BlockedList {
	if r == nil {
		return nil
	}
	return r.BlockedList
}

func (r *channelR) GetBlockedChannelBlockedEntries() BlockedEntrySlice {
	if r == nil {
		return nil
	}
	return r.BlockedChannelBlockedEntries
}

func (r *channelR) GetCreatorChannelBlockedEntries() BlockedEntrySlice {
	if r == nil {
		return nil
	}
	return r.CreatorChannelBlockedEntries
}

func (r *channelR) GetDelegatedModeratorChannelBlockedEntries() BlockedEntrySlice {
	if r == nil {
		return nil
	}
	return r.DelegatedModeratorChannelBlockedEntries
}

func (r *channelR) GetBlockedLists() BlockedListSlice {
	if r == nil {
		return nil
	}
	return r.BlockedLists
}

func (r *channelR) GetInviterChannelBlockedListInvites() BlockedListInviteSlice {
	if r == nil {
		return nil
	}
	return r.InviterChannelBlockedListInvites
}

func (r *channelR) GetInvitedChannelBlockedListInvites() BlockedListInviteSlice {
	if r == nil {
		return nil
	}
	return r.InvitedChannelBlockedListInvites
}

func (r *channelR) GetComments() CommentSlice {
	if r == nil {
		return nil
	}
	return r.Comments
}

func (r *channelR) GetCreatorChannelCreatorSettings() CreatorSettingSlice {
	if r == nil {
		return nil
	}
	return r.CreatorChannelCreatorSettings
}

func (r *channelR) GetModChannelDelegatedModerators() DelegatedModeratorSlice {
	if r == nil {
		return nil
	}
	return r.ModChannelDelegatedModerators
}

func (r *channelR) GetCreatorChannelDelegatedModerators() DelegatedModeratorSlice {
	if r == nil {
		return nil
	}
	return r.CreatorChannelDelegatedModerators
}

func (r *channelR) GetModChannelModerators() ModeratorSlice {
	if r == nil {
		return nil
	}
	return r.ModChannelModerators
}

func (r *channelR) GetReactions() ReactionSlice {
	if r == nil {
		return nil
	}
	return r.Reactions
}

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

var (
	channelAllColumns            = []string{"claim_id", "name", "is_spammer", "blocked_list_invite_id", "blocked_list_id", "sub", "created_at", "updated_at"}
	channelColumnsWithoutDefault = []string{"claim_id", "name", "blocked_list_invite_id", "blocked_list_id", "sub"}
	channelColumnsWithDefault    = []string{"is_spammer", "created_at", "updated_at"}
	channelPrimaryKeyColumns     = []string{"claim_id"}
	channelGeneratedColumns      = []string{}
)

type (
	// ChannelSlice is an alias for a slice of pointers to Channel.
	// This should almost always be used instead of []Channel.
	ChannelSlice []*Channel

	channelQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	channelType                 = reflect.TypeOf(&Channel{})
	channelMapping              = queries.MakeStructMapping(channelType)
	channelPrimaryKeyMapping, _ = queries.BindMapping(channelType, channelMapping, channelPrimaryKeyColumns)
	channelInsertCacheMut       sync.RWMutex
	channelInsertCache          = make(map[string]insertCache)
	channelUpdateCacheMut       sync.RWMutex
	channelUpdateCache          = make(map[string]updateCache)
	channelUpsertCacheMut       sync.RWMutex
	channelUpsertCache          = 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
)

// One returns a single channel record from the query.
func (q channelQuery) One(exec boil.Executor) (*Channel, error) {
	o := &Channel{}

	queries.SetLimit(q.Query, 1)

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

	return o, nil
}

// All returns all Channel records from the query.
func (q channelQuery) All(exec boil.Executor) (ChannelSlice, error) {
	var o []*Channel

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

	return o, nil
}

// Count returns the count of all Channel records in the query.
func (q channelQuery) Count(exec boil.Executor) (int64, error) {
	var count int64

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

	err := q.Query.QueryRow(exec).Scan(&count)
	if err != nil {
		return 0, errors.Wrap(err, "model: failed to count channel rows")
	}

	return count, nil
}

// Exists checks if the row exists in the table.
func (q channelQuery) Exists(exec boil.Executor) (bool, error) {
	var count int64

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

	err := q.Query.QueryRow(exec).Scan(&count)
	if err != nil {
		return false, errors.Wrap(err, "model: failed to check if channel exists")
	}

	return count > 0, nil
}

// BlockedListInvite pointed to by the foreign key.
func (o *Channel) BlockedListInvite(mods ...qm.QueryMod) blockedListQuery {
	queryMods := []qm.QueryMod{
		qm.Where("`id` = ?", o.BlockedListInviteID),
	}

	queryMods = append(queryMods, mods...)

	return BlockedLists(queryMods...)
}

// BlockedList pointed to by the foreign key.
func (o *Channel) BlockedList(mods ...qm.QueryMod) blockedListQuery {
	queryMods := []qm.QueryMod{
		qm.Where("`id` = ?", o.BlockedListID),
	}

	queryMods = append(queryMods, mods...)

	return BlockedLists(queryMods...)
}

// BlockedChannelBlockedEntries retrieves all the blocked_entry's BlockedEntries with an executor via blocked_channel_id column.
func (o *Channel) BlockedChannelBlockedEntries(mods ...qm.QueryMod) blockedEntryQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.Where("`blocked_entry`.`blocked_channel_id`=?", o.ClaimID),
	)

	return BlockedEntries(queryMods...)
}

// CreatorChannelBlockedEntries retrieves all the blocked_entry's BlockedEntries with an executor via creator_channel_id column.
func (o *Channel) CreatorChannelBlockedEntries(mods ...qm.QueryMod) blockedEntryQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.Where("`blocked_entry`.`creator_channel_id`=?", o.ClaimID),
	)

	return BlockedEntries(queryMods...)
}

// DelegatedModeratorChannelBlockedEntries retrieves all the blocked_entry's BlockedEntries with an executor via delegated_moderator_channel_id column.
func (o *Channel) DelegatedModeratorChannelBlockedEntries(mods ...qm.QueryMod) blockedEntryQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.Where("`blocked_entry`.`delegated_moderator_channel_id`=?", o.ClaimID),
	)

	return BlockedEntries(queryMods...)
}

// BlockedLists retrieves all the blocked_list's BlockedLists with an executor.
func (o *Channel) BlockedLists(mods ...qm.QueryMod) blockedListQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.Where("`blocked_list`.`channel_id`=?", o.ClaimID),
	)

	return BlockedLists(queryMods...)
}

// InviterChannelBlockedListInvites retrieves all the blocked_list_invite's BlockedListInvites with an executor via inviter_channel_id column.
func (o *Channel) InviterChannelBlockedListInvites(mods ...qm.QueryMod) blockedListInviteQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.Where("`blocked_list_invite`.`inviter_channel_id`=?", o.ClaimID),
	)

	return BlockedListInvites(queryMods...)
}

// InvitedChannelBlockedListInvites retrieves all the blocked_list_invite's BlockedListInvites with an executor via invited_channel_id column.
func (o *Channel) InvitedChannelBlockedListInvites(mods ...qm.QueryMod) blockedListInviteQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.Where("`blocked_list_invite`.`invited_channel_id`=?", o.ClaimID),
	)

	return BlockedListInvites(queryMods...)
}

// Comments retrieves all the comment's Comments with an executor.
func (o *Channel) Comments(mods ...qm.QueryMod) commentQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.Where("`comment`.`channel_id`=?", o.ClaimID),
	)

	return Comments(queryMods...)
}

// CreatorChannelCreatorSettings retrieves all the creator_setting's CreatorSettings with an executor via creator_channel_id column.
func (o *Channel) CreatorChannelCreatorSettings(mods ...qm.QueryMod) creatorSettingQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.Where("`creator_setting`.`creator_channel_id`=?", o.ClaimID),
	)

	return CreatorSettings(queryMods...)
}

// ModChannelDelegatedModerators retrieves all the delegated_moderator's DelegatedModerators with an executor via mod_channel_id column.
func (o *Channel) ModChannelDelegatedModerators(mods ...qm.QueryMod) delegatedModeratorQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.Where("`delegated_moderator`.`mod_channel_id`=?", o.ClaimID),
	)

	return DelegatedModerators(queryMods...)
}

// CreatorChannelDelegatedModerators retrieves all the delegated_moderator's DelegatedModerators with an executor via creator_channel_id column.
func (o *Channel) CreatorChannelDelegatedModerators(mods ...qm.QueryMod) delegatedModeratorQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.Where("`delegated_moderator`.`creator_channel_id`=?", o.ClaimID),
	)

	return DelegatedModerators(queryMods...)
}

// ModChannelModerators retrieves all the moderator's Moderators with an executor via mod_channel_id column.
func (o *Channel) ModChannelModerators(mods ...qm.QueryMod) moderatorQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.Where("`moderator`.`mod_channel_id`=?", o.ClaimID),
	)

	return Moderators(queryMods...)
}

// Reactions retrieves all the reaction's Reactions with an executor.
func (o *Channel) Reactions(mods ...qm.QueryMod) reactionQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}

	queryMods = append(queryMods,
		qm.Where("`reaction`.`channel_id`=?", o.ClaimID),
	)

	return Reactions(queryMods...)
}

// LoadBlockedListInvite allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for an N-1 relationship.
func (channelL) LoadBlockedListInvite(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

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

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

			if !queries.IsNil(obj.BlockedListInviteID) {
				args[obj.BlockedListInviteID] = 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(`blocked_list`),
		qm.WhereIn(`blocked_list.id in ?`, argsSlice...),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

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

	if singular {
		foreign := resultSlice[0]
		object.R.BlockedListInvite = foreign
		if foreign.R == nil {
			foreign.R = &blockedListR{}
		}
		foreign.R.BlockedListInviteChannels = append(foreign.R.BlockedListInviteChannels, object)
		return nil
	}

	for _, local := range slice {
		for _, foreign := range resultSlice {
			if queries.Equal(local.BlockedListInviteID, foreign.ID) {
				local.R.BlockedListInvite = foreign
				if foreign.R == nil {
					foreign.R = &blockedListR{}
				}
				foreign.R.BlockedListInviteChannels = append(foreign.R.BlockedListInviteChannels, local)
				break
			}
		}
	}

	return nil
}

// LoadBlockedList allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for an N-1 relationship.
func (channelL) LoadBlockedList(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

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

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

			if !queries.IsNil(obj.BlockedListID) {
				args[obj.BlockedListID] = 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(`blocked_list`),
		qm.WhereIn(`blocked_list.id in ?`, argsSlice...),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

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

	if singular {
		foreign := resultSlice[0]
		object.R.BlockedList = foreign
		if foreign.R == nil {
			foreign.R = &blockedListR{}
		}
		foreign.R.Channels = append(foreign.R.Channels, object)
		return nil
	}

	for _, local := range slice {
		for _, foreign := range resultSlice {
			if queries.Equal(local.BlockedListID, foreign.ID) {
				local.R.BlockedList = foreign
				if foreign.R == nil {
					foreign.R = &blockedListR{}
				}
				foreign.R.Channels = append(foreign.R.Channels, local)
				break
			}
		}
	}

	return nil
}

// LoadBlockedChannelBlockedEntries allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (channelL) LoadBlockedChannelBlockedEntries(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &channelR{}
		}
		args[object.ClaimID] = struct{}{}
	} else {
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &channelR{}
			}
			args[obj.ClaimID] = 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(`blocked_entry`),
		qm.WhereIn(`blocked_entry.blocked_channel_id in ?`, argsSlice...),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

	if singular {
		object.R.BlockedChannelBlockedEntries = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &blockedEntryR{}
			}
			foreign.R.BlockedChannel = object
		}
		return nil
	}

	for _, foreign := range resultSlice {
		for _, local := range slice {
			if queries.Equal(local.ClaimID, foreign.BlockedChannelID) {
				local.R.BlockedChannelBlockedEntries = append(local.R.BlockedChannelBlockedEntries, foreign)
				if foreign.R == nil {
					foreign.R = &blockedEntryR{}
				}
				foreign.R.BlockedChannel = local
				break
			}
		}
	}

	return nil
}

// LoadCreatorChannelBlockedEntries allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (channelL) LoadCreatorChannelBlockedEntries(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &channelR{}
		}
		args[object.ClaimID] = struct{}{}
	} else {
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &channelR{}
			}
			args[obj.ClaimID] = 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(`blocked_entry`),
		qm.WhereIn(`blocked_entry.creator_channel_id in ?`, argsSlice...),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

	if singular {
		object.R.CreatorChannelBlockedEntries = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &blockedEntryR{}
			}
			foreign.R.CreatorChannel = object
		}
		return nil
	}

	for _, foreign := range resultSlice {
		for _, local := range slice {
			if queries.Equal(local.ClaimID, foreign.CreatorChannelID) {
				local.R.CreatorChannelBlockedEntries = append(local.R.CreatorChannelBlockedEntries, foreign)
				if foreign.R == nil {
					foreign.R = &blockedEntryR{}
				}
				foreign.R.CreatorChannel = local
				break
			}
		}
	}

	return nil
}

// LoadDelegatedModeratorChannelBlockedEntries allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (channelL) LoadDelegatedModeratorChannelBlockedEntries(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &channelR{}
		}
		args[object.ClaimID] = struct{}{}
	} else {
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &channelR{}
			}
			args[obj.ClaimID] = 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(`blocked_entry`),
		qm.WhereIn(`blocked_entry.delegated_moderator_channel_id in ?`, argsSlice...),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

	if singular {
		object.R.DelegatedModeratorChannelBlockedEntries = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &blockedEntryR{}
			}
			foreign.R.DelegatedModeratorChannel = object
		}
		return nil
	}

	for _, foreign := range resultSlice {
		for _, local := range slice {
			if queries.Equal(local.ClaimID, foreign.DelegatedModeratorChannelID) {
				local.R.DelegatedModeratorChannelBlockedEntries = append(local.R.DelegatedModeratorChannelBlockedEntries, foreign)
				if foreign.R == nil {
					foreign.R = &blockedEntryR{}
				}
				foreign.R.DelegatedModeratorChannel = local
				break
			}
		}
	}

	return nil
}

// LoadBlockedLists allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (channelL) LoadBlockedLists(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &channelR{}
		}
		args[object.ClaimID] = struct{}{}
	} else {
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &channelR{}
			}
			args[obj.ClaimID] = 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(`blocked_list`),
		qm.WhereIn(`blocked_list.channel_id in ?`, argsSlice...),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

	if singular {
		object.R.BlockedLists = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &blockedListR{}
			}
			foreign.R.Channel = object
		}
		return nil
	}

	for _, foreign := range resultSlice {
		for _, local := range slice {
			if local.ClaimID == foreign.ChannelID {
				local.R.BlockedLists = append(local.R.BlockedLists, foreign)
				if foreign.R == nil {
					foreign.R = &blockedListR{}
				}
				foreign.R.Channel = local
				break
			}
		}
	}

	return nil
}

// LoadInviterChannelBlockedListInvites allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (channelL) LoadInviterChannelBlockedListInvites(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &channelR{}
		}
		args[object.ClaimID] = struct{}{}
	} else {
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &channelR{}
			}
			args[obj.ClaimID] = 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(`blocked_list_invite`),
		qm.WhereIn(`blocked_list_invite.inviter_channel_id in ?`, argsSlice...),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

	if singular {
		object.R.InviterChannelBlockedListInvites = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &blockedListInviteR{}
			}
			foreign.R.InviterChannel = object
		}
		return nil
	}

	for _, foreign := range resultSlice {
		for _, local := range slice {
			if local.ClaimID == foreign.InviterChannelID {
				local.R.InviterChannelBlockedListInvites = append(local.R.InviterChannelBlockedListInvites, foreign)
				if foreign.R == nil {
					foreign.R = &blockedListInviteR{}
				}
				foreign.R.InviterChannel = local
				break
			}
		}
	}

	return nil
}

// LoadInvitedChannelBlockedListInvites allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (channelL) LoadInvitedChannelBlockedListInvites(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &channelR{}
		}
		args[object.ClaimID] = struct{}{}
	} else {
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &channelR{}
			}
			args[obj.ClaimID] = 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(`blocked_list_invite`),
		qm.WhereIn(`blocked_list_invite.invited_channel_id in ?`, argsSlice...),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

	if singular {
		object.R.InvitedChannelBlockedListInvites = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &blockedListInviteR{}
			}
			foreign.R.InvitedChannel = object
		}
		return nil
	}

	for _, foreign := range resultSlice {
		for _, local := range slice {
			if local.ClaimID == foreign.InvitedChannelID {
				local.R.InvitedChannelBlockedListInvites = append(local.R.InvitedChannelBlockedListInvites, foreign)
				if foreign.R == nil {
					foreign.R = &blockedListInviteR{}
				}
				foreign.R.InvitedChannel = local
				break
			}
		}
	}

	return nil
}

// LoadComments allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (channelL) LoadComments(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &channelR{}
		}
		args[object.ClaimID] = struct{}{}
	} else {
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &channelR{}
			}
			args[obj.ClaimID] = 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(`comment`),
		qm.WhereIn(`comment.channel_id in ?`, argsSlice...),
		qmhelper.WhereIsNull(`comment.deleted_at`),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

	if singular {
		object.R.Comments = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &commentR{}
			}
			foreign.R.Channel = object
		}
		return nil
	}

	for _, foreign := range resultSlice {
		for _, local := range slice {
			if queries.Equal(local.ClaimID, foreign.ChannelID) {
				local.R.Comments = append(local.R.Comments, foreign)
				if foreign.R == nil {
					foreign.R = &commentR{}
				}
				foreign.R.Channel = local
				break
			}
		}
	}

	return nil
}

// LoadCreatorChannelCreatorSettings allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (channelL) LoadCreatorChannelCreatorSettings(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &channelR{}
		}
		args[object.ClaimID] = struct{}{}
	} else {
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &channelR{}
			}
			args[obj.ClaimID] = 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(`creator_setting`),
		qm.WhereIn(`creator_setting.creator_channel_id in ?`, argsSlice...),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

	if singular {
		object.R.CreatorChannelCreatorSettings = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &creatorSettingR{}
			}
			foreign.R.CreatorChannel = object
		}
		return nil
	}

	for _, foreign := range resultSlice {
		for _, local := range slice {
			if local.ClaimID == foreign.CreatorChannelID {
				local.R.CreatorChannelCreatorSettings = append(local.R.CreatorChannelCreatorSettings, foreign)
				if foreign.R == nil {
					foreign.R = &creatorSettingR{}
				}
				foreign.R.CreatorChannel = local
				break
			}
		}
	}

	return nil
}

// LoadModChannelDelegatedModerators allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (channelL) LoadModChannelDelegatedModerators(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &channelR{}
		}
		args[object.ClaimID] = struct{}{}
	} else {
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &channelR{}
			}
			args[obj.ClaimID] = 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(`delegated_moderator`),
		qm.WhereIn(`delegated_moderator.mod_channel_id in ?`, argsSlice...),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

	if singular {
		object.R.ModChannelDelegatedModerators = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &delegatedModeratorR{}
			}
			foreign.R.ModChannel = object
		}
		return nil
	}

	for _, foreign := range resultSlice {
		for _, local := range slice {
			if local.ClaimID == foreign.ModChannelID {
				local.R.ModChannelDelegatedModerators = append(local.R.ModChannelDelegatedModerators, foreign)
				if foreign.R == nil {
					foreign.R = &delegatedModeratorR{}
				}
				foreign.R.ModChannel = local
				break
			}
		}
	}

	return nil
}

// LoadCreatorChannelDelegatedModerators allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (channelL) LoadCreatorChannelDelegatedModerators(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &channelR{}
		}
		args[object.ClaimID] = struct{}{}
	} else {
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &channelR{}
			}
			args[obj.ClaimID] = 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(`delegated_moderator`),
		qm.WhereIn(`delegated_moderator.creator_channel_id in ?`, argsSlice...),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

	if singular {
		object.R.CreatorChannelDelegatedModerators = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &delegatedModeratorR{}
			}
			foreign.R.CreatorChannel = object
		}
		return nil
	}

	for _, foreign := range resultSlice {
		for _, local := range slice {
			if local.ClaimID == foreign.CreatorChannelID {
				local.R.CreatorChannelDelegatedModerators = append(local.R.CreatorChannelDelegatedModerators, foreign)
				if foreign.R == nil {
					foreign.R = &delegatedModeratorR{}
				}
				foreign.R.CreatorChannel = local
				break
			}
		}
	}

	return nil
}

// LoadModChannelModerators allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (channelL) LoadModChannelModerators(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &channelR{}
		}
		args[object.ClaimID] = struct{}{}
	} else {
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &channelR{}
			}
			args[obj.ClaimID] = 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(`moderator`),
		qm.WhereIn(`moderator.mod_channel_id in ?`, argsSlice...),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

	if singular {
		object.R.ModChannelModerators = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &moderatorR{}
			}
			foreign.R.ModChannel = object
		}
		return nil
	}

	for _, foreign := range resultSlice {
		for _, local := range slice {
			if queries.Equal(local.ClaimID, foreign.ModChannelID) {
				local.R.ModChannelModerators = append(local.R.ModChannelModerators, foreign)
				if foreign.R == nil {
					foreign.R = &moderatorR{}
				}
				foreign.R.ModChannel = local
				break
			}
		}
	}

	return nil
}

// LoadReactions allows an eager lookup of values, cached into the
// loaded structs of the objects. This is for a 1-M or N-M relationship.
func (channelL) LoadReactions(e boil.Executor, singular bool, maybeChannel interface{}, mods queries.Applicator) error {
	var slice []*Channel
	var object *Channel

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

	args := make(map[interface{}]struct{})
	if singular {
		if object.R == nil {
			object.R = &channelR{}
		}
		args[object.ClaimID] = struct{}{}
	} else {
		for _, obj := range slice {
			if obj.R == nil {
				obj.R = &channelR{}
			}
			args[obj.ClaimID] = 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(`reaction`),
		qm.WhereIn(`reaction.channel_id in ?`, argsSlice...),
	)
	if mods != nil {
		mods.Apply(query)
	}

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

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

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

	if singular {
		object.R.Reactions = resultSlice
		for _, foreign := range resultSlice {
			if foreign.R == nil {
				foreign.R = &reactionR{}
			}
			foreign.R.Channel = object
		}
		return nil
	}

	for _, foreign := range resultSlice {
		for _, local := range slice {
			if queries.Equal(local.ClaimID, foreign.ChannelID) {
				local.R.Reactions = append(local.R.Reactions, foreign)
				if foreign.R == nil {
					foreign.R = &reactionR{}
				}
				foreign.R.Channel = local
				break
			}
		}
	}

	return nil
}

// SetBlockedListInvite of the channel to the related item.
// Sets o.R.BlockedListInvite to related.
// Adds o to related.R.BlockedListInviteChannels.
func (o *Channel) SetBlockedListInvite(exec boil.Executor, insert bool, related *BlockedList) error {
	var err error
	if insert {
		if err = related.Insert(exec, boil.Infer()); err != nil {
			return errors.Wrap(err, "failed to insert into foreign table")
		}
	}

	updateQuery := fmt.Sprintf(
		"UPDATE `channel` SET %s WHERE %s",
		strmangle.SetParamNames("`", "`", 0, []string{"blocked_list_invite_id"}),
		strmangle.WhereClause("`", "`", 0, channelPrimaryKeyColumns),
	)
	values := []interface{}{related.ID, o.ClaimID}

	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, updateQuery)
		fmt.Fprintln(boil.DebugWriter, values)
	}
	if _, err = exec.Exec(updateQuery, values...); err != nil {
		return errors.Wrap(err, "failed to update local table")
	}

	queries.Assign(&o.BlockedListInviteID, related.ID)
	if o.R == nil {
		o.R = &channelR{
			BlockedListInvite: related,
		}
	} else {
		o.R.BlockedListInvite = related
	}

	if related.R == nil {
		related.R = &blockedListR{
			BlockedListInviteChannels: ChannelSlice{o},
		}
	} else {
		related.R.BlockedListInviteChannels = append(related.R.BlockedListInviteChannels, o)
	}

	return nil
}

// RemoveBlockedListInvite relationship.
// Sets o.R.BlockedListInvite to nil.
// Removes o from all passed in related items' relationships struct.
func (o *Channel) RemoveBlockedListInvite(exec boil.Executor, related *BlockedList) error {
	var err error

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

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

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

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

// SetBlockedList of the channel to the related item.
// Sets o.R.BlockedList to related.
// Adds o to related.R.Channels.
func (o *Channel) SetBlockedList(exec boil.Executor, insert bool, related *BlockedList) error {
	var err error
	if insert {
		if err = related.Insert(exec, boil.Infer()); err != nil {
			return errors.Wrap(err, "failed to insert into foreign table")
		}
	}

	updateQuery := fmt.Sprintf(
		"UPDATE `channel` SET %s WHERE %s",
		strmangle.SetParamNames("`", "`", 0, []string{"blocked_list_id"}),
		strmangle.WhereClause("`", "`", 0, channelPrimaryKeyColumns),
	)
	values := []interface{}{related.ID, o.ClaimID}

	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, updateQuery)
		fmt.Fprintln(boil.DebugWriter, values)
	}
	if _, err = exec.Exec(updateQuery, values...); err != nil {
		return errors.Wrap(err, "failed to update local table")
	}

	queries.Assign(&o.BlockedListID, related.ID)
	if o.R == nil {
		o.R = &channelR{
			BlockedList: related,
		}
	} else {
		o.R.BlockedList = related
	}

	if related.R == nil {
		related.R = &blockedListR{
			Channels: ChannelSlice{o},
		}
	} else {
		related.R.Channels = append(related.R.Channels, o)
	}

	return nil
}

// RemoveBlockedList relationship.
// Sets o.R.BlockedList to nil.
// Removes o from all passed in related items' relationships struct.
func (o *Channel) RemoveBlockedList(exec boil.Executor, related *BlockedList) error {
	var err error

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

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

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

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

// AddBlockedChannelBlockedEntries adds the given related objects to the existing relationships
// of the channel, optionally inserting them as new records.
// Appends related to o.R.BlockedChannelBlockedEntries.
// Sets related.R.BlockedChannel appropriately.
func (o *Channel) AddBlockedChannelBlockedEntries(exec boil.Executor, insert bool, related ...*BlockedEntry) error {
	var err error
	for _, rel := range related {
		if insert {
			queries.Assign(&rel.BlockedChannelID, o.ClaimID)
			if err = rel.Insert(exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		} else {
			updateQuery := fmt.Sprintf(
				"UPDATE `blocked_entry` SET %s WHERE %s",
				strmangle.SetParamNames("`", "`", 0, []string{"blocked_channel_id"}),
				strmangle.WhereClause("`", "`", 0, blockedEntryPrimaryKeyColumns),
			)
			values := []interface{}{o.ClaimID, rel.ID}

			if boil.DebugMode {
				fmt.Fprintln(boil.DebugWriter, updateQuery)
				fmt.Fprintln(boil.DebugWriter, values)
			}
			if _, err = exec.Exec(updateQuery, values...); err != nil {
				return errors.Wrap(err, "failed to update foreign table")
			}

			queries.Assign(&rel.BlockedChannelID, o.ClaimID)
		}
	}

	if o.R == nil {
		o.R = &channelR{
			BlockedChannelBlockedEntries: related,
		}
	} else {
		o.R.BlockedChannelBlockedEntries = append(o.R.BlockedChannelBlockedEntries, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &blockedEntryR{
				BlockedChannel: o,
			}
		} else {
			rel.R.BlockedChannel = o
		}
	}
	return nil
}

// SetBlockedChannelBlockedEntries removes all previously related items of the
// channel replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.BlockedChannel's BlockedChannelBlockedEntries accordingly.
// Replaces o.R.BlockedChannelBlockedEntries with related.
// Sets related.R.BlockedChannel's BlockedChannelBlockedEntries accordingly.
func (o *Channel) SetBlockedChannelBlockedEntries(exec boil.Executor, insert bool, related ...*BlockedEntry) error {
	query := "update `blocked_entry` set `blocked_channel_id` = null where `blocked_channel_id` = ?"
	values := []interface{}{o.ClaimID}
	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, query)
		fmt.Fprintln(boil.DebugWriter, values)
	}
	_, err := exec.Exec(query, values...)
	if err != nil {
		return errors.Wrap(err, "failed to remove relationships before set")
	}

	if o.R != nil {
		for _, rel := range o.R.BlockedChannelBlockedEntries {
			queries.SetScanner(&rel.BlockedChannelID, nil)
			if rel.R == nil {
				continue
			}

			rel.R.BlockedChannel = nil
		}
		o.R.BlockedChannelBlockedEntries = nil
	}

	return o.AddBlockedChannelBlockedEntries(exec, insert, related...)
}

// RemoveBlockedChannelBlockedEntries relationships from objects passed in.
// Removes related items from R.BlockedChannelBlockedEntries (uses pointer comparison, removal does not keep order)
// Sets related.R.BlockedChannel.
func (o *Channel) RemoveBlockedChannelBlockedEntries(exec boil.Executor, related ...*BlockedEntry) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	for _, rel := range related {
		queries.SetScanner(&rel.BlockedChannelID, nil)
		if rel.R != nil {
			rel.R.BlockedChannel = nil
		}
		if err = rel.Update(exec, boil.Whitelist("blocked_channel_id")); err != nil {
			return err
		}
	}
	if o.R == nil {
		return nil
	}

	for _, rel := range related {
		for i, ri := range o.R.BlockedChannelBlockedEntries {
			if rel != ri {
				continue
			}

			ln := len(o.R.BlockedChannelBlockedEntries)
			if ln > 1 && i < ln-1 {
				o.R.BlockedChannelBlockedEntries[i] = o.R.BlockedChannelBlockedEntries[ln-1]
			}
			o.R.BlockedChannelBlockedEntries = o.R.BlockedChannelBlockedEntries[:ln-1]
			break
		}
	}

	return nil
}

// AddCreatorChannelBlockedEntries adds the given related objects to the existing relationships
// of the channel, optionally inserting them as new records.
// Appends related to o.R.CreatorChannelBlockedEntries.
// Sets related.R.CreatorChannel appropriately.
func (o *Channel) AddCreatorChannelBlockedEntries(exec boil.Executor, insert bool, related ...*BlockedEntry) error {
	var err error
	for _, rel := range related {
		if insert {
			queries.Assign(&rel.CreatorChannelID, o.ClaimID)
			if err = rel.Insert(exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		} else {
			updateQuery := fmt.Sprintf(
				"UPDATE `blocked_entry` SET %s WHERE %s",
				strmangle.SetParamNames("`", "`", 0, []string{"creator_channel_id"}),
				strmangle.WhereClause("`", "`", 0, blockedEntryPrimaryKeyColumns),
			)
			values := []interface{}{o.ClaimID, rel.ID}

			if boil.DebugMode {
				fmt.Fprintln(boil.DebugWriter, updateQuery)
				fmt.Fprintln(boil.DebugWriter, values)
			}
			if _, err = exec.Exec(updateQuery, values...); err != nil {
				return errors.Wrap(err, "failed to update foreign table")
			}

			queries.Assign(&rel.CreatorChannelID, o.ClaimID)
		}
	}

	if o.R == nil {
		o.R = &channelR{
			CreatorChannelBlockedEntries: related,
		}
	} else {
		o.R.CreatorChannelBlockedEntries = append(o.R.CreatorChannelBlockedEntries, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &blockedEntryR{
				CreatorChannel: o,
			}
		} else {
			rel.R.CreatorChannel = o
		}
	}
	return nil
}

// SetCreatorChannelBlockedEntries removes all previously related items of the
// channel replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.CreatorChannel's CreatorChannelBlockedEntries accordingly.
// Replaces o.R.CreatorChannelBlockedEntries with related.
// Sets related.R.CreatorChannel's CreatorChannelBlockedEntries accordingly.
func (o *Channel) SetCreatorChannelBlockedEntries(exec boil.Executor, insert bool, related ...*BlockedEntry) error {
	query := "update `blocked_entry` set `creator_channel_id` = null where `creator_channel_id` = ?"
	values := []interface{}{o.ClaimID}
	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, query)
		fmt.Fprintln(boil.DebugWriter, values)
	}
	_, err := exec.Exec(query, values...)
	if err != nil {
		return errors.Wrap(err, "failed to remove relationships before set")
	}

	if o.R != nil {
		for _, rel := range o.R.CreatorChannelBlockedEntries {
			queries.SetScanner(&rel.CreatorChannelID, nil)
			if rel.R == nil {
				continue
			}

			rel.R.CreatorChannel = nil
		}
		o.R.CreatorChannelBlockedEntries = nil
	}

	return o.AddCreatorChannelBlockedEntries(exec, insert, related...)
}

// RemoveCreatorChannelBlockedEntries relationships from objects passed in.
// Removes related items from R.CreatorChannelBlockedEntries (uses pointer comparison, removal does not keep order)
// Sets related.R.CreatorChannel.
func (o *Channel) RemoveCreatorChannelBlockedEntries(exec boil.Executor, related ...*BlockedEntry) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	for _, rel := range related {
		queries.SetScanner(&rel.CreatorChannelID, nil)
		if rel.R != nil {
			rel.R.CreatorChannel = nil
		}
		if err = rel.Update(exec, boil.Whitelist("creator_channel_id")); err != nil {
			return err
		}
	}
	if o.R == nil {
		return nil
	}

	for _, rel := range related {
		for i, ri := range o.R.CreatorChannelBlockedEntries {
			if rel != ri {
				continue
			}

			ln := len(o.R.CreatorChannelBlockedEntries)
			if ln > 1 && i < ln-1 {
				o.R.CreatorChannelBlockedEntries[i] = o.R.CreatorChannelBlockedEntries[ln-1]
			}
			o.R.CreatorChannelBlockedEntries = o.R.CreatorChannelBlockedEntries[:ln-1]
			break
		}
	}

	return nil
}

// AddDelegatedModeratorChannelBlockedEntries adds the given related objects to the existing relationships
// of the channel, optionally inserting them as new records.
// Appends related to o.R.DelegatedModeratorChannelBlockedEntries.
// Sets related.R.DelegatedModeratorChannel appropriately.
func (o *Channel) AddDelegatedModeratorChannelBlockedEntries(exec boil.Executor, insert bool, related ...*BlockedEntry) error {
	var err error
	for _, rel := range related {
		if insert {
			queries.Assign(&rel.DelegatedModeratorChannelID, o.ClaimID)
			if err = rel.Insert(exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		} else {
			updateQuery := fmt.Sprintf(
				"UPDATE `blocked_entry` SET %s WHERE %s",
				strmangle.SetParamNames("`", "`", 0, []string{"delegated_moderator_channel_id"}),
				strmangle.WhereClause("`", "`", 0, blockedEntryPrimaryKeyColumns),
			)
			values := []interface{}{o.ClaimID, rel.ID}

			if boil.DebugMode {
				fmt.Fprintln(boil.DebugWriter, updateQuery)
				fmt.Fprintln(boil.DebugWriter, values)
			}
			if _, err = exec.Exec(updateQuery, values...); err != nil {
				return errors.Wrap(err, "failed to update foreign table")
			}

			queries.Assign(&rel.DelegatedModeratorChannelID, o.ClaimID)
		}
	}

	if o.R == nil {
		o.R = &channelR{
			DelegatedModeratorChannelBlockedEntries: related,
		}
	} else {
		o.R.DelegatedModeratorChannelBlockedEntries = append(o.R.DelegatedModeratorChannelBlockedEntries, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &blockedEntryR{
				DelegatedModeratorChannel: o,
			}
		} else {
			rel.R.DelegatedModeratorChannel = o
		}
	}
	return nil
}

// SetDelegatedModeratorChannelBlockedEntries removes all previously related items of the
// channel replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.DelegatedModeratorChannel's DelegatedModeratorChannelBlockedEntries accordingly.
// Replaces o.R.DelegatedModeratorChannelBlockedEntries with related.
// Sets related.R.DelegatedModeratorChannel's DelegatedModeratorChannelBlockedEntries accordingly.
func (o *Channel) SetDelegatedModeratorChannelBlockedEntries(exec boil.Executor, insert bool, related ...*BlockedEntry) error {
	query := "update `blocked_entry` set `delegated_moderator_channel_id` = null where `delegated_moderator_channel_id` = ?"
	values := []interface{}{o.ClaimID}
	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, query)
		fmt.Fprintln(boil.DebugWriter, values)
	}
	_, err := exec.Exec(query, values...)
	if err != nil {
		return errors.Wrap(err, "failed to remove relationships before set")
	}

	if o.R != nil {
		for _, rel := range o.R.DelegatedModeratorChannelBlockedEntries {
			queries.SetScanner(&rel.DelegatedModeratorChannelID, nil)
			if rel.R == nil {
				continue
			}

			rel.R.DelegatedModeratorChannel = nil
		}
		o.R.DelegatedModeratorChannelBlockedEntries = nil
	}

	return o.AddDelegatedModeratorChannelBlockedEntries(exec, insert, related...)
}

// RemoveDelegatedModeratorChannelBlockedEntries relationships from objects passed in.
// Removes related items from R.DelegatedModeratorChannelBlockedEntries (uses pointer comparison, removal does not keep order)
// Sets related.R.DelegatedModeratorChannel.
func (o *Channel) RemoveDelegatedModeratorChannelBlockedEntries(exec boil.Executor, related ...*BlockedEntry) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	for _, rel := range related {
		queries.SetScanner(&rel.DelegatedModeratorChannelID, nil)
		if rel.R != nil {
			rel.R.DelegatedModeratorChannel = nil
		}
		if err = rel.Update(exec, boil.Whitelist("delegated_moderator_channel_id")); err != nil {
			return err
		}
	}
	if o.R == nil {
		return nil
	}

	for _, rel := range related {
		for i, ri := range o.R.DelegatedModeratorChannelBlockedEntries {
			if rel != ri {
				continue
			}

			ln := len(o.R.DelegatedModeratorChannelBlockedEntries)
			if ln > 1 && i < ln-1 {
				o.R.DelegatedModeratorChannelBlockedEntries[i] = o.R.DelegatedModeratorChannelBlockedEntries[ln-1]
			}
			o.R.DelegatedModeratorChannelBlockedEntries = o.R.DelegatedModeratorChannelBlockedEntries[:ln-1]
			break
		}
	}

	return nil
}

// AddBlockedLists adds the given related objects to the existing relationships
// of the channel, optionally inserting them as new records.
// Appends related to o.R.BlockedLists.
// Sets related.R.Channel appropriately.
func (o *Channel) AddBlockedLists(exec boil.Executor, insert bool, related ...*BlockedList) error {
	var err error
	for _, rel := range related {
		if insert {
			rel.ChannelID = o.ClaimID
			if err = rel.Insert(exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		} else {
			updateQuery := fmt.Sprintf(
				"UPDATE `blocked_list` SET %s WHERE %s",
				strmangle.SetParamNames("`", "`", 0, []string{"channel_id"}),
				strmangle.WhereClause("`", "`", 0, blockedListPrimaryKeyColumns),
			)
			values := []interface{}{o.ClaimID, rel.ID}

			if boil.DebugMode {
				fmt.Fprintln(boil.DebugWriter, updateQuery)
				fmt.Fprintln(boil.DebugWriter, values)
			}
			if _, err = exec.Exec(updateQuery, values...); err != nil {
				return errors.Wrap(err, "failed to update foreign table")
			}

			rel.ChannelID = o.ClaimID
		}
	}

	if o.R == nil {
		o.R = &channelR{
			BlockedLists: related,
		}
	} else {
		o.R.BlockedLists = append(o.R.BlockedLists, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &blockedListR{
				Channel: o,
			}
		} else {
			rel.R.Channel = o
		}
	}
	return nil
}

// AddInviterChannelBlockedListInvites adds the given related objects to the existing relationships
// of the channel, optionally inserting them as new records.
// Appends related to o.R.InviterChannelBlockedListInvites.
// Sets related.R.InviterChannel appropriately.
func (o *Channel) AddInviterChannelBlockedListInvites(exec boil.Executor, insert bool, related ...*BlockedListInvite) error {
	var err error
	for _, rel := range related {
		if insert {
			rel.InviterChannelID = o.ClaimID
			if err = rel.Insert(exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		} else {
			updateQuery := fmt.Sprintf(
				"UPDATE `blocked_list_invite` SET %s WHERE %s",
				strmangle.SetParamNames("`", "`", 0, []string{"inviter_channel_id"}),
				strmangle.WhereClause("`", "`", 0, blockedListInvitePrimaryKeyColumns),
			)
			values := []interface{}{o.ClaimID, rel.ID}

			if boil.DebugMode {
				fmt.Fprintln(boil.DebugWriter, updateQuery)
				fmt.Fprintln(boil.DebugWriter, values)
			}
			if _, err = exec.Exec(updateQuery, values...); err != nil {
				return errors.Wrap(err, "failed to update foreign table")
			}

			rel.InviterChannelID = o.ClaimID
		}
	}

	if o.R == nil {
		o.R = &channelR{
			InviterChannelBlockedListInvites: related,
		}
	} else {
		o.R.InviterChannelBlockedListInvites = append(o.R.InviterChannelBlockedListInvites, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &blockedListInviteR{
				InviterChannel: o,
			}
		} else {
			rel.R.InviterChannel = o
		}
	}
	return nil
}

// AddInvitedChannelBlockedListInvites adds the given related objects to the existing relationships
// of the channel, optionally inserting them as new records.
// Appends related to o.R.InvitedChannelBlockedListInvites.
// Sets related.R.InvitedChannel appropriately.
func (o *Channel) AddInvitedChannelBlockedListInvites(exec boil.Executor, insert bool, related ...*BlockedListInvite) error {
	var err error
	for _, rel := range related {
		if insert {
			rel.InvitedChannelID = o.ClaimID
			if err = rel.Insert(exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		} else {
			updateQuery := fmt.Sprintf(
				"UPDATE `blocked_list_invite` SET %s WHERE %s",
				strmangle.SetParamNames("`", "`", 0, []string{"invited_channel_id"}),
				strmangle.WhereClause("`", "`", 0, blockedListInvitePrimaryKeyColumns),
			)
			values := []interface{}{o.ClaimID, rel.ID}

			if boil.DebugMode {
				fmt.Fprintln(boil.DebugWriter, updateQuery)
				fmt.Fprintln(boil.DebugWriter, values)
			}
			if _, err = exec.Exec(updateQuery, values...); err != nil {
				return errors.Wrap(err, "failed to update foreign table")
			}

			rel.InvitedChannelID = o.ClaimID
		}
	}

	if o.R == nil {
		o.R = &channelR{
			InvitedChannelBlockedListInvites: related,
		}
	} else {
		o.R.InvitedChannelBlockedListInvites = append(o.R.InvitedChannelBlockedListInvites, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &blockedListInviteR{
				InvitedChannel: o,
			}
		} else {
			rel.R.InvitedChannel = o
		}
	}
	return nil
}

// AddComments adds the given related objects to the existing relationships
// of the channel, optionally inserting them as new records.
// Appends related to o.R.Comments.
// Sets related.R.Channel appropriately.
func (o *Channel) AddComments(exec boil.Executor, insert bool, related ...*Comment) error {
	var err error
	for _, rel := range related {
		if insert {
			queries.Assign(&rel.ChannelID, o.ClaimID)
			if err = rel.Insert(exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		} else {
			updateQuery := fmt.Sprintf(
				"UPDATE `comment` SET %s WHERE %s",
				strmangle.SetParamNames("`", "`", 0, []string{"channel_id"}),
				strmangle.WhereClause("`", "`", 0, commentPrimaryKeyColumns),
			)
			values := []interface{}{o.ClaimID, rel.CommentID}

			if boil.DebugMode {
				fmt.Fprintln(boil.DebugWriter, updateQuery)
				fmt.Fprintln(boil.DebugWriter, values)
			}
			if _, err = exec.Exec(updateQuery, values...); err != nil {
				return errors.Wrap(err, "failed to update foreign table")
			}

			queries.Assign(&rel.ChannelID, o.ClaimID)
		}
	}

	if o.R == nil {
		o.R = &channelR{
			Comments: related,
		}
	} else {
		o.R.Comments = append(o.R.Comments, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &commentR{
				Channel: o,
			}
		} else {
			rel.R.Channel = o
		}
	}
	return nil
}

// SetComments removes all previously related items of the
// channel replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Channel's Comments accordingly.
// Replaces o.R.Comments with related.
// Sets related.R.Channel's Comments accordingly.
func (o *Channel) SetComments(exec boil.Executor, insert bool, related ...*Comment) error {
	query := "update `comment` set `channel_id` = null where `channel_id` = ?"
	values := []interface{}{o.ClaimID}
	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, query)
		fmt.Fprintln(boil.DebugWriter, values)
	}
	_, err := exec.Exec(query, values...)
	if err != nil {
		return errors.Wrap(err, "failed to remove relationships before set")
	}

	if o.R != nil {
		for _, rel := range o.R.Comments {
			queries.SetScanner(&rel.ChannelID, nil)
			if rel.R == nil {
				continue
			}

			rel.R.Channel = nil
		}
		o.R.Comments = nil
	}

	return o.AddComments(exec, insert, related...)
}

// RemoveComments relationships from objects passed in.
// Removes related items from R.Comments (uses pointer comparison, removal does not keep order)
// Sets related.R.Channel.
func (o *Channel) RemoveComments(exec boil.Executor, related ...*Comment) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	for _, rel := range related {
		queries.SetScanner(&rel.ChannelID, nil)
		if rel.R != nil {
			rel.R.Channel = nil
		}
		if err = rel.Update(exec, boil.Whitelist("channel_id")); err != nil {
			return err
		}
	}
	if o.R == nil {
		return nil
	}

	for _, rel := range related {
		for i, ri := range o.R.Comments {
			if rel != ri {
				continue
			}

			ln := len(o.R.Comments)
			if ln > 1 && i < ln-1 {
				o.R.Comments[i] = o.R.Comments[ln-1]
			}
			o.R.Comments = o.R.Comments[:ln-1]
			break
		}
	}

	return nil
}

// AddCreatorChannelCreatorSettings adds the given related objects to the existing relationships
// of the channel, optionally inserting them as new records.
// Appends related to o.R.CreatorChannelCreatorSettings.
// Sets related.R.CreatorChannel appropriately.
func (o *Channel) AddCreatorChannelCreatorSettings(exec boil.Executor, insert bool, related ...*CreatorSetting) error {
	var err error
	for _, rel := range related {
		if insert {
			rel.CreatorChannelID = o.ClaimID
			if err = rel.Insert(exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		} else {
			updateQuery := fmt.Sprintf(
				"UPDATE `creator_setting` SET %s WHERE %s",
				strmangle.SetParamNames("`", "`", 0, []string{"creator_channel_id"}),
				strmangle.WhereClause("`", "`", 0, creatorSettingPrimaryKeyColumns),
			)
			values := []interface{}{o.ClaimID, rel.ID}

			if boil.DebugMode {
				fmt.Fprintln(boil.DebugWriter, updateQuery)
				fmt.Fprintln(boil.DebugWriter, values)
			}
			if _, err = exec.Exec(updateQuery, values...); err != nil {
				return errors.Wrap(err, "failed to update foreign table")
			}

			rel.CreatorChannelID = o.ClaimID
		}
	}

	if o.R == nil {
		o.R = &channelR{
			CreatorChannelCreatorSettings: related,
		}
	} else {
		o.R.CreatorChannelCreatorSettings = append(o.R.CreatorChannelCreatorSettings, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &creatorSettingR{
				CreatorChannel: o,
			}
		} else {
			rel.R.CreatorChannel = o
		}
	}
	return nil
}

// AddModChannelDelegatedModerators adds the given related objects to the existing relationships
// of the channel, optionally inserting them as new records.
// Appends related to o.R.ModChannelDelegatedModerators.
// Sets related.R.ModChannel appropriately.
func (o *Channel) AddModChannelDelegatedModerators(exec boil.Executor, insert bool, related ...*DelegatedModerator) error {
	var err error
	for _, rel := range related {
		if insert {
			rel.ModChannelID = o.ClaimID
			if err = rel.Insert(exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		} else {
			updateQuery := fmt.Sprintf(
				"UPDATE `delegated_moderator` SET %s WHERE %s",
				strmangle.SetParamNames("`", "`", 0, []string{"mod_channel_id"}),
				strmangle.WhereClause("`", "`", 0, delegatedModeratorPrimaryKeyColumns),
			)
			values := []interface{}{o.ClaimID, rel.ID}

			if boil.DebugMode {
				fmt.Fprintln(boil.DebugWriter, updateQuery)
				fmt.Fprintln(boil.DebugWriter, values)
			}
			if _, err = exec.Exec(updateQuery, values...); err != nil {
				return errors.Wrap(err, "failed to update foreign table")
			}

			rel.ModChannelID = o.ClaimID
		}
	}

	if o.R == nil {
		o.R = &channelR{
			ModChannelDelegatedModerators: related,
		}
	} else {
		o.R.ModChannelDelegatedModerators = append(o.R.ModChannelDelegatedModerators, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &delegatedModeratorR{
				ModChannel: o,
			}
		} else {
			rel.R.ModChannel = o
		}
	}
	return nil
}

// AddCreatorChannelDelegatedModerators adds the given related objects to the existing relationships
// of the channel, optionally inserting them as new records.
// Appends related to o.R.CreatorChannelDelegatedModerators.
// Sets related.R.CreatorChannel appropriately.
func (o *Channel) AddCreatorChannelDelegatedModerators(exec boil.Executor, insert bool, related ...*DelegatedModerator) error {
	var err error
	for _, rel := range related {
		if insert {
			rel.CreatorChannelID = o.ClaimID
			if err = rel.Insert(exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		} else {
			updateQuery := fmt.Sprintf(
				"UPDATE `delegated_moderator` SET %s WHERE %s",
				strmangle.SetParamNames("`", "`", 0, []string{"creator_channel_id"}),
				strmangle.WhereClause("`", "`", 0, delegatedModeratorPrimaryKeyColumns),
			)
			values := []interface{}{o.ClaimID, rel.ID}

			if boil.DebugMode {
				fmt.Fprintln(boil.DebugWriter, updateQuery)
				fmt.Fprintln(boil.DebugWriter, values)
			}
			if _, err = exec.Exec(updateQuery, values...); err != nil {
				return errors.Wrap(err, "failed to update foreign table")
			}

			rel.CreatorChannelID = o.ClaimID
		}
	}

	if o.R == nil {
		o.R = &channelR{
			CreatorChannelDelegatedModerators: related,
		}
	} else {
		o.R.CreatorChannelDelegatedModerators = append(o.R.CreatorChannelDelegatedModerators, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &delegatedModeratorR{
				CreatorChannel: o,
			}
		} else {
			rel.R.CreatorChannel = o
		}
	}
	return nil
}

// AddModChannelModerators adds the given related objects to the existing relationships
// of the channel, optionally inserting them as new records.
// Appends related to o.R.ModChannelModerators.
// Sets related.R.ModChannel appropriately.
func (o *Channel) AddModChannelModerators(exec boil.Executor, insert bool, related ...*Moderator) error {
	var err error
	for _, rel := range related {
		if insert {
			queries.Assign(&rel.ModChannelID, o.ClaimID)
			if err = rel.Insert(exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		} else {
			updateQuery := fmt.Sprintf(
				"UPDATE `moderator` SET %s WHERE %s",
				strmangle.SetParamNames("`", "`", 0, []string{"mod_channel_id"}),
				strmangle.WhereClause("`", "`", 0, moderatorPrimaryKeyColumns),
			)
			values := []interface{}{o.ClaimID, rel.ID}

			if boil.DebugMode {
				fmt.Fprintln(boil.DebugWriter, updateQuery)
				fmt.Fprintln(boil.DebugWriter, values)
			}
			if _, err = exec.Exec(updateQuery, values...); err != nil {
				return errors.Wrap(err, "failed to update foreign table")
			}

			queries.Assign(&rel.ModChannelID, o.ClaimID)
		}
	}

	if o.R == nil {
		o.R = &channelR{
			ModChannelModerators: related,
		}
	} else {
		o.R.ModChannelModerators = append(o.R.ModChannelModerators, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &moderatorR{
				ModChannel: o,
			}
		} else {
			rel.R.ModChannel = o
		}
	}
	return nil
}

// SetModChannelModerators removes all previously related items of the
// channel replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.ModChannel's ModChannelModerators accordingly.
// Replaces o.R.ModChannelModerators with related.
// Sets related.R.ModChannel's ModChannelModerators accordingly.
func (o *Channel) SetModChannelModerators(exec boil.Executor, insert bool, related ...*Moderator) error {
	query := "update `moderator` set `mod_channel_id` = null where `mod_channel_id` = ?"
	values := []interface{}{o.ClaimID}
	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, query)
		fmt.Fprintln(boil.DebugWriter, values)
	}
	_, err := exec.Exec(query, values...)
	if err != nil {
		return errors.Wrap(err, "failed to remove relationships before set")
	}

	if o.R != nil {
		for _, rel := range o.R.ModChannelModerators {
			queries.SetScanner(&rel.ModChannelID, nil)
			if rel.R == nil {
				continue
			}

			rel.R.ModChannel = nil
		}
		o.R.ModChannelModerators = nil
	}

	return o.AddModChannelModerators(exec, insert, related...)
}

// RemoveModChannelModerators relationships from objects passed in.
// Removes related items from R.ModChannelModerators (uses pointer comparison, removal does not keep order)
// Sets related.R.ModChannel.
func (o *Channel) RemoveModChannelModerators(exec boil.Executor, related ...*Moderator) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	for _, rel := range related {
		queries.SetScanner(&rel.ModChannelID, nil)
		if rel.R != nil {
			rel.R.ModChannel = nil
		}
		if err = rel.Update(exec, boil.Whitelist("mod_channel_id")); err != nil {
			return err
		}
	}
	if o.R == nil {
		return nil
	}

	for _, rel := range related {
		for i, ri := range o.R.ModChannelModerators {
			if rel != ri {
				continue
			}

			ln := len(o.R.ModChannelModerators)
			if ln > 1 && i < ln-1 {
				o.R.ModChannelModerators[i] = o.R.ModChannelModerators[ln-1]
			}
			o.R.ModChannelModerators = o.R.ModChannelModerators[:ln-1]
			break
		}
	}

	return nil
}

// AddReactions adds the given related objects to the existing relationships
// of the channel, optionally inserting them as new records.
// Appends related to o.R.Reactions.
// Sets related.R.Channel appropriately.
func (o *Channel) AddReactions(exec boil.Executor, insert bool, related ...*Reaction) error {
	var err error
	for _, rel := range related {
		if insert {
			queries.Assign(&rel.ChannelID, o.ClaimID)
			if err = rel.Insert(exec, boil.Infer()); err != nil {
				return errors.Wrap(err, "failed to insert into foreign table")
			}
		} else {
			updateQuery := fmt.Sprintf(
				"UPDATE `reaction` SET %s WHERE %s",
				strmangle.SetParamNames("`", "`", 0, []string{"channel_id"}),
				strmangle.WhereClause("`", "`", 0, reactionPrimaryKeyColumns),
			)
			values := []interface{}{o.ClaimID, rel.ID}

			if boil.DebugMode {
				fmt.Fprintln(boil.DebugWriter, updateQuery)
				fmt.Fprintln(boil.DebugWriter, values)
			}
			if _, err = exec.Exec(updateQuery, values...); err != nil {
				return errors.Wrap(err, "failed to update foreign table")
			}

			queries.Assign(&rel.ChannelID, o.ClaimID)
		}
	}

	if o.R == nil {
		o.R = &channelR{
			Reactions: related,
		}
	} else {
		o.R.Reactions = append(o.R.Reactions, related...)
	}

	for _, rel := range related {
		if rel.R == nil {
			rel.R = &reactionR{
				Channel: o,
			}
		} else {
			rel.R.Channel = o
		}
	}
	return nil
}

// SetReactions removes all previously related items of the
// channel replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Channel's Reactions accordingly.
// Replaces o.R.Reactions with related.
// Sets related.R.Channel's Reactions accordingly.
func (o *Channel) SetReactions(exec boil.Executor, insert bool, related ...*Reaction) error {
	query := "update `reaction` set `channel_id` = null where `channel_id` = ?"
	values := []interface{}{o.ClaimID}
	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, query)
		fmt.Fprintln(boil.DebugWriter, values)
	}
	_, err := exec.Exec(query, values...)
	if err != nil {
		return errors.Wrap(err, "failed to remove relationships before set")
	}

	if o.R != nil {
		for _, rel := range o.R.Reactions {
			queries.SetScanner(&rel.ChannelID, nil)
			if rel.R == nil {
				continue
			}

			rel.R.Channel = nil
		}
		o.R.Reactions = nil
	}

	return o.AddReactions(exec, insert, related...)
}

// RemoveReactions relationships from objects passed in.
// Removes related items from R.Reactions (uses pointer comparison, removal does not keep order)
// Sets related.R.Channel.
func (o *Channel) RemoveReactions(exec boil.Executor, related ...*Reaction) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	for _, rel := range related {
		queries.SetScanner(&rel.ChannelID, nil)
		if rel.R != nil {
			rel.R.Channel = nil
		}
		if err = rel.Update(exec, boil.Whitelist("channel_id")); err != nil {
			return err
		}
	}
	if o.R == nil {
		return nil
	}

	for _, rel := range related {
		for i, ri := range o.R.Reactions {
			if rel != ri {
				continue
			}

			ln := len(o.R.Reactions)
			if ln > 1 && i < ln-1 {
				o.R.Reactions[i] = o.R.Reactions[ln-1]
			}
			o.R.Reactions = o.R.Reactions[:ln-1]
			break
		}
	}

	return nil
}

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

	return channelQuery{q}
}

// FindChannel retrieves a single record by ID with an executor.
// If selectCols is empty Find will return all columns.
func FindChannel(exec boil.Executor, claimID string, selectCols ...string) (*Channel, error) {
	channelObj := &Channel{}

	sel := "*"
	if len(selectCols) > 0 {
		sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",")
	}
	query := fmt.Sprintf(
		"select %s from `channel` where `claim_id`=?", sel,
	)

	q := queries.Raw(query, claimID)

	err := q.Bind(nil, exec, channelObj)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, sql.ErrNoRows
		}
		return nil, errors.Wrap(err, "model: unable to select from channel")
	}

	return channelObj, nil
}

// Insert a single record using an executor.
// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.
func (o *Channel) Insert(exec boil.Executor, columns boil.Columns) error {
	if o == nil {
		return errors.New("model: no channel provided for insertion")
	}

	var err error

	nzDefaults := queries.NonZeroDefaultSet(channelColumnsWithDefault, o)

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

	if !cached {
		wl, returnColumns := columns.InsertColumnSet(
			channelAllColumns,
			channelColumnsWithDefault,
			channelColumnsWithoutDefault,
			nzDefaults,
		)

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

		var queryOutput, queryReturning string

		if len(cache.retMapping) != 0 {
			cache.retQuery = fmt.Sprintf("SELECT `%s` FROM `channel` WHERE %s", strings.Join(returnColumns, "`,`"), strmangle.WhereClause("`", "`", 0, channelPrimaryKeyColumns))
		}

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

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

	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, cache.query)
		fmt.Fprintln(boil.DebugWriter, vals)
	}
	_, err = exec.Exec(cache.query, vals...)

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

	var identifierCols []interface{}

	if len(cache.retMapping) == 0 {
		goto CacheNoHooks
	}

	identifierCols = []interface{}{
		o.ClaimID,
	}

	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, cache.retQuery)
		fmt.Fprintln(boil.DebugWriter, identifierCols...)
	}
	err = exec.QueryRow(cache.retQuery, identifierCols...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...)
	if err != nil {
		return errors.Wrap(err, "model: unable to populate default values for channel")
	}

CacheNoHooks:
	if !cached {
		channelInsertCacheMut.Lock()
		channelInsertCache[key] = cache
		channelInsertCacheMut.Unlock()
	}

	return nil
}

// Update uses an executor to update the Channel.
// 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 *Channel) Update(exec boil.Executor, columns boil.Columns) error {
	var err error
	key := makeCacheKey(columns, nil)
	channelUpdateCacheMut.RLock()
	cache, cached := channelUpdateCache[key]
	channelUpdateCacheMut.RUnlock()

	if !cached {
		wl := columns.UpdateColumnSet(
			channelAllColumns,
			channelPrimaryKeyColumns,
		)
		if len(wl) == 0 {
			return errors.New("model: unable to update channel, could not build whitelist")
		}

		cache.query = fmt.Sprintf("UPDATE `channel` SET %s WHERE %s",
			strmangle.SetParamNames("`", "`", 0, wl),
			strmangle.WhereClause("`", "`", 0, channelPrimaryKeyColumns),
		)
		cache.valueMapping, err = queries.BindMapping(channelType, channelMapping, append(wl, channelPrimaryKeyColumns...))
		if err != nil {
			return err
		}
	}

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

	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, cache.query)
		fmt.Fprintln(boil.DebugWriter, values)
	}
	_, err = exec.Exec(cache.query, values...)
	if err != nil {
		return errors.Wrap(err, "model: unable to update channel row")
	}

	if !cached {
		channelUpdateCacheMut.Lock()
		channelUpdateCache[key] = cache
		channelUpdateCacheMut.Unlock()
	}

	return nil
}

// UpdateAll updates all rows with the specified column values.
func (q channelQuery) UpdateAll(exec boil.Executor, cols M) error {
	queries.SetUpdate(q.Query, cols)

	_, err := q.Query.Exec(exec)
	if err != nil {
		return errors.Wrap(err, "model: unable to update all for channel")
	}

	return nil
}

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

	if len(cols) == 0 {
		return errors.New("model: 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)), channelPrimaryKeyMapping)
		args = append(args, pkeyArgs...)
	}

	sql := fmt.Sprintf("UPDATE `channel` SET %s WHERE %s",
		strmangle.SetParamNames("`", "`", 0, colNames),
		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, channelPrimaryKeyColumns, len(o)))

	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, sql)
		fmt.Fprintln(boil.DebugWriter, args...)
	}
	_, err := exec.Exec(sql, args...)
	if err != nil {
		return errors.Wrap(err, "model: unable to update all in channel slice")
	}

	return nil
}

var mySQLChannelUniqueColumns = []string{
	"claim_id",
}

// 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 *Channel) Upsert(exec boil.Executor, updateColumns, insertColumns boil.Columns) error {
	if o == nil {
		return errors.New("model: no channel provided for upsert")
	}

	nzDefaults := queries.NonZeroDefaultSet(channelColumnsWithDefault, o)
	nzUniques := queries.NonZeroDefaultSet(mySQLChannelUniqueColumns, o)

	if len(nzUniques) == 0 {
		return errors.New("cannot upsert with a table that cannot conflict on a unique column")
	}

	// Build cache key in-line uglily - mysql vs psql problems
	buf := strmangle.GetBuffer()
	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)
	}
	buf.WriteByte('.')
	for _, c := range nzUniques {
		buf.WriteString(c)
	}
	key := buf.String()
	strmangle.PutBuffer(buf)

	channelUpsertCacheMut.RLock()
	cache, cached := channelUpsertCache[key]
	channelUpsertCacheMut.RUnlock()

	var err error

	if !cached {
		insert, _ := insertColumns.InsertColumnSet(
			channelAllColumns,
			channelColumnsWithDefault,
			channelColumnsWithoutDefault,
			nzDefaults,
		)

		update := updateColumns.UpdateColumnSet(
			channelAllColumns,
			channelPrimaryKeyColumns,
		)

		if !updateColumns.IsNone() && len(update) == 0 {
			return errors.New("model: unable to upsert channel, could not build update column list")
		}

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

		cache.query = buildUpsertQueryMySQL(dialect, "`channel`", update, insert)
		cache.retQuery = fmt.Sprintf(
			"SELECT %s FROM `channel` WHERE %s",
			strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, ret), ","),
			strmangle.WhereClause("`", "`", 0, nzUniques),
		)

		cache.valueMapping, err = queries.BindMapping(channelType, channelMapping, insert)
		if err != nil {
			return err
		}
		if len(ret) != 0 {
			cache.retMapping, err = queries.BindMapping(channelType, channelMapping, 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.DebugMode {
		fmt.Fprintln(boil.DebugWriter, cache.query)
		fmt.Fprintln(boil.DebugWriter, vals)
	}
	_, err = exec.Exec(cache.query, vals...)

	if err != nil {
		return errors.Wrap(err, "model: unable to upsert for channel")
	}

	var uniqueMap []uint64
	var nzUniqueCols []interface{}

	if len(cache.retMapping) == 0 {
		goto CacheNoHooks
	}

	uniqueMap, err = queries.BindMapping(channelType, channelMapping, nzUniques)
	if err != nil {
		return errors.Wrap(err, "model: unable to retrieve unique values for channel")
	}
	nzUniqueCols = queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), uniqueMap)

	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, cache.retQuery)
		fmt.Fprintln(boil.DebugWriter, nzUniqueCols...)
	}
	err = exec.QueryRow(cache.retQuery, nzUniqueCols...).Scan(returns...)
	if err != nil {
		return errors.Wrap(err, "model: unable to populate default values for channel")
	}

CacheNoHooks:
	if !cached {
		channelUpsertCacheMut.Lock()
		channelUpsertCache[key] = cache
		channelUpsertCacheMut.Unlock()
	}

	return nil
}

// Delete deletes a single Channel record with an executor.
// Delete will match against the primary key column to find the record to delete.
func (o *Channel) Delete(exec boil.Executor) error {
	if o == nil {
		return errors.New("model: no Channel provided for delete")
	}

	args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), channelPrimaryKeyMapping)
	sql := "DELETE FROM `channel` WHERE `claim_id`=?"

	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, sql)
		fmt.Fprintln(boil.DebugWriter, args...)
	}
	_, err := exec.Exec(sql, args...)
	if err != nil {
		return errors.Wrap(err, "model: unable to delete from channel")
	}

	return nil
}

// DeleteAll deletes all matching rows.
func (q channelQuery) DeleteAll(exec boil.Executor) error {
	if q.Query == nil {
		return errors.New("model: no channelQuery provided for delete all")
	}

	queries.SetDelete(q.Query)

	_, err := q.Query.Exec(exec)
	if err != nil {
		return errors.Wrap(err, "model: unable to delete all from channel")
	}

	return nil
}

// DeleteAll deletes all rows in the slice, using an executor.
func (o ChannelSlice) DeleteAll(exec boil.Executor) error {
	if len(o) == 0 {
		return nil
	}

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

	sql := "DELETE FROM `channel` WHERE " +
		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, channelPrimaryKeyColumns, len(o))

	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, sql)
		fmt.Fprintln(boil.DebugWriter, args)
	}
	_, err := exec.Exec(sql, args...)
	if err != nil {
		return errors.Wrap(err, "model: unable to delete all from channel slice")
	}

	return nil
}

// Reload refetches the object from the database
// using the primary keys with an executor.
func (o *Channel) Reload(exec boil.Executor) error {
	ret, err := FindChannel(exec, o.ClaimID)
	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 *ChannelSlice) ReloadAll(exec boil.Executor) error {
	if o == nil || len(*o) == 0 {
		return nil
	}

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

	sql := "SELECT `channel`.* FROM `channel` WHERE " +
		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, channelPrimaryKeyColumns, len(*o))

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

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

	*o = slice

	return nil
}

// ChannelExists checks if the Channel row exists.
func ChannelExists(exec boil.Executor, claimID string) (bool, error) {
	var exists bool
	sql := "select exists(select 1 from `channel` where `claim_id`=? limit 1)"

	if boil.DebugMode {
		fmt.Fprintln(boil.DebugWriter, sql)
		fmt.Fprintln(boil.DebugWriter, claimID)
	}
	row := exec.QueryRow(sql, claimID)

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

	return exists, nil
}

// Exists checks if the Channel row exists.
func (o *Channel) Exists(exec boil.Executor) (bool, error) {
	return ChannelExists(exec, o.ClaimID)
}