Golang queries.BindMapping函数代码示例

// 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