// Update uses an executor to update the AuthRolePermission.
// 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 *AuthRolePermission) Update(exec boil.Executor, whitelist ...string) error {
currTime := time.Now().In(boil.GetLocation())
o.UpdatedAt.Time = currTime
o.UpdatedAt.Valid = true
var err error
if err = o.doBeforeUpdateHooks(exec); err != nil {
return err
}
key := makeCacheKey(whitelist, nil)
authRolePermissionUpdateCacheMut.RLock()
cache, cached := authRolePermissionUpdateCache[key]
authRolePermissionUpdateCacheMut.RUnlock()
if !cached {
wl := strmangle.UpdateColumnSet(authRolePermissionColumns, authRolePermissionPrimaryKeyColumns, whitelist)
if len(wl) == 0 {
return errors.New("chado: unable to update auth_role_permission, could not build whitelist")
}
cache.query = fmt.Sprintf("UPDATE \"auth_role_permission\" SET %s WHERE %s",
strmangle.SetParamNames("\"", "\"", 1, wl),
strmangle.WhereClause("\"", "\"", len(wl)+1, authRolePermissionPrimaryKeyColumns),
)
cache.valueMapping, err = queries.BindMapping(authRolePermissionType, authRolePermissionMapping, append(wl, authRolePermissionPrimaryKeyColumns...))
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, "chado: unable to update auth_role_permission row")
}
if !cached {
authRolePermissionUpdateCacheMut.Lock()
authRolePermissionUpdateCache[key] = cache
authRolePermissionUpdateCacheMut.Unlock()
}
return o.doAfterUpdateHooks(exec)
}
// Update uses an executor to update the FeaturepropPub.
// 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 *FeaturepropPub) Update(exec boil.Executor, whitelist ...string) error {
var err error
if err = o.doBeforeUpdateHooks(exec); err != nil {
return err
}
key := makeCacheKey(whitelist, nil)
featurepropPubUpdateCacheMut.RLock()
cache, cached := featurepropPubUpdateCache[key]
featurepropPubUpdateCacheMut.RUnlock()
if !cached {
wl := strmangle.UpdateColumnSet(featurepropPubColumns, featurepropPubPrimaryKeyColumns, whitelist)
if len(wl) == 0 {
return errors.New("chado: unable to update featureprop_pub, could not build whitelist")
}
cache.query = fmt.Sprintf("UPDATE \"featureprop_pub\" SET %s WHERE %s",
strmangle.SetParamNames("\"", "\"", 1, wl),
strmangle.WhereClause("\"", "\"", len(wl)+1, featurepropPubPrimaryKeyColumns),
)
cache.valueMapping, err = queries.BindMapping(featurepropPubType, featurepropPubMapping, append(wl, featurepropPubPrimaryKeyColumns...))
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, "chado: unable to update featureprop_pub row")
}
if !cached {
featurepropPubUpdateCacheMut.Lock()
featurepropPubUpdateCache[key] = cache
featurepropPubUpdateCacheMut.Unlock()
}
return o.doAfterUpdateHooks(exec)
}
// PhenotypepropSlice is an alias for a slice of pointers to Phenotypeprop.
// This should generally be used opposed to []Phenotypeprop.
PhenotypepropSlice []*Phenotypeprop
// PhenotypepropHook is the signature for custom Phenotypeprop hook methods
PhenotypepropHook func(boil.Executor, *Phenotypeprop) error
phenotypepropQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
phenotypepropType = reflect.TypeOf(&Phenotypeprop{})
phenotypepropMapping = queries.MakeStructMapping(phenotypepropType)
phenotypepropPrimaryKeyMapping, _ = queries.BindMapping(phenotypepropType, phenotypepropMapping, phenotypepropPrimaryKeyColumns)
phenotypepropInsertCacheMut sync.RWMutex
phenotypepropInsertCache = make(map[string]insertCache)
phenotypepropUpdateCacheMut sync.RWMutex
phenotypepropUpdateCache = make(map[string]updateCache)
phenotypepropUpsertCacheMut sync.RWMutex
phenotypepropUpsertCache = 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
)
var phenotypepropBeforeInsertHooks []PhenotypepropHook
// FeaturepropPubSlice is an alias for a slice of pointers to FeaturepropPub.
// This should generally be used opposed to []FeaturepropPub.
FeaturepropPubSlice []*FeaturepropPub
// FeaturepropPubHook is the signature for custom FeaturepropPub hook methods
FeaturepropPubHook func(boil.Executor, *FeaturepropPub) error
featurepropPubQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
featurepropPubType = reflect.TypeOf(&FeaturepropPub{})
featurepropPubMapping = queries.MakeStructMapping(featurepropPubType)
featurepropPubPrimaryKeyMapping, _ = queries.BindMapping(featurepropPubType, featurepropPubMapping, featurepropPubPrimaryKeyColumns)
featurepropPubInsertCacheMut sync.RWMutex
featurepropPubInsertCache = make(map[string]insertCache)
featurepropPubUpdateCacheMut sync.RWMutex
featurepropPubUpdateCache = make(map[string]updateCache)
featurepropPubUpsertCacheMut sync.RWMutex
featurepropPubUpsertCache = 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
)
var featurepropPubBeforeInsertHooks []FeaturepropPubHook
// TableinfoSlice is an alias for a slice of pointers to Tableinfo.
// This should generally be used opposed to []Tableinfo.
TableinfoSlice []*Tableinfo
// TableinfoHook is the signature for custom Tableinfo hook methods
TableinfoHook func(boil.Executor, *Tableinfo) error
tableinfoQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
tableinfoType = reflect.TypeOf(&Tableinfo{})
tableinfoMapping = queries.MakeStructMapping(tableinfoType)
tableinfoPrimaryKeyMapping, _ = queries.BindMapping(tableinfoType, tableinfoMapping, tableinfoPrimaryKeyColumns)
tableinfoInsertCacheMut sync.RWMutex
tableinfoInsertCache = make(map[string]insertCache)
tableinfoUpdateCacheMut sync.RWMutex
tableinfoUpdateCache = make(map[string]updateCache)
tableinfoUpsertCacheMut sync.RWMutex
tableinfoUpsertCache = 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
)
var tableinfoBeforeInsertHooks []TableinfoHook
// FeatureCvtermpropSlice is an alias for a slice of pointers to FeatureCvtermprop.
// This should generally be used opposed to []FeatureCvtermprop.
FeatureCvtermpropSlice []*FeatureCvtermprop
// FeatureCvtermpropHook is the signature for custom FeatureCvtermprop hook methods
FeatureCvtermpropHook func(boil.Executor, *FeatureCvtermprop) error
featureCvtermpropQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
featureCvtermpropType = reflect.TypeOf(&FeatureCvtermprop{})
featureCvtermpropMapping = queries.MakeStructMapping(featureCvtermpropType)
featureCvtermpropPrimaryKeyMapping, _ = queries.BindMapping(featureCvtermpropType, featureCvtermpropMapping, featureCvtermpropPrimaryKeyColumns)
featureCvtermpropInsertCacheMut sync.RWMutex
featureCvtermpropInsertCache = make(map[string]insertCache)
featureCvtermpropUpdateCacheMut sync.RWMutex
featureCvtermpropUpdateCache = make(map[string]updateCache)
featureCvtermpropUpsertCacheMut sync.RWMutex
featureCvtermpropUpsertCache = 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
)
var featureCvtermpropBeforeInsertHooks []FeatureCvtermpropHook
// AnalysisfeatureSlice is an alias for a slice of pointers to Analysisfeature.
// This should generally be used opposed to []Analysisfeature.
AnalysisfeatureSlice []*Analysisfeature
// AnalysisfeatureHook is the signature for custom Analysisfeature hook methods
AnalysisfeatureHook func(boil.Executor, *Analysisfeature) error
analysisfeatureQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
analysisfeatureType = reflect.TypeOf(&Analysisfeature{})
analysisfeatureMapping = queries.MakeStructMapping(analysisfeatureType)
analysisfeaturePrimaryKeyMapping, _ = queries.BindMapping(analysisfeatureType, analysisfeatureMapping, analysisfeaturePrimaryKeyColumns)
analysisfeatureInsertCacheMut sync.RWMutex
analysisfeatureInsertCache = make(map[string]insertCache)
analysisfeatureUpdateCacheMut sync.RWMutex
analysisfeatureUpdateCache = make(map[string]updateCache)
analysisfeatureUpsertCacheMut sync.RWMutex
analysisfeatureUpsertCache = 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
)
var analysisfeatureBeforeInsertHooks []AnalysisfeatureHook
// StockcollectionSlice is an alias for a slice of pointers to Stockcollection.
// This should generally be used opposed to []Stockcollection.
StockcollectionSlice []*Stockcollection
// StockcollectionHook is the signature for custom Stockcollection hook methods
StockcollectionHook func(boil.Executor, *Stockcollection) error
stockcollectionQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
stockcollectionType = reflect.TypeOf(&Stockcollection{})
stockcollectionMapping = queries.MakeStructMapping(stockcollectionType)
stockcollectionPrimaryKeyMapping, _ = queries.BindMapping(stockcollectionType, stockcollectionMapping, stockcollectionPrimaryKeyColumns)
stockcollectionInsertCacheMut sync.RWMutex
stockcollectionInsertCache = make(map[string]insertCache)
stockcollectionUpdateCacheMut sync.RWMutex
stockcollectionUpdateCache = make(map[string]updateCache)
stockcollectionUpsertCacheMut sync.RWMutex
stockcollectionUpsertCache = 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
)
var stockcollectionBeforeInsertHooks []StockcollectionHook
// FileSlice is an alias for a slice of pointers to File.
// This should generally be used opposed to []File.
FileSlice []*File
// FileHook is the signature for custom File hook methods
FileHook func(boil.Executor, *File) error
fileQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
fileType = reflect.TypeOf(&File{})
fileMapping = queries.MakeStructMapping(fileType)
filePrimaryKeyMapping, _ = queries.BindMapping(fileType, fileMapping, filePrimaryKeyColumns)
fileInsertCacheMut sync.RWMutex
fileInsertCache = make(map[string]insertCache)
fileUpdateCacheMut sync.RWMutex
fileUpdateCache = make(map[string]updateCache)
fileUpsertCacheMut sync.RWMutex
fileUpsertCache = 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
)
var fileBeforeInsertHooks []FileHook
// PubRelationshipSlice is an alias for a slice of pointers to PubRelationship.
// This should generally be used opposed to []PubRelationship.
PubRelationshipSlice []*PubRelationship
// PubRelationshipHook is the signature for custom PubRelationship hook methods
PubRelationshipHook func(boil.Executor, *PubRelationship) error
pubRelationshipQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
pubRelationshipType = reflect.TypeOf(&PubRelationship{})
pubRelationshipMapping = queries.MakeStructMapping(pubRelationshipType)
pubRelationshipPrimaryKeyMapping, _ = queries.BindMapping(pubRelationshipType, pubRelationshipMapping, pubRelationshipPrimaryKeyColumns)
pubRelationshipInsertCacheMut sync.RWMutex
pubRelationshipInsertCache = make(map[string]insertCache)
pubRelationshipUpdateCacheMut sync.RWMutex
pubRelationshipUpdateCache = make(map[string]updateCache)
pubRelationshipUpsertCacheMut sync.RWMutex
pubRelationshipUpsertCache = 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
)
var pubRelationshipBeforeInsertHooks []PubRelationshipHook
// PubpropSlice is an alias for a slice of pointers to Pubprop.
// This should generally be used opposed to []Pubprop.
PubpropSlice []*Pubprop
// PubpropHook is the signature for custom Pubprop hook methods
PubpropHook func(boil.Executor, *Pubprop) error
pubpropQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
pubpropType = reflect.TypeOf(&Pubprop{})
pubpropMapping = queries.MakeStructMapping(pubpropType)
pubpropPrimaryKeyMapping, _ = queries.BindMapping(pubpropType, pubpropMapping, pubpropPrimaryKeyColumns)
pubpropInsertCacheMut sync.RWMutex
pubpropInsertCache = make(map[string]insertCache)
pubpropUpdateCacheMut sync.RWMutex
pubpropUpdateCache = make(map[string]updateCache)
pubpropUpsertCacheMut sync.RWMutex
pubpropUpsertCache = 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
)
var pubpropBeforeInsertHooks []PubpropHook
// PhenstatementSlice is an alias for a slice of pointers to Phenstatement.
// This should generally be used opposed to []Phenstatement.
PhenstatementSlice []*Phenstatement
// PhenstatementHook is the signature for custom Phenstatement hook methods
PhenstatementHook func(boil.Executor, *Phenstatement) error
phenstatementQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
phenstatementType = reflect.TypeOf(&Phenstatement{})
phenstatementMapping = queries.MakeStructMapping(phenstatementType)
phenstatementPrimaryKeyMapping, _ = queries.BindMapping(phenstatementType, phenstatementMapping, phenstatementPrimaryKeyColumns)
phenstatementInsertCacheMut sync.RWMutex
phenstatementInsertCache = make(map[string]insertCache)
phenstatementUpdateCacheMut sync.RWMutex
phenstatementUpdateCache = make(map[string]updateCache)
phenstatementUpsertCacheMut sync.RWMutex
phenstatementUpsertCache = 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
)
var phenstatementBeforeInsertHooks []PhenstatementHook
// AuthUserInfoSlice is an alias for a slice of pointers to AuthUserInfo.
// This should generally be used opposed to []AuthUserInfo.
AuthUserInfoSlice []*AuthUserInfo
// AuthUserInfoHook is the signature for custom AuthUserInfo hook methods
AuthUserInfoHook func(boil.Executor, *AuthUserInfo) error
authUserInfoQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
authUserInfoType = reflect.TypeOf(&AuthUserInfo{})
authUserInfoMapping = queries.MakeStructMapping(authUserInfoType)
authUserInfoPrimaryKeyMapping, _ = queries.BindMapping(authUserInfoType, authUserInfoMapping, authUserInfoPrimaryKeyColumns)
authUserInfoInsertCacheMut sync.RWMutex
authUserInfoInsertCache = make(map[string]insertCache)
authUserInfoUpdateCacheMut sync.RWMutex
authUserInfoUpdateCache = make(map[string]updateCache)
authUserInfoUpsertCacheMut sync.RWMutex
authUserInfoUpsertCache = 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
)
var authUserInfoBeforeInsertHooks []AuthUserInfoHook
// EnvironmentCvtermSlice is an alias for a slice of pointers to EnvironmentCvterm.
// This should generally be used opposed to []EnvironmentCvterm.
EnvironmentCvtermSlice []*EnvironmentCvterm
// EnvironmentCvtermHook is the signature for custom EnvironmentCvterm hook methods
EnvironmentCvtermHook func(boil.Executor, *EnvironmentCvterm) error
environmentCvtermQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
environmentCvtermType = reflect.TypeOf(&EnvironmentCvterm{})
environmentCvtermMapping = queries.MakeStructMapping(environmentCvtermType)
environmentCvtermPrimaryKeyMapping, _ = queries.BindMapping(environmentCvtermType, environmentCvtermMapping, environmentCvtermPrimaryKeyColumns)
environmentCvtermInsertCacheMut sync.RWMutex
environmentCvtermInsertCache = make(map[string]insertCache)
environmentCvtermUpdateCacheMut sync.RWMutex
environmentCvtermUpdateCache = make(map[string]updateCache)
environmentCvtermUpsertCacheMut sync.RWMutex
environmentCvtermUpsertCache = 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
)
var environmentCvtermBeforeInsertHooks []EnvironmentCvtermHook
// CvtermpropSlice is an alias for a slice of pointers to Cvtermprop.
// This should generally be used opposed to []Cvtermprop.
CvtermpropSlice []*Cvtermprop
// CvtermpropHook is the signature for custom Cvtermprop hook methods
CvtermpropHook func(boil.Executor, *Cvtermprop) error
cvtermpropQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
cvtermpropType = reflect.TypeOf(&Cvtermprop{})
cvtermpropMapping = queries.MakeStructMapping(cvtermpropType)
cvtermpropPrimaryKeyMapping, _ = queries.BindMapping(cvtermpropType, cvtermpropMapping, cvtermpropPrimaryKeyColumns)
cvtermpropInsertCacheMut sync.RWMutex
cvtermpropInsertCache = make(map[string]insertCache)
cvtermpropUpdateCacheMut sync.RWMutex
cvtermpropUpdateCache = make(map[string]updateCache)
cvtermpropUpsertCacheMut sync.RWMutex
cvtermpropUpsertCache = 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
)
var cvtermpropBeforeInsertHooks []CvtermpropHook
// CVSlice is an alias for a slice of pointers to CV.
// This should generally be used opposed to []CV.
CVSlice []*CV
// CVHook is the signature for custom CV hook methods
CVHook func(boil.Executor, *CV) error
cvQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
cvType = reflect.TypeOf(&CV{})
cvMapping = queries.MakeStructMapping(cvType)
cvPrimaryKeyMapping, _ = queries.BindMapping(cvType, cvMapping, cvPrimaryKeyColumns)
cvInsertCacheMut sync.RWMutex
cvInsertCache = make(map[string]insertCache)
cvUpdateCacheMut sync.RWMutex
cvUpdateCache = make(map[string]updateCache)
cvUpsertCacheMut sync.RWMutex
cvUpsertCache = 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
)
var cvBeforeInsertHooks []CVHook
// Upsert attempts an insert using an executor, and does an update or ignore on conflict.
func (o *AuthRolePermission) Upsert(exec boil.Executor, updateOnConflict bool, conflictColumns []string, updateColumns []string, whitelist ...string) error {
if o == nil {
return errors.New("chado: no auth_role_permission 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
if err := o.doBeforeUpsertHooks(exec); err != nil {
return err
}
nzDefaults := queries.NonZeroDefaultSet(authRolePermissionColumnsWithDefault, 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)
authRolePermissionUpsertCacheMut.RLock()
cache, cached := authRolePermissionUpsertCache[key]
authRolePermissionUpsertCacheMut.RUnlock()
var err error
if !cached {
var ret []string
whitelist, ret = strmangle.InsertColumnSet(
authRolePermissionColumns,
authRolePermissionColumnsWithDefault,
authRolePermissionColumnsWithoutDefault,
nzDefaults,
whitelist,
)
update := strmangle.UpdateColumnSet(
authRolePermissionColumns,
authRolePermissionPrimaryKeyColumns,
updateColumns,
)
if len(update) == 0 {
return errors.New("chado: unable to upsert auth_role_permission, could not build update column list")
}
conflict := conflictColumns
if len(conflict) == 0 {
conflict = make([]string, len(authRolePermissionPrimaryKeyColumns))
copy(conflict, authRolePermissionPrimaryKeyColumns)
}
cache.query = queries.BuildUpsertQueryPostgres(dialect, "\"auth_role_permission\"", updateOnConflict, ret, update, conflict, whitelist)
cache.valueMapping, err = queries.BindMapping(authRolePermissionType, authRolePermissionMapping, whitelist)
if err != nil {
return err
}
if len(ret) != 0 {
cache.retMapping, err = queries.BindMapping(authRolePermissionType, authRolePermissionMapping, 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...)
} else {
_, err = exec.Exec(cache.query, vals...)
}
if err != nil {
return errors.Wrap(err, "chado: unable to upsert for auth_role_permission")
}
if !cached {
authRolePermissionUpsertCacheMut.Lock()
authRolePermissionUpsertCache[key] = cache
authRolePermissionUpsertCacheMut.Unlock()
}
return o.doAfterUpsertHooks(exec)
}
// DbxrefpropSlice is an alias for a slice of pointers to Dbxrefprop.
// This should generally be used opposed to []Dbxrefprop.
DbxrefpropSlice []*Dbxrefprop
// DbxrefpropHook is the signature for custom Dbxrefprop hook methods
DbxrefpropHook func(boil.Executor, *Dbxrefprop) error
dbxrefpropQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
dbxrefpropType = reflect.TypeOf(&Dbxrefprop{})
dbxrefpropMapping = queries.MakeStructMapping(dbxrefpropType)
dbxrefpropPrimaryKeyMapping, _ = queries.BindMapping(dbxrefpropType, dbxrefpropMapping, dbxrefpropPrimaryKeyColumns)
dbxrefpropInsertCacheMut sync.RWMutex
dbxrefpropInsertCache = make(map[string]insertCache)
dbxrefpropUpdateCacheMut sync.RWMutex
dbxrefpropUpdateCache = make(map[string]updateCache)
dbxrefpropUpsertCacheMut sync.RWMutex
dbxrefpropUpsertCache = 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
)
var dbxrefpropBeforeInsertHooks []DbxrefpropHook
// ContactSlice is an alias for a slice of pointers to Contact.
// This should generally be used opposed to []Contact.
ContactSlice []*Contact
// ContactHook is the signature for custom Contact hook methods
ContactHook func(boil.Executor, *Contact) error
contactQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
contactType = reflect.TypeOf(&Contact{})
contactMapping = queries.MakeStructMapping(contactType)
contactPrimaryKeyMapping, _ = queries.BindMapping(contactType, contactMapping, contactPrimaryKeyColumns)
contactInsertCacheMut sync.RWMutex
contactInsertCache = make(map[string]insertCache)
contactUpdateCacheMut sync.RWMutex
contactUpdateCache = make(map[string]updateCache)
contactUpsertCacheMut sync.RWMutex
contactUpsertCache = 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
)
var contactBeforeInsertHooks []ContactHook
// StockCvtermSlice is an alias for a slice of pointers to StockCvterm.
// This should generally be used opposed to []StockCvterm.
StockCvtermSlice []*StockCvterm
// StockCvtermHook is the signature for custom StockCvterm hook methods
StockCvtermHook func(boil.Executor, *StockCvterm) error
stockCvtermQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
stockCvtermType = reflect.TypeOf(&StockCvterm{})
stockCvtermMapping = queries.MakeStructMapping(stockCvtermType)
stockCvtermPrimaryKeyMapping, _ = queries.BindMapping(stockCvtermType, stockCvtermMapping, stockCvtermPrimaryKeyColumns)
stockCvtermInsertCacheMut sync.RWMutex
stockCvtermInsertCache = make(map[string]insertCache)
stockCvtermUpdateCacheMut sync.RWMutex
stockCvtermUpdateCache = make(map[string]updateCache)
stockCvtermUpsertCacheMut sync.RWMutex
stockCvtermUpsertCache = 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
)
var stockCvtermBeforeInsertHooks []StockCvtermHook
// CvtermDbxrefSlice is an alias for a slice of pointers to CvtermDbxref.
// This should generally be used opposed to []CvtermDbxref.
CvtermDbxrefSlice []*CvtermDbxref
// CvtermDbxrefHook is the signature for custom CvtermDbxref hook methods
CvtermDbxrefHook func(boil.Executor, *CvtermDbxref) error
cvtermDbxrefQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
cvtermDbxrefType = reflect.TypeOf(&CvtermDbxref{})
cvtermDbxrefMapping = queries.MakeStructMapping(cvtermDbxrefType)
cvtermDbxrefPrimaryKeyMapping, _ = queries.BindMapping(cvtermDbxrefType, cvtermDbxrefMapping, cvtermDbxrefPrimaryKeyColumns)
cvtermDbxrefInsertCacheMut sync.RWMutex
cvtermDbxrefInsertCache = make(map[string]insertCache)
cvtermDbxrefUpdateCacheMut sync.RWMutex
cvtermDbxrefUpdateCache = make(map[string]updateCache)
cvtermDbxrefUpsertCacheMut sync.RWMutex
cvtermDbxrefUpsertCache = 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
)
var cvtermDbxrefBeforeInsertHooks []CvtermDbxrefHook
// FeatureRelationshipPubSlice is an alias for a slice of pointers to FeatureRelationshipPub.
// This should generally be used opposed to []FeatureRelationshipPub.
FeatureRelationshipPubSlice []*FeatureRelationshipPub
// FeatureRelationshipPubHook is the signature for custom FeatureRelationshipPub hook methods
FeatureRelationshipPubHook func(boil.Executor, *FeatureRelationshipPub) error
featureRelationshipPubQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
featureRelationshipPubType = reflect.TypeOf(&FeatureRelationshipPub{})
featureRelationshipPubMapping = queries.MakeStructMapping(featureRelationshipPubType)
featureRelationshipPubPrimaryKeyMapping, _ = queries.BindMapping(featureRelationshipPubType, featureRelationshipPubMapping, featureRelationshipPubPrimaryKeyColumns)
featureRelationshipPubInsertCacheMut sync.RWMutex
featureRelationshipPubInsertCache = make(map[string]insertCache)
featureRelationshipPubUpdateCacheMut sync.RWMutex
featureRelationshipPubUpdateCache = make(map[string]updateCache)
featureRelationshipPubUpsertCacheMut sync.RWMutex
featureRelationshipPubUpsertCache = 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
)
var featureRelationshipPubBeforeInsertHooks []FeatureRelationshipPubHook
// AuthUserRoleSlice is an alias for a slice of pointers to AuthUserRole.
// This should generally be used opposed to []AuthUserRole.
AuthUserRoleSlice []*AuthUserRole
// AuthUserRoleHook is the signature for custom AuthUserRole hook methods
AuthUserRoleHook func(boil.Executor, *AuthUserRole) error
authUserRoleQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
authUserRoleType = reflect.TypeOf(&AuthUserRole{})
authUserRoleMapping = queries.MakeStructMapping(authUserRoleType)
authUserRolePrimaryKeyMapping, _ = queries.BindMapping(authUserRoleType, authUserRoleMapping, authUserRolePrimaryKeyColumns)
authUserRoleInsertCacheMut sync.RWMutex
authUserRoleInsertCache = make(map[string]insertCache)
authUserRoleUpdateCacheMut sync.RWMutex
authUserRoleUpdateCache = make(map[string]updateCache)
authUserRoleUpsertCacheMut sync.RWMutex
authUserRoleUpsertCache = 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
)
var authUserRoleBeforeInsertHooks []AuthUserRoleHook
// StockRelationshipCvtermSlice is an alias for a slice of pointers to StockRelationshipCvterm.
// This should generally be used opposed to []StockRelationshipCvterm.
StockRelationshipCvtermSlice []*StockRelationshipCvterm
// StockRelationshipCvtermHook is the signature for custom StockRelationshipCvterm hook methods
StockRelationshipCvtermHook func(boil.Executor, *StockRelationshipCvterm) error
stockRelationshipCvtermQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
stockRelationshipCvtermType = reflect.TypeOf(&StockRelationshipCvterm{})
stockRelationshipCvtermMapping = queries.MakeStructMapping(stockRelationshipCvtermType)
stockRelationshipCvtermPrimaryKeyMapping, _ = queries.BindMapping(stockRelationshipCvtermType, stockRelationshipCvtermMapping, stockRelationshipCvtermPrimaryKeyColumns)
stockRelationshipCvtermInsertCacheMut sync.RWMutex
stockRelationshipCvtermInsertCache = make(map[string]insertCache)
stockRelationshipCvtermUpdateCacheMut sync.RWMutex
stockRelationshipCvtermUpdateCache = make(map[string]updateCache)
stockRelationshipCvtermUpsertCacheMut sync.RWMutex
stockRelationshipCvtermUpsertCache = 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
)
var stockRelationshipCvtermBeforeInsertHooks []StockRelationshipCvtermHook
// FeatureDbxrefSlice is an alias for a slice of pointers to FeatureDbxref.
// This should generally be used opposed to []FeatureDbxref.
FeatureDbxrefSlice []*FeatureDbxref
// FeatureDbxrefHook is the signature for custom FeatureDbxref hook methods
FeatureDbxrefHook func(boil.Executor, *FeatureDbxref) error
featureDbxrefQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
featureDbxrefType = reflect.TypeOf(&FeatureDbxref{})
featureDbxrefMapping = queries.MakeStructMapping(featureDbxrefType)
featureDbxrefPrimaryKeyMapping, _ = queries.BindMapping(featureDbxrefType, featureDbxrefMapping, featureDbxrefPrimaryKeyColumns)
featureDbxrefInsertCacheMut sync.RWMutex
featureDbxrefInsertCache = make(map[string]insertCache)
featureDbxrefUpdateCacheMut sync.RWMutex
featureDbxrefUpdateCache = make(map[string]updateCache)
featureDbxrefUpsertCacheMut sync.RWMutex
featureDbxrefUpsertCache = 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
)
var featureDbxrefBeforeInsertHooks []FeatureDbxrefHook
// AuthRolePermissionSlice is an alias for a slice of pointers to AuthRolePermission.
// This should generally be used opposed to []AuthRolePermission.
AuthRolePermissionSlice []*AuthRolePermission
// AuthRolePermissionHook is the signature for custom AuthRolePermission hook methods
AuthRolePermissionHook func(boil.Executor, *AuthRolePermission) error
authRolePermissionQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
authRolePermissionType = reflect.TypeOf(&AuthRolePermission{})
authRolePermissionMapping = queries.MakeStructMapping(authRolePermissionType)
authRolePermissionPrimaryKeyMapping, _ = queries.BindMapping(authRolePermissionType, authRolePermissionMapping, authRolePermissionPrimaryKeyColumns)
authRolePermissionInsertCacheMut sync.RWMutex
authRolePermissionInsertCache = make(map[string]insertCache)
authRolePermissionUpdateCacheMut sync.RWMutex
authRolePermissionUpdateCache = make(map[string]updateCache)
authRolePermissionUpsertCacheMut sync.RWMutex
authRolePermissionUpsertCache = 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
)
var authRolePermissionBeforeInsertHooks []AuthRolePermissionHook
// 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 *FeaturepropPub) Insert(exec boil.Executor, whitelist ...string) error {
if o == nil {
return errors.New("chado: no featureprop_pub provided for insertion")
}
var err error
if err := o.doBeforeInsertHooks(exec); err != nil {
return err
}
nzDefaults := queries.NonZeroDefaultSet(featurepropPubColumnsWithDefault, o)
key := makeCacheKey(whitelist, nzDefaults)
featurepropPubInsertCacheMut.RLock()
cache, cached := featurepropPubInsertCache[key]
featurepropPubInsertCacheMut.RUnlock()
if !cached {
wl, returnColumns := strmangle.InsertColumnSet(
featurepropPubColumns,
featurepropPubColumnsWithDefault,
featurepropPubColumnsWithoutDefault,
nzDefaults,
whitelist,
)
cache.valueMapping, err = queries.BindMapping(featurepropPubType, featurepropPubMapping, wl)
if err != nil {
return err
}
cache.retMapping, err = queries.BindMapping(featurepropPubType, featurepropPubMapping, returnColumns)
if err != nil {
return err
}
cache.query = fmt.Sprintf("INSERT INTO \"featureprop_pub\" (\"%s\") VALUES (%s)", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.IndexPlaceholders, len(wl), 1, 1))
if len(cache.retMapping) != 0 {
cache.query += fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\""))
}
}
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, "chado: unable to insert into featureprop_pub")
}
if !cached {
featurepropPubInsertCacheMut.Lock()
featurepropPubInsertCache[key] = cache
featurepropPubInsertCacheMut.Unlock()
}
return o.doAfterInsertHooks(exec)
}
// 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 *AuthRolePermission) Insert(exec boil.Executor, whitelist ...string) error {
if o == nil {
return errors.New("chado: no auth_role_permission 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
}
if err := o.doBeforeInsertHooks(exec); err != nil {
return err
}
nzDefaults := queries.NonZeroDefaultSet(authRolePermissionColumnsWithDefault, o)
key := makeCacheKey(whitelist, nzDefaults)
authRolePermissionInsertCacheMut.RLock()
cache, cached := authRolePermissionInsertCache[key]
authRolePermissionInsertCacheMut.RUnlock()
if !cached {
wl, returnColumns := strmangle.InsertColumnSet(
authRolePermissionColumns,
authRolePermissionColumnsWithDefault,
authRolePermissionColumnsWithoutDefault,
nzDefaults,
whitelist,
)
cache.valueMapping, err = queries.BindMapping(authRolePermissionType, authRolePermissionMapping, wl)
if err != nil {
return err
}
cache.retMapping, err = queries.BindMapping(authRolePermissionType, authRolePermissionMapping, returnColumns)
if err != nil {
return err
}
cache.query = fmt.Sprintf("INSERT INTO \"auth_role_permission\" (\"%s\") VALUES (%s)", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.IndexPlaceholders, len(wl), 1, 1))
if len(cache.retMapping) != 0 {
cache.query += fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\""))
}
}
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, "chado: unable to insert into auth_role_permission")
}
if !cached {
authRolePermissionInsertCacheMut.Lock()
authRolePermissionInsertCache[key] = cache
authRolePermissionInsertCacheMut.Unlock()
}
return o.doAfterInsertHooks(exec)
}
// Upsert attempts an insert using an executor, and does an update or ignore on conflict.
func (o *FeaturepropPub) Upsert(exec boil.Executor, updateOnConflict bool, conflictColumns []string, updateColumns []string, whitelist ...string) error {
if o == nil {
return errors.New("chado: no featureprop_pub provided for upsert")
}
if err := o.doBeforeUpsertHooks(exec); err != nil {
return err
}
nzDefaults := queries.NonZeroDefaultSet(featurepropPubColumnsWithDefault, 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)
featurepropPubUpsertCacheMut.RLock()
cache, cached := featurepropPubUpsertCache[key]
featurepropPubUpsertCacheMut.RUnlock()
var err error
if !cached {
var ret []string
whitelist, ret = strmangle.InsertColumnSet(
featurepropPubColumns,
featurepropPubColumnsWithDefault,
featurepropPubColumnsWithoutDefault,
nzDefaults,
whitelist,
)
update := strmangle.UpdateColumnSet(
featurepropPubColumns,
featurepropPubPrimaryKeyColumns,
updateColumns,
)
if len(update) == 0 {
return errors.New("chado: unable to upsert featureprop_pub, could not build update column list")
}
conflict := conflictColumns
if len(conflict) == 0 {
conflict = make([]string, len(featurepropPubPrimaryKeyColumns))
copy(conflict, featurepropPubPrimaryKeyColumns)
}
cache.query = queries.BuildUpsertQueryPostgres(dialect, "\"featureprop_pub\"", updateOnConflict, ret, update, conflict, whitelist)
cache.valueMapping, err = queries.BindMapping(featurepropPubType, featurepropPubMapping, whitelist)
if err != nil {
return err
}
if len(ret) != 0 {
cache.retMapping, err = queries.BindMapping(featurepropPubType, featurepropPubMapping, 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...)
} else {
_, err = exec.Exec(cache.query, vals...)
}
if err != nil {
return errors.Wrap(err, "chado: unable to upsert for featureprop_pub")
}
if !cached {
featurepropPubUpsertCacheMut.Lock()
featurepropPubUpsertCache[key] = cache
featurepropPubUpsertCacheMut.Unlock()
}
return o.doAfterUpsertHooks(exec)
}
// StockcollectionpropSlice is an alias for a slice of pointers to Stockcollectionprop.
// This should generally be used opposed to []Stockcollectionprop.
StockcollectionpropSlice []*Stockcollectionprop
// StockcollectionpropHook is the signature for custom Stockcollectionprop hook methods
StockcollectionpropHook func(boil.Executor, *Stockcollectionprop) error
stockcollectionpropQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
stockcollectionpropType = reflect.TypeOf(&Stockcollectionprop{})
stockcollectionpropMapping = queries.MakeStructMapping(stockcollectionpropType)
stockcollectionpropPrimaryKeyMapping, _ = queries.BindMapping(stockcollectionpropType, stockcollectionpropMapping, stockcollectionpropPrimaryKeyColumns)
stockcollectionpropInsertCacheMut sync.RWMutex
stockcollectionpropInsertCache = make(map[string]insertCache)
stockcollectionpropUpdateCacheMut sync.RWMutex
stockcollectionpropUpdateCache = make(map[string]updateCache)
stockcollectionpropUpsertCacheMut sync.RWMutex
stockcollectionpropUpsertCache = 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
)
var stockcollectionpropBeforeInsertHooks []StockcollectionpropHook
