// Code generated by ent, DO NOT EDIT.
package ent
import (
"context"
"errors"
"fmt"
"time"
"entgo.io/ent/dialect/sql/sqlgraph"
"entgo.io/ent/schema/field"
"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"
)
// ReportPackageCreate is the builder for creating a ReportPackage entity.
type ReportPackageCreate struct {
config
mutation *ReportPackageMutation
hooks []Hook
}
// SetPackageID sets the "package_id" field.
func (rpc *ReportPackageCreate) SetPackageID(s string) *ReportPackageCreate {
rpc.mutation.SetPackageID(s)
return rpc
}
// SetName sets the "name" field.
func (rpc *ReportPackageCreate) SetName(s string) *ReportPackageCreate {
rpc.mutation.SetName(s)
return rpc
}
// SetVersion sets the "version" field.
func (rpc *ReportPackageCreate) SetVersion(s string) *ReportPackageCreate {
rpc.mutation.SetVersion(s)
return rpc
}
// SetEcosystem sets the "ecosystem" field.
func (rpc *ReportPackageCreate) SetEcosystem(s string) *ReportPackageCreate {
rpc.mutation.SetEcosystem(s)
return rpc
}
// SetPackageURL sets the "package_url" field.
func (rpc *ReportPackageCreate) SetPackageURL(s string) *ReportPackageCreate {
rpc.mutation.SetPackageURL(s)
return rpc
}
// SetDepth sets the "depth" field.
func (rpc *ReportPackageCreate) SetDepth(i int) *ReportPackageCreate {
rpc.mutation.SetDepth(i)
return rpc
}
// SetNillableDepth sets the "depth" field if the given value is not nil.
func (rpc *ReportPackageCreate) SetNillableDepth(i *int) *ReportPackageCreate {
if i != nil {
rpc.SetDepth(*i)
}
return rpc
}
// SetIsDirect sets the "is_direct" field.
func (rpc *ReportPackageCreate) SetIsDirect(b bool) *ReportPackageCreate {
rpc.mutation.SetIsDirect(b)
return rpc
}
// SetNillableIsDirect sets the "is_direct" field if the given value is not nil.
func (rpc *ReportPackageCreate) SetNillableIsDirect(b *bool) *ReportPackageCreate {
if b != nil {
rpc.SetIsDirect(*b)
}
return rpc
}
// SetIsMalware sets the "is_malware" field.
func (rpc *ReportPackageCreate) SetIsMalware(b bool) *ReportPackageCreate {
rpc.mutation.SetIsMalware(b)
return rpc
}
// SetNillableIsMalware sets the "is_malware" field if the given value is not nil.
func (rpc *ReportPackageCreate) SetNillableIsMalware(b *bool) *ReportPackageCreate {
if b != nil {
rpc.SetIsMalware(*b)
}
return rpc
}
// SetIsSuspicious sets the "is_suspicious" field.
func (rpc *ReportPackageCreate) SetIsSuspicious(b bool) *ReportPackageCreate {
rpc.mutation.SetIsSuspicious(b)
return rpc
}
// SetNillableIsSuspicious sets the "is_suspicious" field if the given value is not nil.
func (rpc *ReportPackageCreate) SetNillableIsSuspicious(b *bool) *ReportPackageCreate {
if b != nil {
rpc.SetIsSuspicious(*b)
}
return rpc
}
// SetPackageDetails sets the "package_details" field.
func (rpc *ReportPackageCreate) SetPackageDetails(m map[string]interface{}) *ReportPackageCreate {
rpc.mutation.SetPackageDetails(m)
return rpc
}
// SetInsightsV2 sets the "insights_v2" field.
func (rpc *ReportPackageCreate) SetInsightsV2(m map[string]interface{}) *ReportPackageCreate {
rpc.mutation.SetInsightsV2(m)
return rpc
}
// SetCodeAnalysis sets the "code_analysis" field.
func (rpc *ReportPackageCreate) SetCodeAnalysis(m map[string]interface{}) *ReportPackageCreate {
rpc.mutation.SetCodeAnalysis(m)
return rpc
}
// SetCreatedAt sets the "created_at" field.
func (rpc *ReportPackageCreate) SetCreatedAt(t time.Time) *ReportPackageCreate {
rpc.mutation.SetCreatedAt(t)
return rpc
}
// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
func (rpc *ReportPackageCreate) SetNillableCreatedAt(t *time.Time) *ReportPackageCreate {
if t != nil {
rpc.SetCreatedAt(*t)
}
return rpc
}
// SetUpdatedAt sets the "updated_at" field.
func (rpc *ReportPackageCreate) SetUpdatedAt(t time.Time) *ReportPackageCreate {
rpc.mutation.SetUpdatedAt(t)
return rpc
}
// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
func (rpc *ReportPackageCreate) SetNillableUpdatedAt(t *time.Time) *ReportPackageCreate {
if t != nil {
rpc.SetUpdatedAt(*t)
}
return rpc
}
// AddManifestIDs adds the "manifests" edge to the ReportPackageManifest entity by IDs.
func (rpc *ReportPackageCreate) AddManifestIDs(ids ...int) *ReportPackageCreate {
rpc.mutation.AddManifestIDs(ids...)
return rpc
}
// AddManifests adds the "manifests" edges to the ReportPackageManifest entity.
func (rpc *ReportPackageCreate) AddManifests(r ...*ReportPackageManifest) *ReportPackageCreate {
ids := make([]int, len(r))
for i := range r {
ids[i] = r[i].ID
}
return rpc.AddManifestIDs(ids...)
}
// AddVulnerabilityIDs adds the "vulnerabilities" edge to the ReportVulnerability entity by IDs.
func (rpc *ReportPackageCreate) AddVulnerabilityIDs(ids ...int) *ReportPackageCreate {
rpc.mutation.AddVulnerabilityIDs(ids...)
return rpc
}
// AddVulnerabilities adds the "vulnerabilities" edges to the ReportVulnerability entity.
func (rpc *ReportPackageCreate) AddVulnerabilities(r ...*ReportVulnerability) *ReportPackageCreate {
ids := make([]int, len(r))
for i := range r {
ids[i] = r[i].ID
}
return rpc.AddVulnerabilityIDs(ids...)
}
// AddLicenseIDs adds the "licenses" edge to the ReportLicense entity by IDs.
func (rpc *ReportPackageCreate) AddLicenseIDs(ids ...int) *ReportPackageCreate {
rpc.mutation.AddLicenseIDs(ids...)
return rpc
}
// AddLicenses adds the "licenses" edges to the ReportLicense entity.
func (rpc *ReportPackageCreate) AddLicenses(r ...*ReportLicense) *ReportPackageCreate {
ids := make([]int, len(r))
for i := range r {
ids[i] = r[i].ID
}
return rpc.AddLicenseIDs(ids...)
}
// AddDependencyIDs adds the "dependencies" edge to the ReportDependency entity by IDs.
func (rpc *ReportPackageCreate) AddDependencyIDs(ids ...int) *ReportPackageCreate {
rpc.mutation.AddDependencyIDs(ids...)
return rpc
}
// AddDependencies adds the "dependencies" edges to the ReportDependency entity.
func (rpc *ReportPackageCreate) AddDependencies(r ...*ReportDependency) *ReportPackageCreate {
ids := make([]int, len(r))
for i := range r {
ids[i] = r[i].ID
}
return rpc.AddDependencyIDs(ids...)
}
// SetMalwareAnalysisID sets the "malware_analysis" edge to the ReportMalware entity by ID.
func (rpc *ReportPackageCreate) SetMalwareAnalysisID(id int) *ReportPackageCreate {
rpc.mutation.SetMalwareAnalysisID(id)
return rpc
}
// SetNillableMalwareAnalysisID sets the "malware_analysis" edge to the ReportMalware entity by ID if the given value is not nil.
func (rpc *ReportPackageCreate) SetNillableMalwareAnalysisID(id *int) *ReportPackageCreate {
if id != nil {
rpc = rpc.SetMalwareAnalysisID(*id)
}
return rpc
}
// SetMalwareAnalysis sets the "malware_analysis" edge to the ReportMalware entity.
func (rpc *ReportPackageCreate) SetMalwareAnalysis(r *ReportMalware) *ReportPackageCreate {
return rpc.SetMalwareAnalysisID(r.ID)
}
// AddProjectIDs adds the "projects" edge to the ReportProject entity by IDs.
func (rpc *ReportPackageCreate) AddProjectIDs(ids ...int) *ReportPackageCreate {
rpc.mutation.AddProjectIDs(ids...)
return rpc
}
// AddProjects adds the "projects" edges to the ReportProject entity.
func (rpc *ReportPackageCreate) AddProjects(r ...*ReportProject) *ReportPackageCreate {
ids := make([]int, len(r))
for i := range r {
ids[i] = r[i].ID
}
return rpc.AddProjectIDs(ids...)
}
// AddSlsaProvenanceIDs adds the "slsa_provenances" edge to the ReportSlsaProvenance entity by IDs.
func (rpc *ReportPackageCreate) AddSlsaProvenanceIDs(ids ...int) *ReportPackageCreate {
rpc.mutation.AddSlsaProvenanceIDs(ids...)
return rpc
}
// AddSlsaProvenances adds the "slsa_provenances" edges to the ReportSlsaProvenance entity.
func (rpc *ReportPackageCreate) AddSlsaProvenances(r ...*ReportSlsaProvenance) *ReportPackageCreate {
ids := make([]int, len(r))
for i := range r {
ids[i] = r[i].ID
}
return rpc.AddSlsaProvenanceIDs(ids...)
}
// Mutation returns the ReportPackageMutation object of the builder.
func (rpc *ReportPackageCreate) Mutation() *ReportPackageMutation {
return rpc.mutation
}
// Save creates the ReportPackage in the database.
func (rpc *ReportPackageCreate) Save(ctx context.Context) (*ReportPackage, error) {
rpc.defaults()
return withHooks(ctx, rpc.sqlSave, rpc.mutation, rpc.hooks)
}
// SaveX calls Save and panics if Save returns an error.
func (rpc *ReportPackageCreate) SaveX(ctx context.Context) *ReportPackage {
v, err := rpc.Save(ctx)
if err != nil {
panic(err)
}
return v
}
// Exec executes the query.
func (rpc *ReportPackageCreate) Exec(ctx context.Context) error {
_, err := rpc.Save(ctx)
return err
}
// ExecX is like Exec, but panics if an error occurs.
func (rpc *ReportPackageCreate) ExecX(ctx context.Context) {
if err := rpc.Exec(ctx); err != nil {
panic(err)
}
}
// defaults sets the default values of the builder before save.
func (rpc *ReportPackageCreate) defaults() {
if _, ok := rpc.mutation.Depth(); !ok {
v := reportpackage.DefaultDepth
rpc.mutation.SetDepth(v)
}
if _, ok := rpc.mutation.IsDirect(); !ok {
v := reportpackage.DefaultIsDirect
rpc.mutation.SetIsDirect(v)
}
if _, ok := rpc.mutation.IsMalware(); !ok {
v := reportpackage.DefaultIsMalware
rpc.mutation.SetIsMalware(v)
}
if _, ok := rpc.mutation.IsSuspicious(); !ok {
v := reportpackage.DefaultIsSuspicious
rpc.mutation.SetIsSuspicious(v)
}
}
// check runs all checks and user-defined validators on the builder.
func (rpc *ReportPackageCreate) check() error {
if _, ok := rpc.mutation.PackageID(); !ok {
return &ValidationError{Name: "package_id", err: errors.New(`ent: missing required field "ReportPackage.package_id"`)}
}
if v, ok := rpc.mutation.PackageID(); ok {
if err := reportpackage.PackageIDValidator(v); err != nil {
return &ValidationError{Name: "package_id", err: fmt.Errorf(`ent: validator failed for field "ReportPackage.package_id": %w`, err)}
}
}
if _, ok := rpc.mutation.Name(); !ok {
return &ValidationError{Name: "name", err: errors.New(`ent: missing required field "ReportPackage.name"`)}
}
if v, ok := rpc.mutation.Name(); ok {
if err := reportpackage.NameValidator(v); err != nil {
return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "ReportPackage.name": %w`, err)}
}
}
if _, ok := rpc.mutation.Version(); !ok {
return &ValidationError{Name: "version", err: errors.New(`ent: missing required field "ReportPackage.version"`)}
}
if v, ok := rpc.mutation.Version(); ok {
if err := reportpackage.VersionValidator(v); err != nil {
return &ValidationError{Name: "version", err: fmt.Errorf(`ent: validator failed for field "ReportPackage.version": %w`, err)}
}
}
if _, ok := rpc.mutation.Ecosystem(); !ok {
return &ValidationError{Name: "ecosystem", err: errors.New(`ent: missing required field "ReportPackage.ecosystem"`)}
}
if v, ok := rpc.mutation.Ecosystem(); ok {
if err := reportpackage.EcosystemValidator(v); err != nil {
return &ValidationError{Name: "ecosystem", err: fmt.Errorf(`ent: validator failed for field "ReportPackage.ecosystem": %w`, err)}
}
}
if _, ok := rpc.mutation.PackageURL(); !ok {
return &ValidationError{Name: "package_url", err: errors.New(`ent: missing required field "ReportPackage.package_url"`)}
}
if v, ok := rpc.mutation.PackageURL(); ok {
if err := reportpackage.PackageURLValidator(v); err != nil {
return &ValidationError{Name: "package_url", err: fmt.Errorf(`ent: validator failed for field "ReportPackage.package_url": %w`, err)}
}
}
if _, ok := rpc.mutation.Depth(); !ok {
return &ValidationError{Name: "depth", err: errors.New(`ent: missing required field "ReportPackage.depth"`)}
}
if _, ok := rpc.mutation.IsDirect(); !ok {
return &ValidationError{Name: "is_direct", err: errors.New(`ent: missing required field "ReportPackage.is_direct"`)}
}
if _, ok := rpc.mutation.IsMalware(); !ok {
return &ValidationError{Name: "is_malware", err: errors.New(`ent: missing required field "ReportPackage.is_malware"`)}
}
if _, ok := rpc.mutation.IsSuspicious(); !ok {
return &ValidationError{Name: "is_suspicious", err: errors.New(`ent: missing required field "ReportPackage.is_suspicious"`)}
}
return nil
}
func (rpc *ReportPackageCreate) sqlSave(ctx context.Context) (*ReportPackage, error) {
if err := rpc.check(); err != nil {
return nil, err
}
_node, _spec := rpc.createSpec()
if err := sqlgraph.CreateNode(ctx, rpc.driver, _spec); err != nil {
if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err}
}
return nil, err
}
id := _spec.ID.Value.(int64)
_node.ID = int(id)
rpc.mutation.id = &_node.ID
rpc.mutation.done = true
return _node, nil
}
func (rpc *ReportPackageCreate) createSpec() (*ReportPackage, *sqlgraph.CreateSpec) {
var (
_node = &ReportPackage{config: rpc.config}
_spec = sqlgraph.NewCreateSpec(reportpackage.Table, sqlgraph.NewFieldSpec(reportpackage.FieldID, field.TypeInt))
)
if value, ok := rpc.mutation.PackageID(); ok {
_spec.SetField(reportpackage.FieldPackageID, field.TypeString, value)
_node.PackageID = value
}
if value, ok := rpc.mutation.Name(); ok {
_spec.SetField(reportpackage.FieldName, field.TypeString, value)
_node.Name = value
}
if value, ok := rpc.mutation.Version(); ok {
_spec.SetField(reportpackage.FieldVersion, field.TypeString, value)
_node.Version = value
}
if value, ok := rpc.mutation.Ecosystem(); ok {
_spec.SetField(reportpackage.FieldEcosystem, field.TypeString, value)
_node.Ecosystem = value
}
if value, ok := rpc.mutation.PackageURL(); ok {
_spec.SetField(reportpackage.FieldPackageURL, field.TypeString, value)
_node.PackageURL = value
}
if value, ok := rpc.mutation.Depth(); ok {
_spec.SetField(reportpackage.FieldDepth, field.TypeInt, value)
_node.Depth = value
}
if value, ok := rpc.mutation.IsDirect(); ok {
_spec.SetField(reportpackage.FieldIsDirect, field.TypeBool, value)
_node.IsDirect = value
}
if value, ok := rpc.mutation.IsMalware(); ok {
_spec.SetField(reportpackage.FieldIsMalware, field.TypeBool, value)
_node.IsMalware = value
}
if value, ok := rpc.mutation.IsSuspicious(); ok {
_spec.SetField(reportpackage.FieldIsSuspicious, field.TypeBool, value)
_node.IsSuspicious = value
}
if value, ok := rpc.mutation.PackageDetails(); ok {
_spec.SetField(reportpackage.FieldPackageDetails, field.TypeJSON, value)
_node.PackageDetails = value
}
if value, ok := rpc.mutation.InsightsV2(); ok {
_spec.SetField(reportpackage.FieldInsightsV2, field.TypeJSON, value)
_node.InsightsV2 = value
}
if value, ok := rpc.mutation.CodeAnalysis(); ok {
_spec.SetField(reportpackage.FieldCodeAnalysis, field.TypeJSON, value)
_node.CodeAnalysis = value
}
if value, ok := rpc.mutation.CreatedAt(); ok {
_spec.SetField(reportpackage.FieldCreatedAt, field.TypeTime, value)
_node.CreatedAt = value
}
if value, ok := rpc.mutation.UpdatedAt(); ok {
_spec.SetField(reportpackage.FieldUpdatedAt, field.TypeTime, value)
_node.UpdatedAt = value
}
if nodes := rpc.mutation.ManifestsIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: true,
Table: reportpackage.ManifestsTable,
Columns: reportpackage.ManifestsPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(reportpackagemanifest.FieldID, field.TypeInt),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges = append(_spec.Edges, edge)
}
if nodes := rpc.mutation.VulnerabilitiesIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: reportpackage.VulnerabilitiesTable,
Columns: []string{reportpackage.VulnerabilitiesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(reportvulnerability.FieldID, field.TypeInt),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges = append(_spec.Edges, edge)
}
if nodes := rpc.mutation.LicensesIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: reportpackage.LicensesTable,
Columns: []string{reportpackage.LicensesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(reportlicense.FieldID, field.TypeInt),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges = append(_spec.Edges, edge)
}
if nodes := rpc.mutation.DependenciesIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: reportpackage.DependenciesTable,
Columns: []string{reportpackage.DependenciesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(reportdependency.FieldID, field.TypeInt),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges = append(_spec.Edges, edge)
}
if nodes := rpc.mutation.MalwareAnalysisIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2O,
Inverse: false,
Table: reportpackage.MalwareAnalysisTable,
Columns: []string{reportpackage.MalwareAnalysisColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(reportmalware.FieldID, field.TypeInt),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges = append(_spec.Edges, edge)
}
if nodes := rpc.mutation.ProjectsIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: reportpackage.ProjectsTable,
Columns: []string{reportpackage.ProjectsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(reportproject.FieldID, field.TypeInt),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges = append(_spec.Edges, edge)
}
if nodes := rpc.mutation.SlsaProvenancesIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: reportpackage.SlsaProvenancesTable,
Columns: []string{reportpackage.SlsaProvenancesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(reportslsaprovenance.FieldID, field.TypeInt),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges = append(_spec.Edges, edge)
}
return _node, _spec
}
// ReportPackageCreateBulk is the builder for creating many ReportPackage entities in bulk.
type ReportPackageCreateBulk struct {
config
err error
builders []*ReportPackageCreate
}
// Save creates the ReportPackage entities in the database.
func (rpcb *ReportPackageCreateBulk) Save(ctx context.Context) ([]*ReportPackage, error) {
if rpcb.err != nil {
return nil, rpcb.err
}
specs := make([]*sqlgraph.CreateSpec, len(rpcb.builders))
nodes := make([]*ReportPackage, len(rpcb.builders))
mutators := make([]Mutator, len(rpcb.builders))
for i := range rpcb.builders {
func(i int, root context.Context) {
builder := rpcb.builders[i]
builder.defaults()
var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
mutation, ok := m.(*ReportPackageMutation)
if !ok {
return nil, fmt.Errorf("unexpected mutation type %T", m)
}
if err := builder.check(); err != nil {
return nil, err
}
builder.mutation = mutation
var err error
nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, rpcb.builders[i+1].mutation)
} else {
spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
// Invoke the actual operation on the latest mutation in the chain.
if err = sqlgraph.BatchCreate(ctx, rpcb.driver, spec); err != nil {
if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err}
}
}
}
if err != nil {
return nil, err
}
mutation.id = &nodes[i].ID
if specs[i].ID.Value != nil {
id := specs[i].ID.Value.(int64)
nodes[i].ID = int(id)
}
mutation.done = true
return nodes[i], nil
})
for i := len(builder.hooks) - 1; i >= 0; i-- {
mut = builder.hooks[i](mut)
}
mutators[i] = mut
}(i, ctx)
}
if len(mutators) > 0 {
if _, err := mutators[0].Mutate(ctx, rpcb.builders[0].mutation); err != nil {
return nil, err
}
}
return nodes, nil
}
// SaveX is like Save, but panics if an error occurs.
func (rpcb *ReportPackageCreateBulk) SaveX(ctx context.Context) []*ReportPackage {
v, err := rpcb.Save(ctx)
if err != nil {
panic(err)
}
return v
}
// Exec executes the query.
func (rpcb *ReportPackageCreateBulk) Exec(ctx context.Context) error {
_, err := rpcb.Save(ctx)
return err
}
// ExecX is like Exec, but panics if an error occurs.
func (rpcb *ReportPackageCreateBulk) ExecX(ctx context.Context) {
if err := rpcb.Exec(ctx); err != nil {
panic(err)
}
}
