// 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)
}
Beispiel #2
0
// 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)
}
Beispiel #3
0
	// 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
Beispiel #4
0
	// 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
Beispiel #5
0
	// 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
Beispiel #7
0
	// 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
Beispiel #8
0
	// 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
Beispiel #9
0
	// 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
Beispiel #10
0
	// 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
Beispiel #11
0
	// 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
Beispiel #12
0
	// 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
Beispiel #13
0
	// 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
Beispiel #14
0
	// 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
Beispiel #15
0
	// 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
Beispiel #16
0
	// 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)
}
Beispiel #18
0
	// 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
Beispiel #19
0
	// 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
Beispiel #20
0
	// 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
Beispiel #21
0
	// 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
Beispiel #23
0
	// 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
Beispiel #25
0
	// 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
Beispiel #27
0
// 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)
}
Beispiel #29
0
// 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