type (
// StockPubSlice is an alias for a slice of pointers to StockPub.
// This should generally be used opposed to []StockPub.
StockPubSlice []*StockPub
// StockPubHook is the signature for custom StockPub hook methods
StockPubHook func(boil.Executor, *StockPub) error
stockPubQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
stockPubType = reflect.TypeOf(&StockPub{})
stockPubMapping = queries.MakeStructMapping(stockPubType)
stockPubPrimaryKeyMapping, _ = queries.BindMapping(stockPubType, stockPubMapping, stockPubPrimaryKeyColumns)
stockPubInsertCacheMut sync.RWMutex
stockPubInsertCache = make(map[string]insertCache)
stockPubUpdateCacheMut sync.RWMutex
stockPubUpdateCache = make(map[string]updateCache)
stockPubUpsertCacheMut sync.RWMutex
stockPubUpsertCache = 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
)
type (
// FeaturepropSlice is an alias for a slice of pointers to Featureprop.
// This should generally be used opposed to []Featureprop.
FeaturepropSlice []*Featureprop
// FeaturepropHook is the signature for custom Featureprop hook methods
FeaturepropHook func(boil.Executor, *Featureprop) error
featurepropQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
featurepropType = reflect.TypeOf(&Featureprop{})
featurepropMapping = queries.MakeStructMapping(featurepropType)
featurepropPrimaryKeyMapping, _ = queries.BindMapping(featurepropType, featurepropMapping, featurepropPrimaryKeyColumns)
featurepropInsertCacheMut sync.RWMutex
featurepropInsertCache = make(map[string]insertCache)
featurepropUpdateCacheMut sync.RWMutex
featurepropUpdateCache = make(map[string]updateCache)
featurepropUpsertCacheMut sync.RWMutex
featurepropUpsertCache = 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
)
type (
// 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
)
type (
// 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
)
type (
// FeatureRelationshippropPubSlice is an alias for a slice of pointers to FeatureRelationshippropPub.
// This should generally be used opposed to []FeatureRelationshippropPub.
FeatureRelationshippropPubSlice []*FeatureRelationshippropPub
// FeatureRelationshippropPubHook is the signature for custom FeatureRelationshippropPub hook methods
FeatureRelationshippropPubHook func(boil.Executor, *FeatureRelationshippropPub) error
featureRelationshippropPubQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
featureRelationshippropPubType = reflect.TypeOf(&FeatureRelationshippropPub{})
featureRelationshippropPubMapping = queries.MakeStructMapping(featureRelationshippropPubType)
featureRelationshippropPubPrimaryKeyMapping, _ = queries.BindMapping(featureRelationshippropPubType, featureRelationshippropPubMapping, featureRelationshippropPubPrimaryKeyColumns)
featureRelationshippropPubInsertCacheMut sync.RWMutex
featureRelationshippropPubInsertCache = make(map[string]insertCache)
featureRelationshippropPubUpdateCacheMut sync.RWMutex
featureRelationshippropPubUpdateCache = make(map[string]updateCache)
featureRelationshippropPubUpsertCacheMut sync.RWMutex
featureRelationshippropPubUpsertCache = 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// PhendescSlice is an alias for a slice of pointers to Phendesc.
// This should generally be used opposed to []Phendesc.
PhendescSlice []*Phendesc
// PhendescHook is the signature for custom Phendesc hook methods
PhendescHook func(boil.Executor, *Phendesc) error
phendescQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
phendescType = reflect.TypeOf(&Phendesc{})
phendescMapping = queries.MakeStructMapping(phendescType)
phendescPrimaryKeyMapping, _ = queries.BindMapping(phendescType, phendescMapping, phendescPrimaryKeyColumns)
phendescInsertCacheMut sync.RWMutex
phendescInsertCache = make(map[string]insertCache)
phendescUpdateCacheMut sync.RWMutex
phendescUpdateCache = make(map[string]updateCache)
phendescUpsertCacheMut sync.RWMutex
phendescUpsertCache = 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
)
type (
// 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
)
type (
// JbrowseOrganismSlice is an alias for a slice of pointers to JbrowseOrganism.
// This should generally be used opposed to []JbrowseOrganism.
JbrowseOrganismSlice []*JbrowseOrganism
// JbrowseOrganismHook is the signature for custom JbrowseOrganism hook methods
JbrowseOrganismHook func(boil.Executor, *JbrowseOrganism) error
jbrowseOrganismQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
jbrowseOrganismType = reflect.TypeOf(&JbrowseOrganism{})
jbrowseOrganismMapping = queries.MakeStructMapping(jbrowseOrganismType)
jbrowseOrganismPrimaryKeyMapping, _ = queries.BindMapping(jbrowseOrganismType, jbrowseOrganismMapping, jbrowseOrganismPrimaryKeyColumns)
jbrowseOrganismInsertCacheMut sync.RWMutex
jbrowseOrganismInsertCache = make(map[string]insertCache)
jbrowseOrganismUpdateCacheMut sync.RWMutex
jbrowseOrganismUpdateCache = make(map[string]updateCache)
jbrowseOrganismUpsertCacheMut sync.RWMutex
jbrowseOrganismUpsertCache = 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
)
type (
// StockCvtermpropSlice is an alias for a slice of pointers to StockCvtermprop.
// This should generally be used opposed to []StockCvtermprop.
StockCvtermpropSlice []*StockCvtermprop
// StockCvtermpropHook is the signature for custom StockCvtermprop hook methods
StockCvtermpropHook func(boil.Executor, *StockCvtermprop) error
stockCvtermpropQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
stockCvtermpropType = reflect.TypeOf(&StockCvtermprop{})
stockCvtermpropMapping = queries.MakeStructMapping(stockCvtermpropType)
stockCvtermpropPrimaryKeyMapping, _ = queries.BindMapping(stockCvtermpropType, stockCvtermpropMapping, stockCvtermpropPrimaryKeyColumns)
stockCvtermpropInsertCacheMut sync.RWMutex
stockCvtermpropInsertCache = make(map[string]insertCache)
stockCvtermpropUpdateCacheMut sync.RWMutex
stockCvtermpropUpdateCache = make(map[string]updateCache)
stockCvtermpropUpsertCacheMut sync.RWMutex
stockCvtermpropUpsertCache = 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
)
type (
// StockDbxrefSlice is an alias for a slice of pointers to StockDbxref.
// This should generally be used opposed to []StockDbxref.
StockDbxrefSlice []*StockDbxref
// StockDbxrefHook is the signature for custom StockDbxref hook methods
StockDbxrefHook func(boil.Executor, *StockDbxref) error
stockDbxrefQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
stockDbxrefType = reflect.TypeOf(&StockDbxref{})
stockDbxrefMapping = queries.MakeStructMapping(stockDbxrefType)
stockDbxrefPrimaryKeyMapping, _ = queries.BindMapping(stockDbxrefType, stockDbxrefMapping, stockDbxrefPrimaryKeyColumns)
stockDbxrefInsertCacheMut sync.RWMutex
stockDbxrefInsertCache = make(map[string]insertCache)
stockDbxrefUpdateCacheMut sync.RWMutex
stockDbxrefUpdateCache = make(map[string]updateCache)
stockDbxrefUpsertCacheMut sync.RWMutex
stockDbxrefUpsertCache = 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// 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
)
type (
// DBSlice is an alias for a slice of pointers to DB.
// This should generally be used opposed to []DB.
DBSlice []*DB
// DBHook is the signature for custom DB hook methods
DBHook func(boil.Executor, *DB) error
dbQuery struct {
*queries.Query
}
)
// Cache for insert, update and upsert
var (
dbType = reflect.TypeOf(&DB{})
dbMapping = queries.MakeStructMapping(dbType)
dbPrimaryKeyMapping, _ = queries.BindMapping(dbType, dbMapping, dbPrimaryKeyColumns)
dbInsertCacheMut sync.RWMutex
dbInsertCache = make(map[string]insertCache)
dbUpdateCacheMut sync.RWMutex
dbUpdateCache = make(map[string]updateCache)
dbUpsertCacheMut sync.RWMutex
dbUpsertCache = 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
)