importer/kmedia/kmodels/containers.go
// Code generated by SQLBoiler (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 kmodels
import (
"bytes"
"database/sql"
"fmt"
"reflect"
"strings"
"sync"
"time"
"github.com/pkg/errors"
"github.com/volatiletech/sqlboiler/boil"
"github.com/volatiletech/sqlboiler/queries"
"github.com/volatiletech/sqlboiler/queries/qm"
"github.com/volatiletech/sqlboiler/strmangle"
"gopkg.in/volatiletech/null.v6"
)
// Container is an object representing the database table.
type Container struct {
ID int `boil:"id" json:"id" toml:"id" yaml:"id"`
Name null.String `boil:"name" json:"name,omitempty" toml:"name" yaml:"name,omitempty"`
CreatedAt null.Time `boil:"created_at" json:"created_at,omitempty" toml:"created_at" yaml:"created_at,omitempty"`
UpdatedAt null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
Filmdate null.Time `boil:"filmdate" json:"filmdate,omitempty" toml:"filmdate" yaml:"filmdate,omitempty"`
LangID null.String `boil:"lang_id" json:"lang_id,omitempty" toml:"lang_id" yaml:"lang_id,omitempty"`
LecturerID null.Int `boil:"lecturer_id" json:"lecturer_id,omitempty" toml:"lecturer_id" yaml:"lecturer_id,omitempty"`
Secure int `boil:"secure" json:"secure" toml:"secure" yaml:"secure"`
ContentTypeID null.Int `boil:"content_type_id" json:"content_type_id,omitempty" toml:"content_type_id" yaml:"content_type_id,omitempty"`
MarkedForMerge null.Bool `boil:"marked_for_merge" json:"marked_for_merge,omitempty" toml:"marked_for_merge" yaml:"marked_for_merge,omitempty"`
SecureChanged null.Bool `boil:"secure_changed" json:"secure_changed,omitempty" toml:"secure_changed" yaml:"secure_changed,omitempty"`
AutoParsed null.Bool `boil:"auto_parsed" json:"auto_parsed,omitempty" toml:"auto_parsed" yaml:"auto_parsed,omitempty"`
VirtualLessonID null.Int `boil:"virtual_lesson_id" json:"virtual_lesson_id,omitempty" toml:"virtual_lesson_id" yaml:"virtual_lesson_id,omitempty"`
PlaytimeSecs null.Int `boil:"playtime_secs" json:"playtime_secs,omitempty" toml:"playtime_secs" yaml:"playtime_secs,omitempty"`
UserID null.Int `boil:"user_id" json:"user_id,omitempty" toml:"user_id" yaml:"user_id,omitempty"`
ForCensorship null.Bool `boil:"for_censorship" json:"for_censorship,omitempty" toml:"for_censorship" yaml:"for_censorship,omitempty"`
OpenedByCensor null.Bool `boil:"opened_by_censor" json:"opened_by_censor,omitempty" toml:"opened_by_censor" yaml:"opened_by_censor,omitempty"`
ClosedByCensor null.Bool `boil:"closed_by_censor" json:"closed_by_censor,omitempty" toml:"closed_by_censor" yaml:"closed_by_censor,omitempty"`
CensorID null.Int `boil:"censor_id" json:"censor_id,omitempty" toml:"censor_id" yaml:"censor_id,omitempty"`
Position null.Int `boil:"position" json:"position,omitempty" toml:"position" yaml:"position,omitempty"`
R *containerR `boil:"-" json:"-" toml:"-" yaml:"-"`
L containerL `boil:"-" json:"-" toml:"-" yaml:"-"`
}
var ContainerColumns = struct {
ID string
Name string
CreatedAt string
UpdatedAt string
Filmdate string
LangID string
LecturerID string
Secure string
ContentTypeID string
MarkedForMerge string
SecureChanged string
AutoParsed string
VirtualLessonID string
PlaytimeSecs string
UserID string
ForCensorship string
OpenedByCensor string
ClosedByCensor string
CensorID string
Position string
}{
ID: "id",
Name: "name",
CreatedAt: "created_at",
UpdatedAt: "updated_at",
Filmdate: "filmdate",
LangID: "lang_id",
LecturerID: "lecturer_id",
Secure: "secure",
ContentTypeID: "content_type_id",
MarkedForMerge: "marked_for_merge",
SecureChanged: "secure_changed",
AutoParsed: "auto_parsed",
VirtualLessonID: "virtual_lesson_id",
PlaytimeSecs: "playtime_secs",
UserID: "user_id",
ForCensorship: "for_censorship",
OpenedByCensor: "opened_by_censor",
ClosedByCensor: "closed_by_censor",
CensorID: "censor_id",
Position: "position",
}
// containerR is where relationships are stored.
type containerR struct {
ContentType *ContentType
Lang *Language
VirtualLesson *VirtualLesson
Catalogs CatalogSlice
ContainerDescriptions ContainerDescriptionSlice
FileAssets FileAssetSlice
Labels LabelSlice
}
// containerL is where Load methods for each relationship are stored.
type containerL struct{}
var (
containerColumns = []string{"id", "name", "created_at", "updated_at", "filmdate", "lang_id", "lecturer_id", "secure", "content_type_id", "marked_for_merge", "secure_changed", "auto_parsed", "virtual_lesson_id", "playtime_secs", "user_id", "for_censorship", "opened_by_censor", "closed_by_censor", "censor_id", "position"}
containerColumnsWithoutDefault = []string{"name", "created_at", "updated_at", "filmdate", "lang_id", "lecturer_id", "content_type_id", "marked_for_merge", "virtual_lesson_id", "playtime_secs", "user_id", "censor_id", "position"}
containerColumnsWithDefault = []string{"id", "secure", "secure_changed", "auto_parsed", "for_censorship", "opened_by_censor", "closed_by_censor"}
containerPrimaryKeyColumns = []string{"id"}
)
type (
// ContainerSlice is an alias for a slice of pointers to Container.
// This should generally be used opposed to []Container.
ContainerSlice []*Container
containerQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
containerType = reflect.TypeOf(&Container{})
containerMapping = queries.MakeStructMapping(containerType)
containerPrimaryKeyMapping, _ = queries.BindMapping(containerType, containerMapping, containerPrimaryKeyColumns)
containerInsertCacheMut sync.RWMutex
containerInsertCache = make(map[string]insertCache)
containerUpdateCacheMut sync.RWMutex
containerUpdateCache = make(map[string]updateCache)
containerUpsertCacheMut sync.RWMutex
containerUpsertCache = make(map[string]insertCache)
)
var (
// Force time package dependency for automated UpdatedAt/CreatedAt.
_ = time.Second
// Force bytes in case of primary key column that uses []byte (for relationship compares)
_ = bytes.MinRead
)
// OneP returns a single container record from the query, and panics on error.
func (q containerQuery) OneP() *Container {
o, err := q.One()
if err != nil {
panic(boil.WrapErr(err))
}
return o
}
// One returns a single container record from the query.
func (q containerQuery) One() (*Container, error) {
o := &Container{}
queries.SetLimit(q.Query, 1)
err := q.Bind(o)
if err != nil {
if errors.Cause(err) == sql.ErrNoRows {
return nil, sql.ErrNoRows
}
return nil, errors.Wrap(err, "kmodels: failed to execute a one query for containers")
}
return o, nil
}
// AllP returns all Container records from the query, and panics on error.
func (q containerQuery) AllP() ContainerSlice {
o, err := q.All()
if err != nil {
panic(boil.WrapErr(err))
}
return o
}
// All returns all Container records from the query.
func (q containerQuery) All() (ContainerSlice, error) {
var o []*Container
err := q.Bind(&o)
if err != nil {
return nil, errors.Wrap(err, "kmodels: failed to assign all query results to Container slice")
}
return o, nil
}
// CountP returns the count of all Container records in the query, and panics on error.
func (q containerQuery) CountP() int64 {
c, err := q.Count()
if err != nil {
panic(boil.WrapErr(err))
}
return c
}
// Count returns the count of all Container records in the query.
func (q containerQuery) Count() (int64, error) {
var count int64
queries.SetSelect(q.Query, nil)
queries.SetCount(q.Query)
err := q.Query.QueryRow().Scan(&count)
if err != nil {
return 0, errors.Wrap(err, "kmodels: failed to count containers rows")
}
return count, nil
}
// Exists checks if the row exists in the table, and panics on error.
func (q containerQuery) ExistsP() bool {
e, err := q.Exists()
if err != nil {
panic(boil.WrapErr(err))
}
return e
}
// Exists checks if the row exists in the table.
func (q containerQuery) Exists() (bool, error) {
var count int64
queries.SetCount(q.Query)
queries.SetLimit(q.Query, 1)
err := q.Query.QueryRow().Scan(&count)
if err != nil {
return false, errors.Wrap(err, "kmodels: failed to check if containers exists")
}
return count > 0, nil
}
// ContentTypeG pointed to by the foreign key.
func (o *Container) ContentTypeG(mods ...qm.QueryMod) contentTypeQuery {
return o.ContentType(boil.GetDB(), mods...)
}
// ContentType pointed to by the foreign key.
func (o *Container) ContentType(exec boil.Executor, mods ...qm.QueryMod) contentTypeQuery {
queryMods := []qm.QueryMod{
qm.Where("id=?", o.ContentTypeID),
}
queryMods = append(queryMods, mods...)
query := ContentTypes(exec, queryMods...)
queries.SetFrom(query.Query, "\"content_types\"")
return query
}
// LangG pointed to by the foreign key.
func (o *Container) LangG(mods ...qm.QueryMod) languageQuery {
return o.Lang(boil.GetDB(), mods...)
}
// Lang pointed to by the foreign key.
func (o *Container) Lang(exec boil.Executor, mods ...qm.QueryMod) languageQuery {
queryMods := []qm.QueryMod{
qm.Where("code3=?", o.LangID),
}
queryMods = append(queryMods, mods...)
query := Languages(exec, queryMods...)
queries.SetFrom(query.Query, "\"languages\"")
return query
}
// VirtualLessonG pointed to by the foreign key.
func (o *Container) VirtualLessonG(mods ...qm.QueryMod) virtualLessonQuery {
return o.VirtualLesson(boil.GetDB(), mods...)
}
// VirtualLesson pointed to by the foreign key.
func (o *Container) VirtualLesson(exec boil.Executor, mods ...qm.QueryMod) virtualLessonQuery {
queryMods := []qm.QueryMod{
qm.Where("id=?", o.VirtualLessonID),
}
queryMods = append(queryMods, mods...)
query := VirtualLessons(exec, queryMods...)
queries.SetFrom(query.Query, "\"virtual_lessons\"")
return query
}
// CatalogsG retrieves all the catalog's catalogs.
func (o *Container) CatalogsG(mods ...qm.QueryMod) catalogQuery {
return o.Catalogs(boil.GetDB(), mods...)
}
// Catalogs retrieves all the catalog's catalogs with an executor.
func (o *Container) Catalogs(exec boil.Executor, mods ...qm.QueryMod) catalogQuery {
var queryMods []qm.QueryMod
if len(mods) != 0 {
queryMods = append(queryMods, mods...)
}
queryMods = append(queryMods,
qm.InnerJoin("\"catalogs_containers\" on \"catalogs\".\"id\" = \"catalogs_containers\".\"catalog_id\""),
qm.Where("\"catalogs_containers\".\"container_id\"=?", o.ID),
)
query := Catalogs(exec, queryMods...)
queries.SetFrom(query.Query, "\"catalogs\"")
if len(queries.GetSelect(query.Query)) == 0 {
queries.SetSelect(query.Query, []string{"\"catalogs\".*"})
}
return query
}
// ContainerDescriptionsG retrieves all the container_description's container descriptions.
func (o *Container) ContainerDescriptionsG(mods ...qm.QueryMod) containerDescriptionQuery {
return o.ContainerDescriptions(boil.GetDB(), mods...)
}
// ContainerDescriptions retrieves all the container_description's container descriptions with an executor.
func (o *Container) ContainerDescriptions(exec boil.Executor, mods ...qm.QueryMod) containerDescriptionQuery {
var queryMods []qm.QueryMod
if len(mods) != 0 {
queryMods = append(queryMods, mods...)
}
queryMods = append(queryMods,
qm.Where("\"container_descriptions\".\"container_id\"=?", o.ID),
)
query := ContainerDescriptions(exec, queryMods...)
queries.SetFrom(query.Query, "\"container_descriptions\"")
if len(queries.GetSelect(query.Query)) == 0 {
queries.SetSelect(query.Query, []string{"\"container_descriptions\".*"})
}
return query
}
// FileAssetsG retrieves all the file_asset's file assets.
func (o *Container) FileAssetsG(mods ...qm.QueryMod) fileAssetQuery {
return o.FileAssets(boil.GetDB(), mods...)
}
// FileAssets retrieves all the file_asset's file assets with an executor.
func (o *Container) FileAssets(exec boil.Executor, mods ...qm.QueryMod) fileAssetQuery {
var queryMods []qm.QueryMod
if len(mods) != 0 {
queryMods = append(queryMods, mods...)
}
queryMods = append(queryMods,
qm.InnerJoin("\"containers_file_assets\" on \"file_assets\".\"id\" = \"containers_file_assets\".\"file_asset_id\""),
qm.Where("\"containers_file_assets\".\"container_id\"=?", o.ID),
)
query := FileAssets(exec, queryMods...)
queries.SetFrom(query.Query, "\"file_assets\"")
if len(queries.GetSelect(query.Query)) == 0 {
queries.SetSelect(query.Query, []string{"\"file_assets\".*"})
}
return query
}
// LabelsG retrieves all the label's labels.
func (o *Container) LabelsG(mods ...qm.QueryMod) labelQuery {
return o.Labels(boil.GetDB(), mods...)
}
// Labels retrieves all the label's labels with an executor.
func (o *Container) Labels(exec boil.Executor, mods ...qm.QueryMod) labelQuery {
var queryMods []qm.QueryMod
if len(mods) != 0 {
queryMods = append(queryMods, mods...)
}
queryMods = append(queryMods,
qm.InnerJoin("\"containers_labels\" on \"labels\".\"id\" = \"containers_labels\".\"label_id\""),
qm.Where("\"containers_labels\".\"container_id\"=?", o.ID),
)
query := Labels(exec, queryMods...)
queries.SetFrom(query.Query, "\"labels\"")
if len(queries.GetSelect(query.Query)) == 0 {
queries.SetSelect(query.Query, []string{"\"labels\".*"})
}
return query
}
// LoadContentType allows an eager lookup of values, cached into the
// loaded structs of the objects.
func (containerL) LoadContentType(e boil.Executor, singular bool, maybeContainer interface{}) error {
var slice []*Container
var object *Container
count := 1
if singular {
object = maybeContainer.(*Container)
} else {
slice = *maybeContainer.(*[]*Container)
count = len(slice)
}
args := make([]interface{}, count)
if singular {
if object.R == nil {
object.R = &containerR{}
}
args[0] = object.ContentTypeID
} else {
for i, obj := range slice {
if obj.R == nil {
obj.R = &containerR{}
}
args[i] = obj.ContentTypeID
}
}
query := fmt.Sprintf(
"select * from \"content_types\" where \"id\" in (%s)",
strmangle.Placeholders(dialect.IndexPlaceholders, count, 1, 1),
)
if boil.DebugMode {
fmt.Fprintf(boil.DebugWriter, "%s\n%v\n", query, args)
}
results, err := e.Query(query, args...)
if err != nil {
return errors.Wrap(err, "failed to eager load ContentType")
}
defer results.Close()
var resultSlice []*ContentType
if err = queries.Bind(results, &resultSlice); err != nil {
return errors.Wrap(err, "failed to bind eager loaded slice ContentType")
}
if len(resultSlice) == 0 {
return nil
}
if singular {
object.R.ContentType = resultSlice[0]
return nil
}
for _, local := range slice {
for _, foreign := range resultSlice {
if local.ContentTypeID.Int == foreign.ID {
local.R.ContentType = foreign
break
}
}
}
return nil
}
// LoadLang allows an eager lookup of values, cached into the
// loaded structs of the objects.
func (containerL) LoadLang(e boil.Executor, singular bool, maybeContainer interface{}) error {
var slice []*Container
var object *Container
count := 1
if singular {
object = maybeContainer.(*Container)
} else {
slice = *maybeContainer.(*[]*Container)
count = len(slice)
}
args := make([]interface{}, count)
if singular {
if object.R == nil {
object.R = &containerR{}
}
args[0] = object.LangID
} else {
for i, obj := range slice {
if obj.R == nil {
obj.R = &containerR{}
}
args[i] = obj.LangID
}
}
query := fmt.Sprintf(
"select * from \"languages\" where \"code3\" in (%s)",
strmangle.Placeholders(dialect.IndexPlaceholders, count, 1, 1),
)
if boil.DebugMode {
fmt.Fprintf(boil.DebugWriter, "%s\n%v\n", query, args)
}
results, err := e.Query(query, args...)
if err != nil {
return errors.Wrap(err, "failed to eager load Language")
}
defer results.Close()
var resultSlice []*Language
if err = queries.Bind(results, &resultSlice); err != nil {
return errors.Wrap(err, "failed to bind eager loaded slice Language")
}
if len(resultSlice) == 0 {
return nil
}
if singular {
object.R.Lang = resultSlice[0]
return nil
}
for _, local := range slice {
for _, foreign := range resultSlice {
if local.LangID.String == foreign.Code3.String {
local.R.Lang = foreign
break
}
}
}
return nil
}
// LoadVirtualLesson allows an eager lookup of values, cached into the
// loaded structs of the objects.
func (containerL) LoadVirtualLesson(e boil.Executor, singular bool, maybeContainer interface{}) error {
var slice []*Container
var object *Container
count := 1
if singular {
object = maybeContainer.(*Container)
} else {
slice = *maybeContainer.(*[]*Container)
count = len(slice)
}
args := make([]interface{}, count)
if singular {
if object.R == nil {
object.R = &containerR{}
}
args[0] = object.VirtualLessonID
} else {
for i, obj := range slice {
if obj.R == nil {
obj.R = &containerR{}
}
args[i] = obj.VirtualLessonID
}
}
query := fmt.Sprintf(
"select * from \"virtual_lessons\" where \"id\" in (%s)",
strmangle.Placeholders(dialect.IndexPlaceholders, count, 1, 1),
)
if boil.DebugMode {
fmt.Fprintf(boil.DebugWriter, "%s\n%v\n", query, args)
}
results, err := e.Query(query, args...)
if err != nil {
return errors.Wrap(err, "failed to eager load VirtualLesson")
}
defer results.Close()
var resultSlice []*VirtualLesson
if err = queries.Bind(results, &resultSlice); err != nil {
return errors.Wrap(err, "failed to bind eager loaded slice VirtualLesson")
}
if len(resultSlice) == 0 {
return nil
}
if singular {
object.R.VirtualLesson = resultSlice[0]
return nil
}
for _, local := range slice {
for _, foreign := range resultSlice {
if local.VirtualLessonID.Int == foreign.ID {
local.R.VirtualLesson = foreign
break
}
}
}
return nil
}
// LoadCatalogs allows an eager lookup of values, cached into the
// loaded structs of the objects.
func (containerL) LoadCatalogs(e boil.Executor, singular bool, maybeContainer interface{}) error {
var slice []*Container
var object *Container
count := 1
if singular {
object = maybeContainer.(*Container)
} else {
slice = *maybeContainer.(*[]*Container)
count = len(slice)
}
args := make([]interface{}, count)
if singular {
if object.R == nil {
object.R = &containerR{}
}
args[0] = object.ID
} else {
for i, obj := range slice {
if obj.R == nil {
obj.R = &containerR{}
}
args[i] = obj.ID
}
}
query := fmt.Sprintf(
"select \"a\".*, \"b\".\"container_id\" from \"catalogs\" as \"a\" inner join \"catalogs_containers\" as \"b\" on \"a\".\"id\" = \"b\".\"catalog_id\" where \"b\".\"container_id\" in (%s)",
strmangle.Placeholders(dialect.IndexPlaceholders, count, 1, 1),
)
if boil.DebugMode {
fmt.Fprintf(boil.DebugWriter, "%s\n%v\n", query, args)
}
results, err := e.Query(query, args...)
if err != nil {
return errors.Wrap(err, "failed to eager load catalogs")
}
defer results.Close()
var resultSlice []*Catalog
var localJoinCols []int
for results.Next() {
one := new(Catalog)
var localJoinCol int
err = results.Scan(&one.ID, &one.Name, &one.ParentID, &one.CreatedAt, &one.UpdatedAt, &one.Catorder, &one.Secure, &one.Visible, &one.Open, &one.Label, &one.SelectedCatalog, &one.UserID, &one.BooksCatalog, &localJoinCol)
if err = results.Err(); err != nil {
return errors.Wrap(err, "failed to plebian-bind eager loaded slice catalogs")
}
resultSlice = append(resultSlice, one)
localJoinCols = append(localJoinCols, localJoinCol)
}
if err = results.Err(); err != nil {
return errors.Wrap(err, "failed to plebian-bind eager loaded slice catalogs")
}
if singular {
object.R.Catalogs = resultSlice
return nil
}
for i, foreign := range resultSlice {
localJoinCol := localJoinCols[i]
for _, local := range slice {
if local.ID == localJoinCol {
local.R.Catalogs = append(local.R.Catalogs, foreign)
break
}
}
}
return nil
}
// LoadContainerDescriptions allows an eager lookup of values, cached into the
// loaded structs of the objects.
func (containerL) LoadContainerDescriptions(e boil.Executor, singular bool, maybeContainer interface{}) error {
var slice []*Container
var object *Container
count := 1
if singular {
object = maybeContainer.(*Container)
} else {
slice = *maybeContainer.(*[]*Container)
count = len(slice)
}
args := make([]interface{}, count)
if singular {
if object.R == nil {
object.R = &containerR{}
}
args[0] = object.ID
} else {
for i, obj := range slice {
if obj.R == nil {
obj.R = &containerR{}
}
args[i] = obj.ID
}
}
query := fmt.Sprintf(
"select * from \"container_descriptions\" where \"container_id\" in (%s)",
strmangle.Placeholders(dialect.IndexPlaceholders, count, 1, 1),
)
if boil.DebugMode {
fmt.Fprintf(boil.DebugWriter, "%s\n%v\n", query, args)
}
results, err := e.Query(query, args...)
if err != nil {
return errors.Wrap(err, "failed to eager load container_descriptions")
}
defer results.Close()
var resultSlice []*ContainerDescription
if err = queries.Bind(results, &resultSlice); err != nil {
return errors.Wrap(err, "failed to bind eager loaded slice container_descriptions")
}
if singular {
object.R.ContainerDescriptions = resultSlice
return nil
}
for _, foreign := range resultSlice {
for _, local := range slice {
if local.ID == foreign.ContainerID {
local.R.ContainerDescriptions = append(local.R.ContainerDescriptions, foreign)
break
}
}
}
return nil
}
// LoadFileAssets allows an eager lookup of values, cached into the
// loaded structs of the objects.
func (containerL) LoadFileAssets(e boil.Executor, singular bool, maybeContainer interface{}) error {
var slice []*Container
var object *Container
count := 1
if singular {
object = maybeContainer.(*Container)
} else {
slice = *maybeContainer.(*[]*Container)
count = len(slice)
}
args := make([]interface{}, count)
if singular {
if object.R == nil {
object.R = &containerR{}
}
args[0] = object.ID
} else {
for i, obj := range slice {
if obj.R == nil {
obj.R = &containerR{}
}
args[i] = obj.ID
}
}
query := fmt.Sprintf(
"select \"a\".*, \"b\".\"container_id\" from \"file_assets\" as \"a\" inner join \"containers_file_assets\" as \"b\" on \"a\".\"id\" = \"b\".\"file_asset_id\" where \"b\".\"container_id\" in (%s)",
strmangle.Placeholders(dialect.IndexPlaceholders, count, 1, 1),
)
if boil.DebugMode {
fmt.Fprintf(boil.DebugWriter, "%s\n%v\n", query, args)
}
results, err := e.Query(query, args...)
if err != nil {
return errors.Wrap(err, "failed to eager load file_assets")
}
defer results.Close()
var resultSlice []*FileAsset
var localJoinCols []int
for results.Next() {
one := new(FileAsset)
var localJoinCol int
err = results.Scan(&one.ID, &one.Name, &one.LangID, &one.AssetType, &one.Date, &one.Size, &one.ServernameID, &one.Status, &one.CreatedAt, &one.UpdatedAt, &one.Lastuser, &one.Clicks, &one.Secure, &one.PlaytimeSecs, &one.UserID, &one.Sha1, &localJoinCol)
if err = results.Err(); err != nil {
return errors.Wrap(err, "failed to plebian-bind eager loaded slice file_assets")
}
resultSlice = append(resultSlice, one)
localJoinCols = append(localJoinCols, localJoinCol)
}
if err = results.Err(); err != nil {
return errors.Wrap(err, "failed to plebian-bind eager loaded slice file_assets")
}
if singular {
object.R.FileAssets = resultSlice
return nil
}
for i, foreign := range resultSlice {
localJoinCol := localJoinCols[i]
for _, local := range slice {
if local.ID == localJoinCol {
local.R.FileAssets = append(local.R.FileAssets, foreign)
break
}
}
}
return nil
}
// LoadLabels allows an eager lookup of values, cached into the
// loaded structs of the objects.
func (containerL) LoadLabels(e boil.Executor, singular bool, maybeContainer interface{}) error {
var slice []*Container
var object *Container
count := 1
if singular {
object = maybeContainer.(*Container)
} else {
slice = *maybeContainer.(*[]*Container)
count = len(slice)
}
args := make([]interface{}, count)
if singular {
if object.R == nil {
object.R = &containerR{}
}
args[0] = object.ID
} else {
for i, obj := range slice {
if obj.R == nil {
obj.R = &containerR{}
}
args[i] = obj.ID
}
}
query := fmt.Sprintf(
"select \"a\".*, \"b\".\"container_id\" from \"labels\" as \"a\" inner join \"containers_labels\" as \"b\" on \"a\".\"id\" = \"b\".\"label_id\" where \"b\".\"container_id\" in (%s)",
strmangle.Placeholders(dialect.IndexPlaceholders, count, 1, 1),
)
if boil.DebugMode {
fmt.Fprintf(boil.DebugWriter, "%s\n%v\n", query, args)
}
results, err := e.Query(query, args...)
if err != nil {
return errors.Wrap(err, "failed to eager load labels")
}
defer results.Close()
var resultSlice []*Label
var localJoinCols []int
for results.Next() {
one := new(Label)
var localJoinCol int
err = results.Scan(&one.ID, &one.DictionaryID, &one.Suid, &one.CreatedAt, &one.UpdatedAt, &localJoinCol)
if err = results.Err(); err != nil {
return errors.Wrap(err, "failed to plebian-bind eager loaded slice labels")
}
resultSlice = append(resultSlice, one)
localJoinCols = append(localJoinCols, localJoinCol)
}
if err = results.Err(); err != nil {
return errors.Wrap(err, "failed to plebian-bind eager loaded slice labels")
}
if singular {
object.R.Labels = resultSlice
return nil
}
for i, foreign := range resultSlice {
localJoinCol := localJoinCols[i]
for _, local := range slice {
if local.ID == localJoinCol {
local.R.Labels = append(local.R.Labels, foreign)
break
}
}
}
return nil
}
// SetContentTypeG of the container to the related item.
// Sets o.R.ContentType to related.
// Adds o to related.R.Containers.
// Uses the global database handle.
func (o *Container) SetContentTypeG(insert bool, related *ContentType) error {
return o.SetContentType(boil.GetDB(), insert, related)
}
// SetContentTypeP of the container to the related item.
// Sets o.R.ContentType to related.
// Adds o to related.R.Containers.
// Panics on error.
func (o *Container) SetContentTypeP(exec boil.Executor, insert bool, related *ContentType) {
if err := o.SetContentType(exec, insert, related); err != nil {
panic(boil.WrapErr(err))
}
}
// SetContentTypeGP of the container to the related item.
// Sets o.R.ContentType to related.
// Adds o to related.R.Containers.
// Uses the global database handle and panics on error.
func (o *Container) SetContentTypeGP(insert bool, related *ContentType) {
if err := o.SetContentType(boil.GetDB(), insert, related); err != nil {
panic(boil.WrapErr(err))
}
}
// SetContentType of the container to the related item.
// Sets o.R.ContentType to related.
// Adds o to related.R.Containers.
func (o *Container) SetContentType(exec boil.Executor, insert bool, related *ContentType) error {
var err error
if insert {
if err = related.Insert(exec); err != nil {
return errors.Wrap(err, "failed to insert into foreign table")
}
}
updateQuery := fmt.Sprintf(
"UPDATE \"containers\" SET %s WHERE %s",
strmangle.SetParamNames("\"", "\"", 1, []string{"content_type_id"}),
strmangle.WhereClause("\"", "\"", 2, containerPrimaryKeyColumns),
)
values := []interface{}{related.ID, o.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 local table")
}
o.ContentTypeID.Int = related.ID
o.ContentTypeID.Valid = true
if o.R == nil {
o.R = &containerR{
ContentType: related,
}
} else {
o.R.ContentType = related
}
if related.R == nil {
related.R = &contentTypeR{
Containers: ContainerSlice{o},
}
} else {
related.R.Containers = append(related.R.Containers, o)
}
return nil
}
// RemoveContentTypeG relationship.
// Sets o.R.ContentType to nil.
// Removes o from all passed in related items' relationships struct (Optional).
// Uses the global database handle.
func (o *Container) RemoveContentTypeG(related *ContentType) error {
return o.RemoveContentType(boil.GetDB(), related)
}
// RemoveContentTypeP relationship.
// Sets o.R.ContentType to nil.
// Removes o from all passed in related items' relationships struct (Optional).
// Panics on error.
func (o *Container) RemoveContentTypeP(exec boil.Executor, related *ContentType) {
if err := o.RemoveContentType(exec, related); err != nil {
panic(boil.WrapErr(err))
}
}
// RemoveContentTypeGP relationship.
// Sets o.R.ContentType to nil.
// Removes o from all passed in related items' relationships struct (Optional).
// Uses the global database handle and panics on error.
func (o *Container) RemoveContentTypeGP(related *ContentType) {
if err := o.RemoveContentType(boil.GetDB(), related); err != nil {
panic(boil.WrapErr(err))
}
}
// RemoveContentType relationship.
// Sets o.R.ContentType to nil.
// Removes o from all passed in related items' relationships struct (Optional).
func (o *Container) RemoveContentType(exec boil.Executor, related *ContentType) error {
var err error
o.ContentTypeID.Valid = false
if err = o.Update(exec, "content_type_id"); err != nil {
o.ContentTypeID.Valid = true
return errors.Wrap(err, "failed to update local table")
}
o.R.ContentType = nil
if related == nil || related.R == nil {
return nil
}
for i, ri := range related.R.Containers {
if o.ContentTypeID.Int != ri.ContentTypeID.Int {
continue
}
ln := len(related.R.Containers)
if ln > 1 && i < ln-1 {
related.R.Containers[i] = related.R.Containers[ln-1]
}
related.R.Containers = related.R.Containers[:ln-1]
break
}
return nil
}
// SetLangG of the container to the related item.
// Sets o.R.Lang to related.
// Adds o to related.R.LangContainers.
// Uses the global database handle.
func (o *Container) SetLangG(insert bool, related *Language) error {
return o.SetLang(boil.GetDB(), insert, related)
}
// SetLangP of the container to the related item.
// Sets o.R.Lang to related.
// Adds o to related.R.LangContainers.
// Panics on error.
func (o *Container) SetLangP(exec boil.Executor, insert bool, related *Language) {
if err := o.SetLang(exec, insert, related); err != nil {
panic(boil.WrapErr(err))
}
}
// SetLangGP of the container to the related item.
// Sets o.R.Lang to related.
// Adds o to related.R.LangContainers.
// Uses the global database handle and panics on error.
func (o *Container) SetLangGP(insert bool, related *Language) {
if err := o.SetLang(boil.GetDB(), insert, related); err != nil {
panic(boil.WrapErr(err))
}
}
// SetLang of the container to the related item.
// Sets o.R.Lang to related.
// Adds o to related.R.LangContainers.
func (o *Container) SetLang(exec boil.Executor, insert bool, related *Language) error {
var err error
if insert {
if err = related.Insert(exec); err != nil {
return errors.Wrap(err, "failed to insert into foreign table")
}
}
updateQuery := fmt.Sprintf(
"UPDATE \"containers\" SET %s WHERE %s",
strmangle.SetParamNames("\"", "\"", 1, []string{"lang_id"}),
strmangle.WhereClause("\"", "\"", 2, containerPrimaryKeyColumns),
)
values := []interface{}{related.Code3, o.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 local table")
}
o.LangID.String = related.Code3.String
o.LangID.Valid = true
if o.R == nil {
o.R = &containerR{
Lang: related,
}
} else {
o.R.Lang = related
}
if related.R == nil {
related.R = &languageR{
LangContainers: ContainerSlice{o},
}
} else {
related.R.LangContainers = append(related.R.LangContainers, o)
}
return nil
}
// RemoveLangG relationship.
// Sets o.R.Lang to nil.
// Removes o from all passed in related items' relationships struct (Optional).
// Uses the global database handle.
func (o *Container) RemoveLangG(related *Language) error {
return o.RemoveLang(boil.GetDB(), related)
}
// RemoveLangP relationship.
// Sets o.R.Lang to nil.
// Removes o from all passed in related items' relationships struct (Optional).
// Panics on error.
func (o *Container) RemoveLangP(exec boil.Executor, related *Language) {
if err := o.RemoveLang(exec, related); err != nil {
panic(boil.WrapErr(err))
}
}
// RemoveLangGP relationship.
// Sets o.R.Lang to nil.
// Removes o from all passed in related items' relationships struct (Optional).
// Uses the global database handle and panics on error.
func (o *Container) RemoveLangGP(related *Language) {
if err := o.RemoveLang(boil.GetDB(), related); err != nil {
panic(boil.WrapErr(err))
}
}
// RemoveLang relationship.
// Sets o.R.Lang to nil.
// Removes o from all passed in related items' relationships struct (Optional).
func (o *Container) RemoveLang(exec boil.Executor, related *Language) error {
var err error
o.LangID.Valid = false
if err = o.Update(exec, "lang_id"); err != nil {
o.LangID.Valid = true
return errors.Wrap(err, "failed to update local table")
}
o.R.Lang = nil
if related == nil || related.R == nil {
return nil
}
for i, ri := range related.R.LangContainers {
if o.LangID.String != ri.LangID.String {
continue
}
ln := len(related.R.LangContainers)
if ln > 1 && i < ln-1 {
related.R.LangContainers[i] = related.R.LangContainers[ln-1]
}
related.R.LangContainers = related.R.LangContainers[:ln-1]
break
}
return nil
}
// SetVirtualLessonG of the container to the related item.
// Sets o.R.VirtualLesson to related.
// Adds o to related.R.Containers.
// Uses the global database handle.
func (o *Container) SetVirtualLessonG(insert bool, related *VirtualLesson) error {
return o.SetVirtualLesson(boil.GetDB(), insert, related)
}
// SetVirtualLessonP of the container to the related item.
// Sets o.R.VirtualLesson to related.
// Adds o to related.R.Containers.
// Panics on error.
func (o *Container) SetVirtualLessonP(exec boil.Executor, insert bool, related *VirtualLesson) {
if err := o.SetVirtualLesson(exec, insert, related); err != nil {
panic(boil.WrapErr(err))
}
}
// SetVirtualLessonGP of the container to the related item.
// Sets o.R.VirtualLesson to related.
// Adds o to related.R.Containers.
// Uses the global database handle and panics on error.
func (o *Container) SetVirtualLessonGP(insert bool, related *VirtualLesson) {
if err := o.SetVirtualLesson(boil.GetDB(), insert, related); err != nil {
panic(boil.WrapErr(err))
}
}
// SetVirtualLesson of the container to the related item.
// Sets o.R.VirtualLesson to related.
// Adds o to related.R.Containers.
func (o *Container) SetVirtualLesson(exec boil.Executor, insert bool, related *VirtualLesson) error {
var err error
if insert {
if err = related.Insert(exec); err != nil {
return errors.Wrap(err, "failed to insert into foreign table")
}
}
updateQuery := fmt.Sprintf(
"UPDATE \"containers\" SET %s WHERE %s",
strmangle.SetParamNames("\"", "\"", 1, []string{"virtual_lesson_id"}),
strmangle.WhereClause("\"", "\"", 2, containerPrimaryKeyColumns),
)
values := []interface{}{related.ID, o.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 local table")
}
o.VirtualLessonID.Int = related.ID
o.VirtualLessonID.Valid = true
if o.R == nil {
o.R = &containerR{
VirtualLesson: related,
}
} else {
o.R.VirtualLesson = related
}
if related.R == nil {
related.R = &virtualLessonR{
Containers: ContainerSlice{o},
}
} else {
related.R.Containers = append(related.R.Containers, o)
}
return nil
}
// RemoveVirtualLessonG relationship.
// Sets o.R.VirtualLesson to nil.
// Removes o from all passed in related items' relationships struct (Optional).
// Uses the global database handle.
func (o *Container) RemoveVirtualLessonG(related *VirtualLesson) error {
return o.RemoveVirtualLesson(boil.GetDB(), related)
}
// RemoveVirtualLessonP relationship.
// Sets o.R.VirtualLesson to nil.
// Removes o from all passed in related items' relationships struct (Optional).
// Panics on error.
func (o *Container) RemoveVirtualLessonP(exec boil.Executor, related *VirtualLesson) {
if err := o.RemoveVirtualLesson(exec, related); err != nil {
panic(boil.WrapErr(err))
}
}
// RemoveVirtualLessonGP relationship.
// Sets o.R.VirtualLesson to nil.
// Removes o from all passed in related items' relationships struct (Optional).
// Uses the global database handle and panics on error.
func (o *Container) RemoveVirtualLessonGP(related *VirtualLesson) {
if err := o.RemoveVirtualLesson(boil.GetDB(), related); err != nil {
panic(boil.WrapErr(err))
}
}
// RemoveVirtualLesson relationship.
// Sets o.R.VirtualLesson to nil.
// Removes o from all passed in related items' relationships struct (Optional).
func (o *Container) RemoveVirtualLesson(exec boil.Executor, related *VirtualLesson) error {
var err error
o.VirtualLessonID.Valid = false
if err = o.Update(exec, "virtual_lesson_id"); err != nil {
o.VirtualLessonID.Valid = true
return errors.Wrap(err, "failed to update local table")
}
o.R.VirtualLesson = nil
if related == nil || related.R == nil {
return nil
}
for i, ri := range related.R.Containers {
if o.VirtualLessonID.Int != ri.VirtualLessonID.Int {
continue
}
ln := len(related.R.Containers)
if ln > 1 && i < ln-1 {
related.R.Containers[i] = related.R.Containers[ln-1]
}
related.R.Containers = related.R.Containers[:ln-1]
break
}
return nil
}
// AddCatalogsG adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.Catalogs.
// Sets related.R.Containers appropriately.
// Uses the global database handle.
func (o *Container) AddCatalogsG(insert bool, related ...*Catalog) error {
return o.AddCatalogs(boil.GetDB(), insert, related...)
}
// AddCatalogsP adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.Catalogs.
// Sets related.R.Containers appropriately.
// Panics on error.
func (o *Container) AddCatalogsP(exec boil.Executor, insert bool, related ...*Catalog) {
if err := o.AddCatalogs(exec, insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// AddCatalogsGP adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.Catalogs.
// Sets related.R.Containers appropriately.
// Uses the global database handle and panics on error.
func (o *Container) AddCatalogsGP(insert bool, related ...*Catalog) {
if err := o.AddCatalogs(boil.GetDB(), insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// AddCatalogs adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.Catalogs.
// Sets related.R.Containers appropriately.
func (o *Container) AddCatalogs(exec boil.Executor, insert bool, related ...*Catalog) error {
var err error
for _, rel := range related {
if insert {
if err = rel.Insert(exec); err != nil {
return errors.Wrap(err, "failed to insert into foreign table")
}
}
}
for _, rel := range related {
query := "insert into \"catalogs_containers\" (\"container_id\", \"catalog_id\") values ($1, $2)"
values := []interface{}{o.ID, rel.ID}
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 insert into join table")
}
}
if o.R == nil {
o.R = &containerR{
Catalogs: related,
}
} else {
o.R.Catalogs = append(o.R.Catalogs, related...)
}
for _, rel := range related {
if rel.R == nil {
rel.R = &catalogR{
Containers: ContainerSlice{o},
}
} else {
rel.R.Containers = append(rel.R.Containers, o)
}
}
return nil
}
// SetCatalogsG removes all previously related items of the
// container replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Containers's Catalogs accordingly.
// Replaces o.R.Catalogs with related.
// Sets related.R.Containers's Catalogs accordingly.
// Uses the global database handle.
func (o *Container) SetCatalogsG(insert bool, related ...*Catalog) error {
return o.SetCatalogs(boil.GetDB(), insert, related...)
}
// SetCatalogsP removes all previously related items of the
// container replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Containers's Catalogs accordingly.
// Replaces o.R.Catalogs with related.
// Sets related.R.Containers's Catalogs accordingly.
// Panics on error.
func (o *Container) SetCatalogsP(exec boil.Executor, insert bool, related ...*Catalog) {
if err := o.SetCatalogs(exec, insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// SetCatalogsGP removes all previously related items of the
// container replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Containers's Catalogs accordingly.
// Replaces o.R.Catalogs with related.
// Sets related.R.Containers's Catalogs accordingly.
// Uses the global database handle and panics on error.
func (o *Container) SetCatalogsGP(insert bool, related ...*Catalog) {
if err := o.SetCatalogs(boil.GetDB(), insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// SetCatalogs removes all previously related items of the
// container replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Containers's Catalogs accordingly.
// Replaces o.R.Catalogs with related.
// Sets related.R.Containers's Catalogs accordingly.
func (o *Container) SetCatalogs(exec boil.Executor, insert bool, related ...*Catalog) error {
query := "delete from \"catalogs_containers\" where \"container_id\" = $1"
values := []interface{}{o.ID}
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")
}
removeCatalogsFromContainersSlice(o, related)
if o.R != nil {
o.R.Catalogs = nil
}
return o.AddCatalogs(exec, insert, related...)
}
// RemoveCatalogsG relationships from objects passed in.
// Removes related items from R.Catalogs (uses pointer comparison, removal does not keep order)
// Sets related.R.Containers.
// Uses the global database handle.
func (o *Container) RemoveCatalogsG(related ...*Catalog) error {
return o.RemoveCatalogs(boil.GetDB(), related...)
}
// RemoveCatalogsP relationships from objects passed in.
// Removes related items from R.Catalogs (uses pointer comparison, removal does not keep order)
// Sets related.R.Containers.
// Panics on error.
func (o *Container) RemoveCatalogsP(exec boil.Executor, related ...*Catalog) {
if err := o.RemoveCatalogs(exec, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// RemoveCatalogsGP relationships from objects passed in.
// Removes related items from R.Catalogs (uses pointer comparison, removal does not keep order)
// Sets related.R.Containers.
// Uses the global database handle and panics on error.
func (o *Container) RemoveCatalogsGP(related ...*Catalog) {
if err := o.RemoveCatalogs(boil.GetDB(), related...); err != nil {
panic(boil.WrapErr(err))
}
}
// RemoveCatalogs relationships from objects passed in.
// Removes related items from R.Catalogs (uses pointer comparison, removal does not keep order)
// Sets related.R.Containers.
func (o *Container) RemoveCatalogs(exec boil.Executor, related ...*Catalog) error {
var err error
query := fmt.Sprintf(
"delete from \"catalogs_containers\" where \"container_id\" = $1 and \"catalog_id\" in (%s)",
strmangle.Placeholders(dialect.IndexPlaceholders, len(related), 2, 1),
)
values := []interface{}{o.ID}
for _, rel := range related {
values = append(values, rel.ID)
}
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")
}
removeCatalogsFromContainersSlice(o, related)
if o.R == nil {
return nil
}
for _, rel := range related {
for i, ri := range o.R.Catalogs {
if rel != ri {
continue
}
ln := len(o.R.Catalogs)
if ln > 1 && i < ln-1 {
o.R.Catalogs[i] = o.R.Catalogs[ln-1]
}
o.R.Catalogs = o.R.Catalogs[:ln-1]
break
}
}
return nil
}
func removeCatalogsFromContainersSlice(o *Container, related []*Catalog) {
for _, rel := range related {
if rel.R == nil {
continue
}
for i, ri := range rel.R.Containers {
if o.ID != ri.ID {
continue
}
ln := len(rel.R.Containers)
if ln > 1 && i < ln-1 {
rel.R.Containers[i] = rel.R.Containers[ln-1]
}
rel.R.Containers = rel.R.Containers[:ln-1]
break
}
}
}
// AddContainerDescriptionsG adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.ContainerDescriptions.
// Sets related.R.Container appropriately.
// Uses the global database handle.
func (o *Container) AddContainerDescriptionsG(insert bool, related ...*ContainerDescription) error {
return o.AddContainerDescriptions(boil.GetDB(), insert, related...)
}
// AddContainerDescriptionsP adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.ContainerDescriptions.
// Sets related.R.Container appropriately.
// Panics on error.
func (o *Container) AddContainerDescriptionsP(exec boil.Executor, insert bool, related ...*ContainerDescription) {
if err := o.AddContainerDescriptions(exec, insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// AddContainerDescriptionsGP adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.ContainerDescriptions.
// Sets related.R.Container appropriately.
// Uses the global database handle and panics on error.
func (o *Container) AddContainerDescriptionsGP(insert bool, related ...*ContainerDescription) {
if err := o.AddContainerDescriptions(boil.GetDB(), insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// AddContainerDescriptions adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.ContainerDescriptions.
// Sets related.R.Container appropriately.
func (o *Container) AddContainerDescriptions(exec boil.Executor, insert bool, related ...*ContainerDescription) error {
var err error
for _, rel := range related {
if insert {
rel.ContainerID = o.ID
if err = rel.Insert(exec); err != nil {
return errors.Wrap(err, "failed to insert into foreign table")
}
} else {
updateQuery := fmt.Sprintf(
"UPDATE \"container_descriptions\" SET %s WHERE %s",
strmangle.SetParamNames("\"", "\"", 1, []string{"container_id"}),
strmangle.WhereClause("\"", "\"", 2, containerDescriptionPrimaryKeyColumns),
)
values := []interface{}{o.ID, 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.ContainerID = o.ID
}
}
if o.R == nil {
o.R = &containerR{
ContainerDescriptions: related,
}
} else {
o.R.ContainerDescriptions = append(o.R.ContainerDescriptions, related...)
}
for _, rel := range related {
if rel.R == nil {
rel.R = &containerDescriptionR{
Container: o,
}
} else {
rel.R.Container = o
}
}
return nil
}
// AddFileAssetsG adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.FileAssets.
// Sets related.R.Containers appropriately.
// Uses the global database handle.
func (o *Container) AddFileAssetsG(insert bool, related ...*FileAsset) error {
return o.AddFileAssets(boil.GetDB(), insert, related...)
}
// AddFileAssetsP adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.FileAssets.
// Sets related.R.Containers appropriately.
// Panics on error.
func (o *Container) AddFileAssetsP(exec boil.Executor, insert bool, related ...*FileAsset) {
if err := o.AddFileAssets(exec, insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// AddFileAssetsGP adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.FileAssets.
// Sets related.R.Containers appropriately.
// Uses the global database handle and panics on error.
func (o *Container) AddFileAssetsGP(insert bool, related ...*FileAsset) {
if err := o.AddFileAssets(boil.GetDB(), insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// AddFileAssets adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.FileAssets.
// Sets related.R.Containers appropriately.
func (o *Container) AddFileAssets(exec boil.Executor, insert bool, related ...*FileAsset) error {
var err error
for _, rel := range related {
if insert {
if err = rel.Insert(exec); err != nil {
return errors.Wrap(err, "failed to insert into foreign table")
}
}
}
for _, rel := range related {
query := "insert into \"containers_file_assets\" (\"container_id\", \"file_asset_id\") values ($1, $2)"
values := []interface{}{o.ID, rel.ID}
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 insert into join table")
}
}
if o.R == nil {
o.R = &containerR{
FileAssets: related,
}
} else {
o.R.FileAssets = append(o.R.FileAssets, related...)
}
for _, rel := range related {
if rel.R == nil {
rel.R = &fileAssetR{
Containers: ContainerSlice{o},
}
} else {
rel.R.Containers = append(rel.R.Containers, o)
}
}
return nil
}
// SetFileAssetsG removes all previously related items of the
// container replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Containers's FileAssets accordingly.
// Replaces o.R.FileAssets with related.
// Sets related.R.Containers's FileAssets accordingly.
// Uses the global database handle.
func (o *Container) SetFileAssetsG(insert bool, related ...*FileAsset) error {
return o.SetFileAssets(boil.GetDB(), insert, related...)
}
// SetFileAssetsP removes all previously related items of the
// container replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Containers's FileAssets accordingly.
// Replaces o.R.FileAssets with related.
// Sets related.R.Containers's FileAssets accordingly.
// Panics on error.
func (o *Container) SetFileAssetsP(exec boil.Executor, insert bool, related ...*FileAsset) {
if err := o.SetFileAssets(exec, insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// SetFileAssetsGP removes all previously related items of the
// container replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Containers's FileAssets accordingly.
// Replaces o.R.FileAssets with related.
// Sets related.R.Containers's FileAssets accordingly.
// Uses the global database handle and panics on error.
func (o *Container) SetFileAssetsGP(insert bool, related ...*FileAsset) {
if err := o.SetFileAssets(boil.GetDB(), insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// SetFileAssets removes all previously related items of the
// container replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Containers's FileAssets accordingly.
// Replaces o.R.FileAssets with related.
// Sets related.R.Containers's FileAssets accordingly.
func (o *Container) SetFileAssets(exec boil.Executor, insert bool, related ...*FileAsset) error {
query := "delete from \"containers_file_assets\" where \"container_id\" = $1"
values := []interface{}{o.ID}
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")
}
removeFileAssetsFromContainersSlice(o, related)
if o.R != nil {
o.R.FileAssets = nil
}
return o.AddFileAssets(exec, insert, related...)
}
// RemoveFileAssetsG relationships from objects passed in.
// Removes related items from R.FileAssets (uses pointer comparison, removal does not keep order)
// Sets related.R.Containers.
// Uses the global database handle.
func (o *Container) RemoveFileAssetsG(related ...*FileAsset) error {
return o.RemoveFileAssets(boil.GetDB(), related...)
}
// RemoveFileAssetsP relationships from objects passed in.
// Removes related items from R.FileAssets (uses pointer comparison, removal does not keep order)
// Sets related.R.Containers.
// Panics on error.
func (o *Container) RemoveFileAssetsP(exec boil.Executor, related ...*FileAsset) {
if err := o.RemoveFileAssets(exec, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// RemoveFileAssetsGP relationships from objects passed in.
// Removes related items from R.FileAssets (uses pointer comparison, removal does not keep order)
// Sets related.R.Containers.
// Uses the global database handle and panics on error.
func (o *Container) RemoveFileAssetsGP(related ...*FileAsset) {
if err := o.RemoveFileAssets(boil.GetDB(), related...); err != nil {
panic(boil.WrapErr(err))
}
}
// RemoveFileAssets relationships from objects passed in.
// Removes related items from R.FileAssets (uses pointer comparison, removal does not keep order)
// Sets related.R.Containers.
func (o *Container) RemoveFileAssets(exec boil.Executor, related ...*FileAsset) error {
var err error
query := fmt.Sprintf(
"delete from \"containers_file_assets\" where \"container_id\" = $1 and \"file_asset_id\" in (%s)",
strmangle.Placeholders(dialect.IndexPlaceholders, len(related), 2, 1),
)
values := []interface{}{o.ID}
for _, rel := range related {
values = append(values, rel.ID)
}
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")
}
removeFileAssetsFromContainersSlice(o, related)
if o.R == nil {
return nil
}
for _, rel := range related {
for i, ri := range o.R.FileAssets {
if rel != ri {
continue
}
ln := len(o.R.FileAssets)
if ln > 1 && i < ln-1 {
o.R.FileAssets[i] = o.R.FileAssets[ln-1]
}
o.R.FileAssets = o.R.FileAssets[:ln-1]
break
}
}
return nil
}
func removeFileAssetsFromContainersSlice(o *Container, related []*FileAsset) {
for _, rel := range related {
if rel.R == nil {
continue
}
for i, ri := range rel.R.Containers {
if o.ID != ri.ID {
continue
}
ln := len(rel.R.Containers)
if ln > 1 && i < ln-1 {
rel.R.Containers[i] = rel.R.Containers[ln-1]
}
rel.R.Containers = rel.R.Containers[:ln-1]
break
}
}
}
// AddLabelsG adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.Labels.
// Sets related.R.Containers appropriately.
// Uses the global database handle.
func (o *Container) AddLabelsG(insert bool, related ...*Label) error {
return o.AddLabels(boil.GetDB(), insert, related...)
}
// AddLabelsP adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.Labels.
// Sets related.R.Containers appropriately.
// Panics on error.
func (o *Container) AddLabelsP(exec boil.Executor, insert bool, related ...*Label) {
if err := o.AddLabels(exec, insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// AddLabelsGP adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.Labels.
// Sets related.R.Containers appropriately.
// Uses the global database handle and panics on error.
func (o *Container) AddLabelsGP(insert bool, related ...*Label) {
if err := o.AddLabels(boil.GetDB(), insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// AddLabels adds the given related objects to the existing relationships
// of the container, optionally inserting them as new records.
// Appends related to o.R.Labels.
// Sets related.R.Containers appropriately.
func (o *Container) AddLabels(exec boil.Executor, insert bool, related ...*Label) error {
var err error
for _, rel := range related {
if insert {
if err = rel.Insert(exec); err != nil {
return errors.Wrap(err, "failed to insert into foreign table")
}
}
}
for _, rel := range related {
query := "insert into \"containers_labels\" (\"container_id\", \"label_id\") values ($1, $2)"
values := []interface{}{o.ID, rel.ID}
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 insert into join table")
}
}
if o.R == nil {
o.R = &containerR{
Labels: related,
}
} else {
o.R.Labels = append(o.R.Labels, related...)
}
for _, rel := range related {
if rel.R == nil {
rel.R = &labelR{
Containers: ContainerSlice{o},
}
} else {
rel.R.Containers = append(rel.R.Containers, o)
}
}
return nil
}
// SetLabelsG removes all previously related items of the
// container replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Containers's Labels accordingly.
// Replaces o.R.Labels with related.
// Sets related.R.Containers's Labels accordingly.
// Uses the global database handle.
func (o *Container) SetLabelsG(insert bool, related ...*Label) error {
return o.SetLabels(boil.GetDB(), insert, related...)
}
// SetLabelsP removes all previously related items of the
// container replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Containers's Labels accordingly.
// Replaces o.R.Labels with related.
// Sets related.R.Containers's Labels accordingly.
// Panics on error.
func (o *Container) SetLabelsP(exec boil.Executor, insert bool, related ...*Label) {
if err := o.SetLabels(exec, insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// SetLabelsGP removes all previously related items of the
// container replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Containers's Labels accordingly.
// Replaces o.R.Labels with related.
// Sets related.R.Containers's Labels accordingly.
// Uses the global database handle and panics on error.
func (o *Container) SetLabelsGP(insert bool, related ...*Label) {
if err := o.SetLabels(boil.GetDB(), insert, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// SetLabels removes all previously related items of the
// container replacing them completely with the passed
// in related items, optionally inserting them as new records.
// Sets o.R.Containers's Labels accordingly.
// Replaces o.R.Labels with related.
// Sets related.R.Containers's Labels accordingly.
func (o *Container) SetLabels(exec boil.Executor, insert bool, related ...*Label) error {
query := "delete from \"containers_labels\" where \"container_id\" = $1"
values := []interface{}{o.ID}
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")
}
removeLabelsFromContainersSlice(o, related)
if o.R != nil {
o.R.Labels = nil
}
return o.AddLabels(exec, insert, related...)
}
// RemoveLabelsG relationships from objects passed in.
// Removes related items from R.Labels (uses pointer comparison, removal does not keep order)
// Sets related.R.Containers.
// Uses the global database handle.
func (o *Container) RemoveLabelsG(related ...*Label) error {
return o.RemoveLabels(boil.GetDB(), related...)
}
// RemoveLabelsP relationships from objects passed in.
// Removes related items from R.Labels (uses pointer comparison, removal does not keep order)
// Sets related.R.Containers.
// Panics on error.
func (o *Container) RemoveLabelsP(exec boil.Executor, related ...*Label) {
if err := o.RemoveLabels(exec, related...); err != nil {
panic(boil.WrapErr(err))
}
}
// RemoveLabelsGP relationships from objects passed in.
// Removes related items from R.Labels (uses pointer comparison, removal does not keep order)
// Sets related.R.Containers.
// Uses the global database handle and panics on error.
func (o *Container) RemoveLabelsGP(related ...*Label) {
if err := o.RemoveLabels(boil.GetDB(), related...); err != nil {
panic(boil.WrapErr(err))
}
}
// RemoveLabels relationships from objects passed in.
// Removes related items from R.Labels (uses pointer comparison, removal does not keep order)
// Sets related.R.Containers.
func (o *Container) RemoveLabels(exec boil.Executor, related ...*Label) error {
var err error
query := fmt.Sprintf(
"delete from \"containers_labels\" where \"container_id\" = $1 and \"label_id\" in (%s)",
strmangle.Placeholders(dialect.IndexPlaceholders, len(related), 2, 1),
)
values := []interface{}{o.ID}
for _, rel := range related {
values = append(values, rel.ID)
}
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")
}
removeLabelsFromContainersSlice(o, related)
if o.R == nil {
return nil
}
for _, rel := range related {
for i, ri := range o.R.Labels {
if rel != ri {
continue
}
ln := len(o.R.Labels)
if ln > 1 && i < ln-1 {
o.R.Labels[i] = o.R.Labels[ln-1]
}
o.R.Labels = o.R.Labels[:ln-1]
break
}
}
return nil
}
func removeLabelsFromContainersSlice(o *Container, related []*Label) {
for _, rel := range related {
if rel.R == nil {
continue
}
for i, ri := range rel.R.Containers {
if o.ID != ri.ID {
continue
}
ln := len(rel.R.Containers)
if ln > 1 && i < ln-1 {
rel.R.Containers[i] = rel.R.Containers[ln-1]
}
rel.R.Containers = rel.R.Containers[:ln-1]
break
}
}
}
// ContainersG retrieves all records.
func ContainersG(mods ...qm.QueryMod) containerQuery {
return Containers(boil.GetDB(), mods...)
}
// Containers retrieves all the records using an executor.
func Containers(exec boil.Executor, mods ...qm.QueryMod) containerQuery {
mods = append(mods, qm.From("\"containers\""))
return containerQuery{NewQuery(exec, mods...)}
}
// FindContainerG retrieves a single record by ID.
func FindContainerG(id int, selectCols ...string) (*Container, error) {
return FindContainer(boil.GetDB(), id, selectCols...)
}
// FindContainerGP retrieves a single record by ID, and panics on error.
func FindContainerGP(id int, selectCols ...string) *Container {
retobj, err := FindContainer(boil.GetDB(), id, selectCols...)
if err != nil {
panic(boil.WrapErr(err))
}
return retobj
}
// FindContainer retrieves a single record by ID with an executor.
// If selectCols is empty Find will return all columns.
func FindContainer(exec boil.Executor, id int, selectCols ...string) (*Container, error) {
containerObj := &Container{}
sel := "*"
if len(selectCols) > 0 {
sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",")
}
query := fmt.Sprintf(
"select %s from \"containers\" where \"id\"=$1", sel,
)
q := queries.Raw(exec, query, id)
err := q.Bind(containerObj)
if err != nil {
if errors.Cause(err) == sql.ErrNoRows {
return nil, sql.ErrNoRows
}
return nil, errors.Wrap(err, "kmodels: unable to select from containers")
}
return containerObj, nil
}
// FindContainerP retrieves a single record by ID with an executor, and panics on error.
func FindContainerP(exec boil.Executor, id int, selectCols ...string) *Container {
retobj, err := FindContainer(exec, id, selectCols...)
if err != nil {
panic(boil.WrapErr(err))
}
return retobj
}
// InsertG a single record. See Insert for whitelist behavior description.
func (o *Container) InsertG(whitelist ...string) error {
return o.Insert(boil.GetDB(), whitelist...)
}
// InsertGP a single record, and panics on error. See Insert for whitelist
// behavior description.
func (o *Container) InsertGP(whitelist ...string) {
if err := o.Insert(boil.GetDB(), whitelist...); err != nil {
panic(boil.WrapErr(err))
}
}
// InsertP a single record using an executor, and panics on error. See Insert
// for whitelist behavior description.
func (o *Container) InsertP(exec boil.Executor, whitelist ...string) {
if err := o.Insert(exec, whitelist...); err != nil {
panic(boil.WrapErr(err))
}
}
// Insert a single record using an executor.
// Whitelist behavior: If a whitelist is provided, only those columns supplied are inserted
// No whitelist behavior: Without a whitelist, columns are inferred by the following rules:
// - All columns without a default value are included (i.e. name, age)
// - All columns with a default, but non-zero are included (i.e. health = 75)
func (o *Container) Insert(exec boil.Executor, whitelist ...string) error {
if o == nil {
return errors.New("kmodels: no containers provided for insertion")
}
var err error
currTime := time.Now().In(boil.GetLocation())
if o.CreatedAt.Time.IsZero() {
o.CreatedAt.Time = currTime
o.CreatedAt.Valid = true
}
if o.UpdatedAt.Time.IsZero() {
o.UpdatedAt.Time = currTime
o.UpdatedAt.Valid = true
}
nzDefaults := queries.NonZeroDefaultSet(containerColumnsWithDefault, o)
key := makeCacheKey(whitelist, nzDefaults)
containerInsertCacheMut.RLock()
cache, cached := containerInsertCache[key]
containerInsertCacheMut.RUnlock()
if !cached {
wl, returnColumns := strmangle.InsertColumnSet(
containerColumns,
containerColumnsWithDefault,
containerColumnsWithoutDefault,
nzDefaults,
whitelist,
)
cache.valueMapping, err = queries.BindMapping(containerType, containerMapping, wl)
if err != nil {
return err
}
cache.retMapping, err = queries.BindMapping(containerType, containerMapping, returnColumns)
if err != nil {
return err
}
if len(wl) != 0 {
cache.query = fmt.Sprintf("INSERT INTO \"containers\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.IndexPlaceholders, len(wl), 1, 1))
} else {
cache.query = "INSERT INTO \"containers\" DEFAULT VALUES"
}
var queryOutput, queryReturning string
if len(cache.retMapping) != 0 {
queryReturning = fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\""))
}
if len(wl) != 0 {
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)
}
if len(cache.retMapping) != 0 {
err = exec.QueryRow(cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...)
} else {
_, err = exec.Exec(cache.query, vals...)
}
if err != nil {
return errors.Wrap(err, "kmodels: unable to insert into containers")
}
if !cached {
containerInsertCacheMut.Lock()
containerInsertCache[key] = cache
containerInsertCacheMut.Unlock()
}
return nil
}
// UpdateG a single Container record. See Update for
// whitelist behavior description.
func (o *Container) UpdateG(whitelist ...string) error {
return o.Update(boil.GetDB(), whitelist...)
}
// UpdateGP a single Container record.
// UpdateGP takes a whitelist of column names that should be updated.
// Panics on error. See Update for whitelist behavior description.
func (o *Container) UpdateGP(whitelist ...string) {
if err := o.Update(boil.GetDB(), whitelist...); err != nil {
panic(boil.WrapErr(err))
}
}
// UpdateP uses an executor to update the Container, and panics on error.
// See Update for whitelist behavior description.
func (o *Container) UpdateP(exec boil.Executor, whitelist ...string) {
err := o.Update(exec, whitelist...)
if err != nil {
panic(boil.WrapErr(err))
}
}
// Update uses an executor to update the Container.
// Whitelist behavior: If a whitelist is provided, only the columns given are updated.
// No whitelist behavior: Without a whitelist, columns are inferred by the following rules:
// - All columns are inferred to start with
// - All primary keys are subtracted from this set
// Update does not automatically update the record in case of default values. Use .Reload()
// to refresh the records.
func (o *Container) Update(exec boil.Executor, whitelist ...string) error {
currTime := time.Now().In(boil.GetLocation())
o.UpdatedAt.Time = currTime
o.UpdatedAt.Valid = true
var err error
key := makeCacheKey(whitelist, nil)
containerUpdateCacheMut.RLock()
cache, cached := containerUpdateCache[key]
containerUpdateCacheMut.RUnlock()
if !cached {
wl := strmangle.UpdateColumnSet(
containerColumns,
containerPrimaryKeyColumns,
whitelist,
)
if len(whitelist) == 0 {
wl = strmangle.SetComplement(wl, []string{"created_at"})
}
if len(wl) == 0 {
return errors.New("kmodels: unable to update containers, could not build whitelist")
}
cache.query = fmt.Sprintf("UPDATE \"containers\" SET %s WHERE %s",
strmangle.SetParamNames("\"", "\"", 1, wl),
strmangle.WhereClause("\"", "\"", len(wl)+1, containerPrimaryKeyColumns),
)
cache.valueMapping, err = queries.BindMapping(containerType, containerMapping, append(wl, containerPrimaryKeyColumns...))
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, "kmodels: unable to update containers row")
}
if !cached {
containerUpdateCacheMut.Lock()
containerUpdateCache[key] = cache
containerUpdateCacheMut.Unlock()
}
return nil
}
// UpdateAllP updates all rows with matching column names, and panics on error.
func (q containerQuery) UpdateAllP(cols M) {
if err := q.UpdateAll(cols); err != nil {
panic(boil.WrapErr(err))
}
}
// UpdateAll updates all rows with the specified column values.
func (q containerQuery) UpdateAll(cols M) error {
queries.SetUpdate(q.Query, cols)
_, err := q.Query.Exec()
if err != nil {
return errors.Wrap(err, "kmodels: unable to update all for containers")
}
return nil
}
// UpdateAllG updates all rows with the specified column values.
func (o ContainerSlice) UpdateAllG(cols M) error {
return o.UpdateAll(boil.GetDB(), cols)
}
// UpdateAllGP updates all rows with the specified column values, and panics on error.
func (o ContainerSlice) UpdateAllGP(cols M) {
if err := o.UpdateAll(boil.GetDB(), cols); err != nil {
panic(boil.WrapErr(err))
}
}
// UpdateAllP updates all rows with the specified column values, and panics on error.
func (o ContainerSlice) UpdateAllP(exec boil.Executor, cols M) {
if err := o.UpdateAll(exec, cols); err != nil {
panic(boil.WrapErr(err))
}
}
// UpdateAll updates all rows with the specified column values, using an executor.
func (o ContainerSlice) UpdateAll(exec boil.Executor, cols M) error {
ln := int64(len(o))
if ln == 0 {
return nil
}
if len(cols) == 0 {
return errors.New("kmodels: 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)), containerPrimaryKeyMapping)
args = append(args, pkeyArgs...)
}
sql := fmt.Sprintf("UPDATE \"containers\" SET %s WHERE %s",
strmangle.SetParamNames("\"", "\"", 1, colNames),
strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, containerPrimaryKeyColumns, 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, "kmodels: unable to update all in container slice")
}
return nil
}
// UpsertG attempts an insert, and does an update or ignore on conflict.
func (o *Container) UpsertG(updateOnConflict bool, conflictColumns []string, updateColumns []string, whitelist ...string) error {
return o.Upsert(boil.GetDB(), updateOnConflict, conflictColumns, updateColumns, whitelist...)
}
// UpsertGP attempts an insert, and does an update or ignore on conflict. Panics on error.
func (o *Container) UpsertGP(updateOnConflict bool, conflictColumns []string, updateColumns []string, whitelist ...string) {
if err := o.Upsert(boil.GetDB(), updateOnConflict, conflictColumns, updateColumns, whitelist...); err != nil {
panic(boil.WrapErr(err))
}
}
// UpsertP attempts an insert using an executor, and does an update or ignore on conflict.
// UpsertP panics on error.
func (o *Container) UpsertP(exec boil.Executor, updateOnConflict bool, conflictColumns []string, updateColumns []string, whitelist ...string) {
if err := o.Upsert(exec, updateOnConflict, conflictColumns, updateColumns, whitelist...); err != nil {
panic(boil.WrapErr(err))
}
}
// Upsert attempts an insert using an executor, and does an update or ignore on conflict.
func (o *Container) Upsert(exec boil.Executor, updateOnConflict bool, conflictColumns []string, updateColumns []string, whitelist ...string) error {
if o == nil {
return errors.New("kmodels: no containers provided for upsert")
}
currTime := time.Now().In(boil.GetLocation())
if o.CreatedAt.Time.IsZero() {
o.CreatedAt.Time = currTime
o.CreatedAt.Valid = true
}
o.UpdatedAt.Time = currTime
o.UpdatedAt.Valid = true
nzDefaults := queries.NonZeroDefaultSet(containerColumnsWithDefault, o)
// Build cache key in-line uglily - mysql vs postgres problems
buf := strmangle.GetBuffer()
if updateOnConflict {
buf.WriteByte('t')
} else {
buf.WriteByte('f')
}
buf.WriteByte('.')
for _, c := range conflictColumns {
buf.WriteString(c)
}
buf.WriteByte('.')
for _, c := range updateColumns {
buf.WriteString(c)
}
buf.WriteByte('.')
for _, c := range whitelist {
buf.WriteString(c)
}
buf.WriteByte('.')
for _, c := range nzDefaults {
buf.WriteString(c)
}
key := buf.String()
strmangle.PutBuffer(buf)
containerUpsertCacheMut.RLock()
cache, cached := containerUpsertCache[key]
containerUpsertCacheMut.RUnlock()
var err error
if !cached {
insert, ret := strmangle.InsertColumnSet(
containerColumns,
containerColumnsWithDefault,
containerColumnsWithoutDefault,
nzDefaults,
whitelist,
)
update := strmangle.UpdateColumnSet(
containerColumns,
containerPrimaryKeyColumns,
updateColumns,
)
if len(update) == 0 {
return errors.New("kmodels: unable to upsert containers, could not build update column list")
}
conflict := conflictColumns
if len(conflict) == 0 {
conflict = make([]string, len(containerPrimaryKeyColumns))
copy(conflict, containerPrimaryKeyColumns)
}
cache.query = queries.BuildUpsertQueryPostgres(dialect, "\"containers\"", updateOnConflict, ret, update, conflict, insert)
cache.valueMapping, err = queries.BindMapping(containerType, containerMapping, insert)
if err != nil {
return err
}
if len(ret) != 0 {
cache.retMapping, err = queries.BindMapping(containerType, containerMapping, 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)
}
if len(cache.retMapping) != 0 {
err = exec.QueryRow(cache.query, vals...).Scan(returns...)
if err == sql.ErrNoRows {
err = nil // Postgres doesn't return anything when there's no update
}
} else {
_, err = exec.Exec(cache.query, vals...)
}
if err != nil {
return errors.Wrap(err, "kmodels: unable to upsert containers")
}
if !cached {
containerUpsertCacheMut.Lock()
containerUpsertCache[key] = cache
containerUpsertCacheMut.Unlock()
}
return nil
}
// DeleteP deletes a single Container record with an executor.
// DeleteP will match against the primary key column to find the record to delete.
// Panics on error.
func (o *Container) DeleteP(exec boil.Executor) {
if err := o.Delete(exec); err != nil {
panic(boil.WrapErr(err))
}
}
// DeleteG deletes a single Container record.
// DeleteG will match against the primary key column to find the record to delete.
func (o *Container) DeleteG() error {
if o == nil {
return errors.New("kmodels: no Container provided for deletion")
}
return o.Delete(boil.GetDB())
}
// DeleteGP deletes a single Container record.
// DeleteGP will match against the primary key column to find the record to delete.
// Panics on error.
func (o *Container) DeleteGP() {
if err := o.DeleteG(); err != nil {
panic(boil.WrapErr(err))
}
}
// Delete deletes a single Container record with an executor.
// Delete will match against the primary key column to find the record to delete.
func (o *Container) Delete(exec boil.Executor) error {
if o == nil {
return errors.New("kmodels: no Container provided for delete")
}
args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), containerPrimaryKeyMapping)
sql := "DELETE FROM \"containers\" WHERE \"id\"=$1"
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, "kmodels: unable to delete from containers")
}
return nil
}
// DeleteAllP deletes all rows, and panics on error.
func (q containerQuery) DeleteAllP() {
if err := q.DeleteAll(); err != nil {
panic(boil.WrapErr(err))
}
}
// DeleteAll deletes all matching rows.
func (q containerQuery) DeleteAll() error {
if q.Query == nil {
return errors.New("kmodels: no containerQuery provided for delete all")
}
queries.SetDelete(q.Query)
_, err := q.Query.Exec()
if err != nil {
return errors.Wrap(err, "kmodels: unable to delete all from containers")
}
return nil
}
// DeleteAllGP deletes all rows in the slice, and panics on error.
func (o ContainerSlice) DeleteAllGP() {
if err := o.DeleteAllG(); err != nil {
panic(boil.WrapErr(err))
}
}
// DeleteAllG deletes all rows in the slice.
func (o ContainerSlice) DeleteAllG() error {
if o == nil {
return errors.New("kmodels: no Container slice provided for delete all")
}
return o.DeleteAll(boil.GetDB())
}
// DeleteAllP deletes all rows in the slice, using an executor, and panics on error.
func (o ContainerSlice) DeleteAllP(exec boil.Executor) {
if err := o.DeleteAll(exec); err != nil {
panic(boil.WrapErr(err))
}
}
// DeleteAll deletes all rows in the slice, using an executor.
func (o ContainerSlice) DeleteAll(exec boil.Executor) error {
if o == nil {
return errors.New("kmodels: no Container slice provided for delete all")
}
if len(o) == 0 {
return nil
}
var args []interface{}
for _, obj := range o {
pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), containerPrimaryKeyMapping)
args = append(args, pkeyArgs...)
}
sql := "DELETE FROM \"containers\" WHERE " +
strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, containerPrimaryKeyColumns, 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, "kmodels: unable to delete all from container slice")
}
return nil
}
// ReloadGP refetches the object from the database and panics on error.
func (o *Container) ReloadGP() {
if err := o.ReloadG(); err != nil {
panic(boil.WrapErr(err))
}
}
// ReloadP refetches the object from the database with an executor. Panics on error.
func (o *Container) ReloadP(exec boil.Executor) {
if err := o.Reload(exec); err != nil {
panic(boil.WrapErr(err))
}
}
// ReloadG refetches the object from the database using the primary keys.
func (o *Container) ReloadG() error {
if o == nil {
return errors.New("kmodels: no Container provided for reload")
}
return o.Reload(boil.GetDB())
}
// Reload refetches the object from the database
// using the primary keys with an executor.
func (o *Container) Reload(exec boil.Executor) error {
ret, err := FindContainer(exec, o.ID)
if err != nil {
return err
}
*o = *ret
return nil
}
// ReloadAllGP refetches every row with matching primary key column values
// and overwrites the original object slice with the newly updated slice.
// Panics on error.
func (o *ContainerSlice) ReloadAllGP() {
if err := o.ReloadAllG(); err != nil {
panic(boil.WrapErr(err))
}
}
// ReloadAllP refetches every row with matching primary key column values
// and overwrites the original object slice with the newly updated slice.
// Panics on error.
func (o *ContainerSlice) ReloadAllP(exec boil.Executor) {
if err := o.ReloadAll(exec); err != nil {
panic(boil.WrapErr(err))
}
}
// ReloadAllG refetches every row with matching primary key column values
// and overwrites the original object slice with the newly updated slice.
func (o *ContainerSlice) ReloadAllG() error {
if o == nil {
return errors.New("kmodels: empty ContainerSlice provided for reload all")
}
return o.ReloadAll(boil.GetDB())
}
// ReloadAll refetches every row with matching primary key column values
// and overwrites the original object slice with the newly updated slice.
func (o *ContainerSlice) ReloadAll(exec boil.Executor) error {
if o == nil || len(*o) == 0 {
return nil
}
containers := ContainerSlice{}
var args []interface{}
for _, obj := range *o {
pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), containerPrimaryKeyMapping)
args = append(args, pkeyArgs...)
}
sql := "SELECT \"containers\".* FROM \"containers\" WHERE " +
strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, containerPrimaryKeyColumns, len(*o))
q := queries.Raw(exec, sql, args...)
err := q.Bind(&containers)
if err != nil {
return errors.Wrap(err, "kmodels: unable to reload all in ContainerSlice")
}
*o = containers
return nil
}
// ContainerExists checks if the Container row exists.
func ContainerExists(exec boil.Executor, id int) (bool, error) {
var exists bool
sql := "select exists(select 1 from \"containers\" where \"id\"=$1 limit 1)"
if boil.DebugMode {
fmt.Fprintln(boil.DebugWriter, sql)
fmt.Fprintln(boil.DebugWriter, id)
}
row := exec.QueryRow(sql, id)
err := row.Scan(&exists)
if err != nil {
return false, errors.Wrap(err, "kmodels: unable to check if containers exists")
}
return exists, nil
}
// ContainerExistsG checks if the Container row exists.
func ContainerExistsG(id int) (bool, error) {
return ContainerExists(boil.GetDB(), id)
}
// ContainerExistsGP checks if the Container row exists. Panics on error.
func ContainerExistsGP(id int) bool {
e, err := ContainerExists(boil.GetDB(), id)
if err != nil {
panic(boil.WrapErr(err))
}
return e
}
// ContainerExistsP checks if the Container row exists. Panics on error.
func ContainerExistsP(exec boil.Executor, id int) bool {
e, err := ContainerExists(exec, id)
if err != nil {
panic(boil.WrapErr(err))
}
return e
}