// Code generated by ent, DO NOT EDIT.
package ent
import (
"context"
"database/sql/driver"
"fmt"
"math"
"entgo.io/ent"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
"entgo.io/ent/schema/field"
"github.com/safedep/vet/ent/predicate"
"github.com/safedep/vet/ent/reportdependency"
"github.com/safedep/vet/ent/reportlicense"
"github.com/safedep/vet/ent/reportmalware"
"github.com/safedep/vet/ent/reportpackage"
"github.com/safedep/vet/ent/reportpackagemanifest"
"github.com/safedep/vet/ent/reportproject"
"github.com/safedep/vet/ent/reportslsaprovenance"
"github.com/safedep/vet/ent/reportvulnerability"
)
// ReportPackageQuery is the builder for querying ReportPackage entities.
type ReportPackageQuery struct {
config
ctx *QueryContext
order []reportpackage.OrderOption
inters []Interceptor
predicates []predicate.ReportPackage
withManifests *ReportPackageManifestQuery
withVulnerabilities *ReportVulnerabilityQuery
withLicenses *ReportLicenseQuery
withDependencies *ReportDependencyQuery
withMalwareAnalysis *ReportMalwareQuery
withProjects *ReportProjectQuery
withSlsaProvenances *ReportSlsaProvenanceQuery
// intermediate query (i.e. traversal path).
sql *sql.Selector
path func(context.Context) (*sql.Selector, error)
}
// Where adds a new predicate for the ReportPackageQuery builder.
func (rpq *ReportPackageQuery) Where(ps ...predicate.ReportPackage) *ReportPackageQuery {
rpq.predicates = append(rpq.predicates, ps...)
return rpq
}
// Limit the number of records to be returned by this query.
func (rpq *ReportPackageQuery) Limit(limit int) *ReportPackageQuery {
rpq.ctx.Limit = &limit
return rpq
}
// Offset to start from.
func (rpq *ReportPackageQuery) Offset(offset int) *ReportPackageQuery {
rpq.ctx.Offset = &offset
return rpq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (rpq *ReportPackageQuery) Unique(unique bool) *ReportPackageQuery {
rpq.ctx.Unique = &unique
return rpq
}
// Order specifies how the records should be ordered.
func (rpq *ReportPackageQuery) Order(o ...reportpackage.OrderOption) *ReportPackageQuery {
rpq.order = append(rpq.order, o...)
return rpq
}
// QueryManifests chains the current query on the "manifests" edge.
func (rpq *ReportPackageQuery) QueryManifests() *ReportPackageManifestQuery {
query := (&ReportPackageManifestClient{config: rpq.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := rpq.prepareQuery(ctx); err != nil {
return nil, err
}
selector := rpq.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, selector),
sqlgraph.To(reportpackagemanifest.Table, reportpackagemanifest.FieldID),
sqlgraph.Edge(sqlgraph.M2M, true, reportpackage.ManifestsTable, reportpackage.ManifestsPrimaryKey...),
)
fromU = sqlgraph.SetNeighbors(rpq.driver.Dialect(), step)
return fromU, nil
}
return query
}
// QueryVulnerabilities chains the current query on the "vulnerabilities" edge.
func (rpq *ReportPackageQuery) QueryVulnerabilities() *ReportVulnerabilityQuery {
query := (&ReportVulnerabilityClient{config: rpq.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := rpq.prepareQuery(ctx); err != nil {
return nil, err
}
selector := rpq.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, selector),
sqlgraph.To(reportvulnerability.Table, reportvulnerability.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, reportpackage.VulnerabilitiesTable, reportpackage.VulnerabilitiesColumn),
)
fromU = sqlgraph.SetNeighbors(rpq.driver.Dialect(), step)
return fromU, nil
}
return query
}
// QueryLicenses chains the current query on the "licenses" edge.
func (rpq *ReportPackageQuery) QueryLicenses() *ReportLicenseQuery {
query := (&ReportLicenseClient{config: rpq.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := rpq.prepareQuery(ctx); err != nil {
return nil, err
}
selector := rpq.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, selector),
sqlgraph.To(reportlicense.Table, reportlicense.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, reportpackage.LicensesTable, reportpackage.LicensesColumn),
)
fromU = sqlgraph.SetNeighbors(rpq.driver.Dialect(), step)
return fromU, nil
}
return query
}
// QueryDependencies chains the current query on the "dependencies" edge.
func (rpq *ReportPackageQuery) QueryDependencies() *ReportDependencyQuery {
query := (&ReportDependencyClient{config: rpq.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := rpq.prepareQuery(ctx); err != nil {
return nil, err
}
selector := rpq.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, selector),
sqlgraph.To(reportdependency.Table, reportdependency.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, reportpackage.DependenciesTable, reportpackage.DependenciesColumn),
)
fromU = sqlgraph.SetNeighbors(rpq.driver.Dialect(), step)
return fromU, nil
}
return query
}
// QueryMalwareAnalysis chains the current query on the "malware_analysis" edge.
func (rpq *ReportPackageQuery) QueryMalwareAnalysis() *ReportMalwareQuery {
query := (&ReportMalwareClient{config: rpq.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := rpq.prepareQuery(ctx); err != nil {
return nil, err
}
selector := rpq.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, selector),
sqlgraph.To(reportmalware.Table, reportmalware.FieldID),
sqlgraph.Edge(sqlgraph.O2O, false, reportpackage.MalwareAnalysisTable, reportpackage.MalwareAnalysisColumn),
)
fromU = sqlgraph.SetNeighbors(rpq.driver.Dialect(), step)
return fromU, nil
}
return query
}
// QueryProjects chains the current query on the "projects" edge.
func (rpq *ReportPackageQuery) QueryProjects() *ReportProjectQuery {
query := (&ReportProjectClient{config: rpq.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := rpq.prepareQuery(ctx); err != nil {
return nil, err
}
selector := rpq.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, selector),
sqlgraph.To(reportproject.Table, reportproject.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, reportpackage.ProjectsTable, reportpackage.ProjectsColumn),
)
fromU = sqlgraph.SetNeighbors(rpq.driver.Dialect(), step)
return fromU, nil
}
return query
}
// QuerySlsaProvenances chains the current query on the "slsa_provenances" edge.
func (rpq *ReportPackageQuery) QuerySlsaProvenances() *ReportSlsaProvenanceQuery {
query := (&ReportSlsaProvenanceClient{config: rpq.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := rpq.prepareQuery(ctx); err != nil {
return nil, err
}
selector := rpq.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, selector),
sqlgraph.To(reportslsaprovenance.Table, reportslsaprovenance.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, reportpackage.SlsaProvenancesTable, reportpackage.SlsaProvenancesColumn),
)
fromU = sqlgraph.SetNeighbors(rpq.driver.Dialect(), step)
return fromU, nil
}
return query
}
// First returns the first ReportPackage entity from the query.
// Returns a *NotFoundError when no ReportPackage was found.
func (rpq *ReportPackageQuery) First(ctx context.Context) (*ReportPackage, error) {
nodes, err := rpq.Limit(1).All(setContextOp(ctx, rpq.ctx, ent.OpQueryFirst))
if err != nil {
return nil, err
}
if len(nodes) == 0 {
return nil, &NotFoundError{reportpackage.Label}
}
return nodes[0], nil
}
// FirstX is like First, but panics if an error occurs.
func (rpq *ReportPackageQuery) FirstX(ctx context.Context) *ReportPackage {
node, err := rpq.First(ctx)
if err != nil && !IsNotFound(err) {
panic(err)
}
return node
}
// FirstID returns the first ReportPackage ID from the query.
// Returns a *NotFoundError when no ReportPackage ID was found.
func (rpq *ReportPackageQuery) FirstID(ctx context.Context) (id int, err error) {
var ids []int
if ids, err = rpq.Limit(1).IDs(setContextOp(ctx, rpq.ctx, ent.OpQueryFirstID)); err != nil {
return
}
if len(ids) == 0 {
err = &NotFoundError{reportpackage.Label}
return
}
return ids[0], nil
}
// FirstIDX is like FirstID, but panics if an error occurs.
func (rpq *ReportPackageQuery) FirstIDX(ctx context.Context) int {
id, err := rpq.FirstID(ctx)
if err != nil && !IsNotFound(err) {
panic(err)
}
return id
}
// Only returns a single ReportPackage entity found by the query, ensuring it only returns one.
// Returns a *NotSingularError when more than one ReportPackage entity is found.
// Returns a *NotFoundError when no ReportPackage entities are found.
func (rpq *ReportPackageQuery) Only(ctx context.Context) (*ReportPackage, error) {
nodes, err := rpq.Limit(2).All(setContextOp(ctx, rpq.ctx, ent.OpQueryOnly))
if err != nil {
return nil, err
}
switch len(nodes) {
case 1:
return nodes[0], nil
case 0:
return nil, &NotFoundError{reportpackage.Label}
default:
return nil, &NotSingularError{reportpackage.Label}
}
}
// OnlyX is like Only, but panics if an error occurs.
func (rpq *ReportPackageQuery) OnlyX(ctx context.Context) *ReportPackage {
node, err := rpq.Only(ctx)
if err != nil {
panic(err)
}
return node
}
// OnlyID is like Only, but returns the only ReportPackage ID in the query.
// Returns a *NotSingularError when more than one ReportPackage ID is found.
// Returns a *NotFoundError when no entities are found.
func (rpq *ReportPackageQuery) OnlyID(ctx context.Context) (id int, err error) {
var ids []int
if ids, err = rpq.Limit(2).IDs(setContextOp(ctx, rpq.ctx, ent.OpQueryOnlyID)); err != nil {
return
}
switch len(ids) {
case 1:
id = ids[0]
case 0:
err = &NotFoundError{reportpackage.Label}
default:
err = &NotSingularError{reportpackage.Label}
}
return
}
// OnlyIDX is like OnlyID, but panics if an error occurs.
func (rpq *ReportPackageQuery) OnlyIDX(ctx context.Context) int {
id, err := rpq.OnlyID(ctx)
if err != nil {
panic(err)
}
return id
}
// All executes the query and returns a list of ReportPackages.
func (rpq *ReportPackageQuery) All(ctx context.Context) ([]*ReportPackage, error) {
ctx = setContextOp(ctx, rpq.ctx, ent.OpQueryAll)
if err := rpq.prepareQuery(ctx); err != nil {
return nil, err
}
qr := querierAll[[]*ReportPackage, *ReportPackageQuery]()
return withInterceptors[[]*ReportPackage](ctx, rpq, qr, rpq.inters)
}
// AllX is like All, but panics if an error occurs.
func (rpq *ReportPackageQuery) AllX(ctx context.Context) []*ReportPackage {
nodes, err := rpq.All(ctx)
if err != nil {
panic(err)
}
return nodes
}
// IDs executes the query and returns a list of ReportPackage IDs.
func (rpq *ReportPackageQuery) IDs(ctx context.Context) (ids []int, err error) {
if rpq.ctx.Unique == nil && rpq.path != nil {
rpq.Unique(true)
}
ctx = setContextOp(ctx, rpq.ctx, ent.OpQueryIDs)
if err = rpq.Select(reportpackage.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
}
// IDsX is like IDs, but panics if an error occurs.
func (rpq *ReportPackageQuery) IDsX(ctx context.Context) []int {
ids, err := rpq.IDs(ctx)
if err != nil {
panic(err)
}
return ids
}
// Count returns the count of the given query.
func (rpq *ReportPackageQuery) Count(ctx context.Context) (int, error) {
ctx = setContextOp(ctx, rpq.ctx, ent.OpQueryCount)
if err := rpq.prepareQuery(ctx); err != nil {
return 0, err
}
return withInterceptors[int](ctx, rpq, querierCount[*ReportPackageQuery](), rpq.inters)
}
// CountX is like Count, but panics if an error occurs.
func (rpq *ReportPackageQuery) CountX(ctx context.Context) int {
count, err := rpq.Count(ctx)
if err != nil {
panic(err)
}
return count
}
// Exist returns true if the query has elements in the graph.
func (rpq *ReportPackageQuery) Exist(ctx context.Context) (bool, error) {
ctx = setContextOp(ctx, rpq.ctx, ent.OpQueryExist)
switch _, err := rpq.FirstID(ctx); {
case IsNotFound(err):
return false, nil
case err != nil:
return false, fmt.Errorf("ent: check existence: %w", err)
default:
return true, nil
}
}
// ExistX is like Exist, but panics if an error occurs.
func (rpq *ReportPackageQuery) ExistX(ctx context.Context) bool {
exist, err := rpq.Exist(ctx)
if err != nil {
panic(err)
}
return exist
}
// Clone returns a duplicate of the ReportPackageQuery builder, including all associated steps. It can be
// used to prepare common query builders and use them differently after the clone is made.
func (rpq *ReportPackageQuery) Clone() *ReportPackageQuery {
if rpq == nil {
return nil
}
return &ReportPackageQuery{
config: rpq.config,
ctx: rpq.ctx.Clone(),
order: append([]reportpackage.OrderOption{}, rpq.order...),
inters: append([]Interceptor{}, rpq.inters...),
predicates: append([]predicate.ReportPackage{}, rpq.predicates...),
withManifests: rpq.withManifests.Clone(),
withVulnerabilities: rpq.withVulnerabilities.Clone(),
withLicenses: rpq.withLicenses.Clone(),
withDependencies: rpq.withDependencies.Clone(),
withMalwareAnalysis: rpq.withMalwareAnalysis.Clone(),
withProjects: rpq.withProjects.Clone(),
withSlsaProvenances: rpq.withSlsaProvenances.Clone(),
// clone intermediate query.
sql: rpq.sql.Clone(),
path: rpq.path,
}
}
// WithManifests tells the query-builder to eager-load the nodes that are connected to
// the "manifests" edge. The optional arguments are used to configure the query builder of the edge.
func (rpq *ReportPackageQuery) WithManifests(opts ...func(*ReportPackageManifestQuery)) *ReportPackageQuery {
query := (&ReportPackageManifestClient{config: rpq.config}).Query()
for _, opt := range opts {
opt(query)
}
rpq.withManifests = query
return rpq
}
// WithVulnerabilities tells the query-builder to eager-load the nodes that are connected to
// the "vulnerabilities" edge. The optional arguments are used to configure the query builder of the edge.
func (rpq *ReportPackageQuery) WithVulnerabilities(opts ...func(*ReportVulnerabilityQuery)) *ReportPackageQuery {
query := (&ReportVulnerabilityClient{config: rpq.config}).Query()
for _, opt := range opts {
opt(query)
}
rpq.withVulnerabilities = query
return rpq
}
// WithLicenses tells the query-builder to eager-load the nodes that are connected to
// the "licenses" edge. The optional arguments are used to configure the query builder of the edge.
func (rpq *ReportPackageQuery) WithLicenses(opts ...func(*ReportLicenseQuery)) *ReportPackageQuery {
query := (&ReportLicenseClient{config: rpq.config}).Query()
for _, opt := range opts {
opt(query)
}
rpq.withLicenses = query
return rpq
}
// WithDependencies tells the query-builder to eager-load the nodes that are connected to
// the "dependencies" edge. The optional arguments are used to configure the query builder of the edge.
func (rpq *ReportPackageQuery) WithDependencies(opts ...func(*ReportDependencyQuery)) *ReportPackageQuery {
query := (&ReportDependencyClient{config: rpq.config}).Query()
for _, opt := range opts {
opt(query)
}
rpq.withDependencies = query
return rpq
}
// WithMalwareAnalysis tells the query-builder to eager-load the nodes that are connected to
// the "malware_analysis" edge. The optional arguments are used to configure the query builder of the edge.
func (rpq *ReportPackageQuery) WithMalwareAnalysis(opts ...func(*ReportMalwareQuery)) *ReportPackageQuery {
query := (&ReportMalwareClient{config: rpq.config}).Query()
for _, opt := range opts {
opt(query)
}
rpq.withMalwareAnalysis = query
return rpq
}
// WithProjects tells the query-builder to eager-load the nodes that are connected to
// the "projects" edge. The optional arguments are used to configure the query builder of the edge.
func (rpq *ReportPackageQuery) WithProjects(opts ...func(*ReportProjectQuery)) *ReportPackageQuery {
query := (&ReportProjectClient{config: rpq.config}).Query()
for _, opt := range opts {
opt(query)
}
rpq.withProjects = query
return rpq
}
// WithSlsaProvenances tells the query-builder to eager-load the nodes that are connected to
// the "slsa_provenances" edge. The optional arguments are used to configure the query builder of the edge.
func (rpq *ReportPackageQuery) WithSlsaProvenances(opts ...func(*ReportSlsaProvenanceQuery)) *ReportPackageQuery {
query := (&ReportSlsaProvenanceClient{config: rpq.config}).Query()
for _, opt := range opts {
opt(query)
}
rpq.withSlsaProvenances = query
return rpq
}
// GroupBy is used to group vertices by one or more fields/columns.
// It is often used with aggregate functions, like: count, max, mean, min, sum.
//
// Example:
//
// var v []struct {
// PackageID string `json:"package_id,omitempty"`
// Count int `json:"count,omitempty"`
// }
//
// client.ReportPackage.Query().
// GroupBy(reportpackage.FieldPackageID).
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (rpq *ReportPackageQuery) GroupBy(field string, fields ...string) *ReportPackageGroupBy {
rpq.ctx.Fields = append([]string{field}, fields...)
grbuild := &ReportPackageGroupBy{build: rpq}
grbuild.flds = &rpq.ctx.Fields
grbuild.label = reportpackage.Label
grbuild.scan = grbuild.Scan
return grbuild
}
// Select allows the selection one or more fields/columns for the given query,
// instead of selecting all fields in the entity.
//
// Example:
//
// var v []struct {
// PackageID string `json:"package_id,omitempty"`
// }
//
// client.ReportPackage.Query().
// Select(reportpackage.FieldPackageID).
// Scan(ctx, &v)
func (rpq *ReportPackageQuery) Select(fields ...string) *ReportPackageSelect {
rpq.ctx.Fields = append(rpq.ctx.Fields, fields...)
sbuild := &ReportPackageSelect{ReportPackageQuery: rpq}
sbuild.label = reportpackage.Label
sbuild.flds, sbuild.scan = &rpq.ctx.Fields, sbuild.Scan
return sbuild
}
// Aggregate returns a ReportPackageSelect configured with the given aggregations.
func (rpq *ReportPackageQuery) Aggregate(fns ...AggregateFunc) *ReportPackageSelect {
return rpq.Select().Aggregate(fns...)
}
func (rpq *ReportPackageQuery) prepareQuery(ctx context.Context) error {
for _, inter := range rpq.inters {
if inter == nil {
return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
}
if trv, ok := inter.(Traverser); ok {
if err := trv.Traverse(ctx, rpq); err != nil {
return err
}
}
}
for _, f := range rpq.ctx.Fields {
if !reportpackage.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
}
if rpq.path != nil {
prev, err := rpq.path(ctx)
if err != nil {
return err
}
rpq.sql = prev
}
return nil
}
func (rpq *ReportPackageQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*ReportPackage, error) {
var (
nodes = []*ReportPackage{}
_spec = rpq.querySpec()
loadedTypes = [7]bool{
rpq.withManifests != nil,
rpq.withVulnerabilities != nil,
rpq.withLicenses != nil,
rpq.withDependencies != nil,
rpq.withMalwareAnalysis != nil,
rpq.withProjects != nil,
rpq.withSlsaProvenances != nil,
}
)
_spec.ScanValues = func(columns []string) ([]any, error) {
return (*ReportPackage).scanValues(nil, columns)
}
_spec.Assign = func(columns []string, values []any) error {
node := &ReportPackage{config: rpq.config}
nodes = append(nodes, node)
node.Edges.loadedTypes = loadedTypes
return node.assignValues(columns, values)
}
for i := range hooks {
hooks[i](ctx, _spec)
}
if err := sqlgraph.QueryNodes(ctx, rpq.driver, _spec); err != nil {
return nil, err
}
if len(nodes) == 0 {
return nodes, nil
}
if query := rpq.withManifests; query != nil {
if err := rpq.loadManifests(ctx, query, nodes,
func(n *ReportPackage) { n.Edges.Manifests = []*ReportPackageManifest{} },
func(n *ReportPackage, e *ReportPackageManifest) { n.Edges.Manifests = append(n.Edges.Manifests, e) }); err != nil {
return nil, err
}
}
if query := rpq.withVulnerabilities; query != nil {
if err := rpq.loadVulnerabilities(ctx, query, nodes,
func(n *ReportPackage) { n.Edges.Vulnerabilities = []*ReportVulnerability{} },
func(n *ReportPackage, e *ReportVulnerability) {
n.Edges.Vulnerabilities = append(n.Edges.Vulnerabilities, e)
}); err != nil {
return nil, err
}
}
if query := rpq.withLicenses; query != nil {
if err := rpq.loadLicenses(ctx, query, nodes,
func(n *ReportPackage) { n.Edges.Licenses = []*ReportLicense{} },
func(n *ReportPackage, e *ReportLicense) { n.Edges.Licenses = append(n.Edges.Licenses, e) }); err != nil {
return nil, err
}
}
if query := rpq.withDependencies; query != nil {
if err := rpq.loadDependencies(ctx, query, nodes,
func(n *ReportPackage) { n.Edges.Dependencies = []*ReportDependency{} },
func(n *ReportPackage, e *ReportDependency) { n.Edges.Dependencies = append(n.Edges.Dependencies, e) }); err != nil {
return nil, err
}
}
if query := rpq.withMalwareAnalysis; query != nil {
if err := rpq.loadMalwareAnalysis(ctx, query, nodes, nil,
func(n *ReportPackage, e *ReportMalware) { n.Edges.MalwareAnalysis = e }); err != nil {
return nil, err
}
}
if query := rpq.withProjects; query != nil {
if err := rpq.loadProjects(ctx, query, nodes,
func(n *ReportPackage) { n.Edges.Projects = []*ReportProject{} },
func(n *ReportPackage, e *ReportProject) { n.Edges.Projects = append(n.Edges.Projects, e) }); err != nil {
return nil, err
}
}
if query := rpq.withSlsaProvenances; query != nil {
if err := rpq.loadSlsaProvenances(ctx, query, nodes,
func(n *ReportPackage) { n.Edges.SlsaProvenances = []*ReportSlsaProvenance{} },
func(n *ReportPackage, e *ReportSlsaProvenance) {
n.Edges.SlsaProvenances = append(n.Edges.SlsaProvenances, e)
}); err != nil {
return nil, err
}
}
return nodes, nil
}
func (rpq *ReportPackageQuery) loadManifests(ctx context.Context, query *ReportPackageManifestQuery, nodes []*ReportPackage, init func(*ReportPackage), assign func(*ReportPackage, *ReportPackageManifest)) error {
edgeIDs := make([]driver.Value, len(nodes))
byID := make(map[int]*ReportPackage)
nids := make(map[int]map[*ReportPackage]struct{})
for i, node := range nodes {
edgeIDs[i] = node.ID
byID[node.ID] = node
if init != nil {
init(node)
}
}
query.Where(func(s *sql.Selector) {
joinT := sql.Table(reportpackage.ManifestsTable)
s.Join(joinT).On(s.C(reportpackagemanifest.FieldID), joinT.C(reportpackage.ManifestsPrimaryKey[0]))
s.Where(sql.InValues(joinT.C(reportpackage.ManifestsPrimaryKey[1]), edgeIDs...))
columns := s.SelectedColumns()
s.Select(joinT.C(reportpackage.ManifestsPrimaryKey[1]))
s.AppendSelect(columns...)
s.SetDistinct(false)
})
if err := query.prepareQuery(ctx); err != nil {
return err
}
qr := QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
return query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
assign := spec.Assign
values := spec.ScanValues
spec.ScanValues = func(columns []string) ([]any, error) {
values, err := values(columns[1:])
if err != nil {
return nil, err
}
return append([]any{new(sql.NullInt64)}, values...), nil
}
spec.Assign = func(columns []string, values []any) error {
outValue := int(values[0].(*sql.NullInt64).Int64)
inValue := int(values[1].(*sql.NullInt64).Int64)
if nids[inValue] == nil {
nids[inValue] = map[*ReportPackage]struct{}{byID[outValue]: {}}
return assign(columns[1:], values[1:])
}
nids[inValue][byID[outValue]] = struct{}{}
return nil
}
})
})
neighbors, err := withInterceptors[[]*ReportPackageManifest](ctx, query, qr, query.inters)
if err != nil {
return err
}
for _, n := range neighbors {
nodes, ok := nids[n.ID]
if !ok {
return fmt.Errorf(`unexpected "manifests" node returned %v`, n.ID)
}
for kn := range nodes {
assign(kn, n)
}
}
return nil
}
func (rpq *ReportPackageQuery) loadVulnerabilities(ctx context.Context, query *ReportVulnerabilityQuery, nodes []*ReportPackage, init func(*ReportPackage), assign func(*ReportPackage, *ReportVulnerability)) error {
fks := make([]driver.Value, 0, len(nodes))
nodeids := make(map[int]*ReportPackage)
for i := range nodes {
fks = append(fks, nodes[i].ID)
nodeids[nodes[i].ID] = nodes[i]
if init != nil {
init(nodes[i])
}
}
query.withFKs = true
query.Where(predicate.ReportVulnerability(func(s *sql.Selector) {
s.Where(sql.InValues(s.C(reportpackage.VulnerabilitiesColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
return err
}
for _, n := range neighbors {
fk := n.report_package_vulnerabilities
if fk == nil {
return fmt.Errorf(`foreign-key "report_package_vulnerabilities" is nil for node %v`, n.ID)
}
node, ok := nodeids[*fk]
if !ok {
return fmt.Errorf(`unexpected referenced foreign-key "report_package_vulnerabilities" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
return nil
}
func (rpq *ReportPackageQuery) loadLicenses(ctx context.Context, query *ReportLicenseQuery, nodes []*ReportPackage, init func(*ReportPackage), assign func(*ReportPackage, *ReportLicense)) error {
fks := make([]driver.Value, 0, len(nodes))
nodeids := make(map[int]*ReportPackage)
for i := range nodes {
fks = append(fks, nodes[i].ID)
nodeids[nodes[i].ID] = nodes[i]
if init != nil {
init(nodes[i])
}
}
query.withFKs = true
query.Where(predicate.ReportLicense(func(s *sql.Selector) {
s.Where(sql.InValues(s.C(reportpackage.LicensesColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
return err
}
for _, n := range neighbors {
fk := n.report_package_licenses
if fk == nil {
return fmt.Errorf(`foreign-key "report_package_licenses" is nil for node %v`, n.ID)
}
node, ok := nodeids[*fk]
if !ok {
return fmt.Errorf(`unexpected referenced foreign-key "report_package_licenses" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
return nil
}
func (rpq *ReportPackageQuery) loadDependencies(ctx context.Context, query *ReportDependencyQuery, nodes []*ReportPackage, init func(*ReportPackage), assign func(*ReportPackage, *ReportDependency)) error {
fks := make([]driver.Value, 0, len(nodes))
nodeids := make(map[int]*ReportPackage)
for i := range nodes {
fks = append(fks, nodes[i].ID)
nodeids[nodes[i].ID] = nodes[i]
if init != nil {
init(nodes[i])
}
}
query.withFKs = true
query.Where(predicate.ReportDependency(func(s *sql.Selector) {
s.Where(sql.InValues(s.C(reportpackage.DependenciesColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
return err
}
for _, n := range neighbors {
fk := n.report_package_dependencies
if fk == nil {
return fmt.Errorf(`foreign-key "report_package_dependencies" is nil for node %v`, n.ID)
}
node, ok := nodeids[*fk]
if !ok {
return fmt.Errorf(`unexpected referenced foreign-key "report_package_dependencies" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
return nil
}
func (rpq *ReportPackageQuery) loadMalwareAnalysis(ctx context.Context, query *ReportMalwareQuery, nodes []*ReportPackage, init func(*ReportPackage), assign func(*ReportPackage, *ReportMalware)) error {
fks := make([]driver.Value, 0, len(nodes))
nodeids := make(map[int]*ReportPackage)
for i := range nodes {
fks = append(fks, nodes[i].ID)
nodeids[nodes[i].ID] = nodes[i]
}
query.withFKs = true
query.Where(predicate.ReportMalware(func(s *sql.Selector) {
s.Where(sql.InValues(s.C(reportpackage.MalwareAnalysisColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
return err
}
for _, n := range neighbors {
fk := n.report_package_malware_analysis
if fk == nil {
return fmt.Errorf(`foreign-key "report_package_malware_analysis" is nil for node %v`, n.ID)
}
node, ok := nodeids[*fk]
if !ok {
return fmt.Errorf(`unexpected referenced foreign-key "report_package_malware_analysis" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
return nil
}
func (rpq *ReportPackageQuery) loadProjects(ctx context.Context, query *ReportProjectQuery, nodes []*ReportPackage, init func(*ReportPackage), assign func(*ReportPackage, *ReportProject)) error {
fks := make([]driver.Value, 0, len(nodes))
nodeids := make(map[int]*ReportPackage)
for i := range nodes {
fks = append(fks, nodes[i].ID)
nodeids[nodes[i].ID] = nodes[i]
if init != nil {
init(nodes[i])
}
}
query.withFKs = true
query.Where(predicate.ReportProject(func(s *sql.Selector) {
s.Where(sql.InValues(s.C(reportpackage.ProjectsColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
return err
}
for _, n := range neighbors {
fk := n.report_package_projects
if fk == nil {
return fmt.Errorf(`foreign-key "report_package_projects" is nil for node %v`, n.ID)
}
node, ok := nodeids[*fk]
if !ok {
return fmt.Errorf(`unexpected referenced foreign-key "report_package_projects" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
return nil
}
func (rpq *ReportPackageQuery) loadSlsaProvenances(ctx context.Context, query *ReportSlsaProvenanceQuery, nodes []*ReportPackage, init func(*ReportPackage), assign func(*ReportPackage, *ReportSlsaProvenance)) error {
fks := make([]driver.Value, 0, len(nodes))
nodeids := make(map[int]*ReportPackage)
for i := range nodes {
fks = append(fks, nodes[i].ID)
nodeids[nodes[i].ID] = nodes[i]
if init != nil {
init(nodes[i])
}
}
query.withFKs = true
query.Where(predicate.ReportSlsaProvenance(func(s *sql.Selector) {
s.Where(sql.InValues(s.C(reportpackage.SlsaProvenancesColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
return err
}
for _, n := range neighbors {
fk := n.report_package_slsa_provenances
if fk == nil {
return fmt.Errorf(`foreign-key "report_package_slsa_provenances" is nil for node %v`, n.ID)
}
node, ok := nodeids[*fk]
if !ok {
return fmt.Errorf(`unexpected referenced foreign-key "report_package_slsa_provenances" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
return nil
}
func (rpq *ReportPackageQuery) sqlCount(ctx context.Context) (int, error) {
_spec := rpq.querySpec()
_spec.Node.Columns = rpq.ctx.Fields
if len(rpq.ctx.Fields) > 0 {
_spec.Unique = rpq.ctx.Unique != nil && *rpq.ctx.Unique
}
return sqlgraph.CountNodes(ctx, rpq.driver, _spec)
}
func (rpq *ReportPackageQuery) querySpec() *sqlgraph.QuerySpec {
_spec := sqlgraph.NewQuerySpec(reportpackage.Table, reportpackage.Columns, sqlgraph.NewFieldSpec(reportpackage.FieldID, field.TypeInt))
_spec.From = rpq.sql
if unique := rpq.ctx.Unique; unique != nil {
_spec.Unique = *unique
} else if rpq.path != nil {
_spec.Unique = true
}
if fields := rpq.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, reportpackage.FieldID)
for i := range fields {
if fields[i] != reportpackage.FieldID {
_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
}
}
}
if ps := rpq.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
}
if limit := rpq.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
if offset := rpq.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := rpq.order; len(ps) > 0 {
_spec.Order = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
}
return _spec
}
func (rpq *ReportPackageQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(rpq.driver.Dialect())
t1 := builder.Table(reportpackage.Table)
columns := rpq.ctx.Fields
if len(columns) == 0 {
columns = reportpackage.Columns
}
selector := builder.Select(t1.Columns(columns...)...).From(t1)
if rpq.sql != nil {
selector = rpq.sql
selector.Select(selector.Columns(columns...)...)
}
if rpq.ctx.Unique != nil && *rpq.ctx.Unique {
selector.Distinct()
}
for _, p := range rpq.predicates {
p(selector)
}
for _, p := range rpq.order {
p(selector)
}
if offset := rpq.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
if limit := rpq.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
}
// ReportPackageGroupBy is the group-by builder for ReportPackage entities.
type ReportPackageGroupBy struct {
selector
build *ReportPackageQuery
}
// Aggregate adds the given aggregation functions to the group-by query.
func (rpgb *ReportPackageGroupBy) Aggregate(fns ...AggregateFunc) *ReportPackageGroupBy {
rpgb.fns = append(rpgb.fns, fns...)
return rpgb
}
// Scan applies the selector query and scans the result into the given value.
func (rpgb *ReportPackageGroupBy) Scan(ctx context.Context, v any) error {
ctx = setContextOp(ctx, rpgb.build.ctx, ent.OpQueryGroupBy)
if err := rpgb.build.prepareQuery(ctx); err != nil {
return err
}
return scanWithInterceptors[*ReportPackageQuery, *ReportPackageGroupBy](ctx, rpgb.build, rpgb, rpgb.build.inters, v)
}
func (rpgb *ReportPackageGroupBy) sqlScan(ctx context.Context, root *ReportPackageQuery, v any) error {
selector := root.sqlQuery(ctx).Select()
aggregation := make([]string, 0, len(rpgb.fns))
for _, fn := range rpgb.fns {
aggregation = append(aggregation, fn(selector))
}
if len(selector.SelectedColumns()) == 0 {
columns := make([]string, 0, len(*rpgb.flds)+len(rpgb.fns))
for _, f := range *rpgb.flds {
columns = append(columns, selector.C(f))
}
columns = append(columns, aggregation...)
selector.Select(columns...)
}
selector.GroupBy(selector.Columns(*rpgb.flds...)...)
if err := selector.Err(); err != nil {
return err
}
rows := &sql.Rows{}
query, args := selector.Query()
if err := rpgb.build.driver.Query(ctx, query, args, rows); err != nil {
return err
}
defer rows.Close()
return sql.ScanSlice(rows, v)
}
// ReportPackageSelect is the builder for selecting fields of ReportPackage entities.
type ReportPackageSelect struct {
*ReportPackageQuery
selector
}
// Aggregate adds the given aggregation functions to the selector query.
func (rps *ReportPackageSelect) Aggregate(fns ...AggregateFunc) *ReportPackageSelect {
rps.fns = append(rps.fns, fns...)
return rps
}
// Scan applies the selector query and scans the result into the given value.
func (rps *ReportPackageSelect) Scan(ctx context.Context, v any) error {
ctx = setContextOp(ctx, rps.ctx, ent.OpQuerySelect)
if err := rps.prepareQuery(ctx); err != nil {
return err
}
return scanWithInterceptors[*ReportPackageQuery, *ReportPackageSelect](ctx, rps.ReportPackageQuery, rps, rps.inters, v)
}
func (rps *ReportPackageSelect) sqlScan(ctx context.Context, root *ReportPackageQuery, v any) error {
selector := root.sqlQuery(ctx)
aggregation := make([]string, 0, len(rps.fns))
for _, fn := range rps.fns {
aggregation = append(aggregation, fn(selector))
}
switch n := len(*rps.selector.flds); {
case n == 0 && len(aggregation) > 0:
selector.Select(aggregation...)
case n != 0 && len(aggregation) > 0:
selector.AppendSelect(aggregation...)
}
rows := &sql.Rows{}
query, args := selector.Query()
if err := rps.driver.Query(ctx, query, args, rows); err != nil {
return err
}
defer rows.Close()
return sql.ScanSlice(rows, v)
}
