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 )