Example #1
0
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
)
Example #2
0
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
)
Example #3
0
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
)
Example #4
0
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
)
Example #7
0
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
)
Example #8
0
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
)
Example #9
0
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
)
Example #10
0
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
)
Example #11
0
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
)
Example #12
0
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
)
Example #13
0
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
)
Example #14
0
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
)
Example #15
0
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
)
Example #16
0
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
)
Example #17
0
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
)
Example #18
0
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
)
Example #19
0
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
)
Example #20
0
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
)
Example #21
0
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
)
Example #22
0
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
)
Example #23
0
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
)
Example #24
0
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
)
Example #25
0
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
)
Example #26
0
File: files.go Project: zqzca/back
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
)
Example #27
0
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
)
Example #28
0
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
)
Example #29
0
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
)
Example #30
0
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
)