vet/ent/reportdependencygraph_update.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"errors"
	"fmt"
	"time"

	"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/reportdependencygraph"
)

// ReportDependencyGraphUpdate is the builder for updating ReportDependencyGraph entities.
type ReportDependencyGraphUpdate struct {
	config
	hooks    []Hook
	mutation *ReportDependencyGraphMutation
}

// Where appends a list predicates to the ReportDependencyGraphUpdate builder.
func (rdgu *ReportDependencyGraphUpdate) Where(ps ...predicate.ReportDependencyGraph) *ReportDependencyGraphUpdate {
	rdgu.mutation.Where(ps...)
	return rdgu
}

// SetFromPackageID sets the "from_package_id" field.
func (rdgu *ReportDependencyGraphUpdate) SetFromPackageID(s string) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetFromPackageID(s)
	return rdgu
}

// SetNillableFromPackageID sets the "from_package_id" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableFromPackageID(s *string) *ReportDependencyGraphUpdate {
	if s != nil {
		rdgu.SetFromPackageID(*s)
	}
	return rdgu
}

// SetFromPackageName sets the "from_package_name" field.
func (rdgu *ReportDependencyGraphUpdate) SetFromPackageName(s string) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetFromPackageName(s)
	return rdgu
}

// SetNillableFromPackageName sets the "from_package_name" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableFromPackageName(s *string) *ReportDependencyGraphUpdate {
	if s != nil {
		rdgu.SetFromPackageName(*s)
	}
	return rdgu
}

// SetFromPackageVersion sets the "from_package_version" field.
func (rdgu *ReportDependencyGraphUpdate) SetFromPackageVersion(s string) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetFromPackageVersion(s)
	return rdgu
}

// SetNillableFromPackageVersion sets the "from_package_version" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableFromPackageVersion(s *string) *ReportDependencyGraphUpdate {
	if s != nil {
		rdgu.SetFromPackageVersion(*s)
	}
	return rdgu
}

// SetFromPackageEcosystem sets the "from_package_ecosystem" field.
func (rdgu *ReportDependencyGraphUpdate) SetFromPackageEcosystem(s string) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetFromPackageEcosystem(s)
	return rdgu
}

// SetNillableFromPackageEcosystem sets the "from_package_ecosystem" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableFromPackageEcosystem(s *string) *ReportDependencyGraphUpdate {
	if s != nil {
		rdgu.SetFromPackageEcosystem(*s)
	}
	return rdgu
}

// SetToPackageID sets the "to_package_id" field.
func (rdgu *ReportDependencyGraphUpdate) SetToPackageID(s string) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetToPackageID(s)
	return rdgu
}

// SetNillableToPackageID sets the "to_package_id" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableToPackageID(s *string) *ReportDependencyGraphUpdate {
	if s != nil {
		rdgu.SetToPackageID(*s)
	}
	return rdgu
}

// SetToPackageName sets the "to_package_name" field.
func (rdgu *ReportDependencyGraphUpdate) SetToPackageName(s string) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetToPackageName(s)
	return rdgu
}

// SetNillableToPackageName sets the "to_package_name" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableToPackageName(s *string) *ReportDependencyGraphUpdate {
	if s != nil {
		rdgu.SetToPackageName(*s)
	}
	return rdgu
}

// SetToPackageVersion sets the "to_package_version" field.
func (rdgu *ReportDependencyGraphUpdate) SetToPackageVersion(s string) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetToPackageVersion(s)
	return rdgu
}

// SetNillableToPackageVersion sets the "to_package_version" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableToPackageVersion(s *string) *ReportDependencyGraphUpdate {
	if s != nil {
		rdgu.SetToPackageVersion(*s)
	}
	return rdgu
}

// SetToPackageEcosystem sets the "to_package_ecosystem" field.
func (rdgu *ReportDependencyGraphUpdate) SetToPackageEcosystem(s string) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetToPackageEcosystem(s)
	return rdgu
}

// SetNillableToPackageEcosystem sets the "to_package_ecosystem" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableToPackageEcosystem(s *string) *ReportDependencyGraphUpdate {
	if s != nil {
		rdgu.SetToPackageEcosystem(*s)
	}
	return rdgu
}

// SetDependencyType sets the "dependency_type" field.
func (rdgu *ReportDependencyGraphUpdate) SetDependencyType(s string) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetDependencyType(s)
	return rdgu
}

// SetNillableDependencyType sets the "dependency_type" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableDependencyType(s *string) *ReportDependencyGraphUpdate {
	if s != nil {
		rdgu.SetDependencyType(*s)
	}
	return rdgu
}

// ClearDependencyType clears the value of the "dependency_type" field.
func (rdgu *ReportDependencyGraphUpdate) ClearDependencyType() *ReportDependencyGraphUpdate {
	rdgu.mutation.ClearDependencyType()
	return rdgu
}

// SetVersionConstraint sets the "version_constraint" field.
func (rdgu *ReportDependencyGraphUpdate) SetVersionConstraint(s string) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetVersionConstraint(s)
	return rdgu
}

// SetNillableVersionConstraint sets the "version_constraint" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableVersionConstraint(s *string) *ReportDependencyGraphUpdate {
	if s != nil {
		rdgu.SetVersionConstraint(*s)
	}
	return rdgu
}

// ClearVersionConstraint clears the value of the "version_constraint" field.
func (rdgu *ReportDependencyGraphUpdate) ClearVersionConstraint() *ReportDependencyGraphUpdate {
	rdgu.mutation.ClearVersionConstraint()
	return rdgu
}

// SetDepth sets the "depth" field.
func (rdgu *ReportDependencyGraphUpdate) SetDepth(i int) *ReportDependencyGraphUpdate {
	rdgu.mutation.ResetDepth()
	rdgu.mutation.SetDepth(i)
	return rdgu
}

// SetNillableDepth sets the "depth" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableDepth(i *int) *ReportDependencyGraphUpdate {
	if i != nil {
		rdgu.SetDepth(*i)
	}
	return rdgu
}

// AddDepth adds i to the "depth" field.
func (rdgu *ReportDependencyGraphUpdate) AddDepth(i int) *ReportDependencyGraphUpdate {
	rdgu.mutation.AddDepth(i)
	return rdgu
}

// SetIsDirect sets the "is_direct" field.
func (rdgu *ReportDependencyGraphUpdate) SetIsDirect(b bool) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetIsDirect(b)
	return rdgu
}

// SetNillableIsDirect sets the "is_direct" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableIsDirect(b *bool) *ReportDependencyGraphUpdate {
	if b != nil {
		rdgu.SetIsDirect(*b)
	}
	return rdgu
}

// SetIsRootEdge sets the "is_root_edge" field.
func (rdgu *ReportDependencyGraphUpdate) SetIsRootEdge(b bool) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetIsRootEdge(b)
	return rdgu
}

// SetNillableIsRootEdge sets the "is_root_edge" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableIsRootEdge(b *bool) *ReportDependencyGraphUpdate {
	if b != nil {
		rdgu.SetIsRootEdge(*b)
	}
	return rdgu
}

// SetManifestID sets the "manifest_id" field.
func (rdgu *ReportDependencyGraphUpdate) SetManifestID(s string) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetManifestID(s)
	return rdgu
}

// SetNillableManifestID sets the "manifest_id" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableManifestID(s *string) *ReportDependencyGraphUpdate {
	if s != nil {
		rdgu.SetManifestID(*s)
	}
	return rdgu
}

// SetCreatedAt sets the "created_at" field.
func (rdgu *ReportDependencyGraphUpdate) SetCreatedAt(t time.Time) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetCreatedAt(t)
	return rdgu
}

// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableCreatedAt(t *time.Time) *ReportDependencyGraphUpdate {
	if t != nil {
		rdgu.SetCreatedAt(*t)
	}
	return rdgu
}

// ClearCreatedAt clears the value of the "created_at" field.
func (rdgu *ReportDependencyGraphUpdate) ClearCreatedAt() *ReportDependencyGraphUpdate {
	rdgu.mutation.ClearCreatedAt()
	return rdgu
}

// SetUpdatedAt sets the "updated_at" field.
func (rdgu *ReportDependencyGraphUpdate) SetUpdatedAt(t time.Time) *ReportDependencyGraphUpdate {
	rdgu.mutation.SetUpdatedAt(t)
	return rdgu
}

// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
func (rdgu *ReportDependencyGraphUpdate) SetNillableUpdatedAt(t *time.Time) *ReportDependencyGraphUpdate {
	if t != nil {
		rdgu.SetUpdatedAt(*t)
	}
	return rdgu
}

// ClearUpdatedAt clears the value of the "updated_at" field.
func (rdgu *ReportDependencyGraphUpdate) ClearUpdatedAt() *ReportDependencyGraphUpdate {
	rdgu.mutation.ClearUpdatedAt()
	return rdgu
}

// Mutation returns the ReportDependencyGraphMutation object of the builder.
func (rdgu *ReportDependencyGraphUpdate) Mutation() *ReportDependencyGraphMutation {
	return rdgu.mutation
}

// Save executes the query and returns the number of nodes affected by the update operation.
func (rdgu *ReportDependencyGraphUpdate) Save(ctx context.Context) (int, error) {
	return withHooks(ctx, rdgu.sqlSave, rdgu.mutation, rdgu.hooks)
}

// SaveX is like Save, but panics if an error occurs.
func (rdgu *ReportDependencyGraphUpdate) SaveX(ctx context.Context) int {
	affected, err := rdgu.Save(ctx)
	if err != nil {
		panic(err)
	}
	return affected
}

// Exec executes the query.
func (rdgu *ReportDependencyGraphUpdate) Exec(ctx context.Context) error {
	_, err := rdgu.Save(ctx)
	return err
}

// ExecX is like Exec, but panics if an error occurs.
func (rdgu *ReportDependencyGraphUpdate) ExecX(ctx context.Context) {
	if err := rdgu.Exec(ctx); err != nil {
		panic(err)
	}
}

// check runs all checks and user-defined validators on the builder.
func (rdgu *ReportDependencyGraphUpdate) check() error {
	if v, ok := rdgu.mutation.FromPackageID(); ok {
		if err := reportdependencygraph.FromPackageIDValidator(v); err != nil {
			return &ValidationError{Name: "from_package_id", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.from_package_id": %w`, err)}
		}
	}
	if v, ok := rdgu.mutation.FromPackageName(); ok {
		if err := reportdependencygraph.FromPackageNameValidator(v); err != nil {
			return &ValidationError{Name: "from_package_name", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.from_package_name": %w`, err)}
		}
	}
	if v, ok := rdgu.mutation.FromPackageVersion(); ok {
		if err := reportdependencygraph.FromPackageVersionValidator(v); err != nil {
			return &ValidationError{Name: "from_package_version", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.from_package_version": %w`, err)}
		}
	}
	if v, ok := rdgu.mutation.FromPackageEcosystem(); ok {
		if err := reportdependencygraph.FromPackageEcosystemValidator(v); err != nil {
			return &ValidationError{Name: "from_package_ecosystem", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.from_package_ecosystem": %w`, err)}
		}
	}
	if v, ok := rdgu.mutation.ToPackageID(); ok {
		if err := reportdependencygraph.ToPackageIDValidator(v); err != nil {
			return &ValidationError{Name: "to_package_id", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.to_package_id": %w`, err)}
		}
	}
	if v, ok := rdgu.mutation.ToPackageName(); ok {
		if err := reportdependencygraph.ToPackageNameValidator(v); err != nil {
			return &ValidationError{Name: "to_package_name", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.to_package_name": %w`, err)}
		}
	}
	if v, ok := rdgu.mutation.ToPackageVersion(); ok {
		if err := reportdependencygraph.ToPackageVersionValidator(v); err != nil {
			return &ValidationError{Name: "to_package_version", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.to_package_version": %w`, err)}
		}
	}
	if v, ok := rdgu.mutation.ToPackageEcosystem(); ok {
		if err := reportdependencygraph.ToPackageEcosystemValidator(v); err != nil {
			return &ValidationError{Name: "to_package_ecosystem", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.to_package_ecosystem": %w`, err)}
		}
	}
	if v, ok := rdgu.mutation.ManifestID(); ok {
		if err := reportdependencygraph.ManifestIDValidator(v); err != nil {
			return &ValidationError{Name: "manifest_id", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.manifest_id": %w`, err)}
		}
	}
	return nil
}

func (rdgu *ReportDependencyGraphUpdate) sqlSave(ctx context.Context) (n int, err error) {
	if err := rdgu.check(); err != nil {
		return n, err
	}
	_spec := sqlgraph.NewUpdateSpec(reportdependencygraph.Table, reportdependencygraph.Columns, sqlgraph.NewFieldSpec(reportdependencygraph.FieldID, field.TypeInt))
	if ps := rdgu.mutation.predicates; len(ps) > 0 {
		_spec.Predicate = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	if value, ok := rdgu.mutation.FromPackageID(); ok {
		_spec.SetField(reportdependencygraph.FieldFromPackageID, field.TypeString, value)
	}
	if value, ok := rdgu.mutation.FromPackageName(); ok {
		_spec.SetField(reportdependencygraph.FieldFromPackageName, field.TypeString, value)
	}
	if value, ok := rdgu.mutation.FromPackageVersion(); ok {
		_spec.SetField(reportdependencygraph.FieldFromPackageVersion, field.TypeString, value)
	}
	if value, ok := rdgu.mutation.FromPackageEcosystem(); ok {
		_spec.SetField(reportdependencygraph.FieldFromPackageEcosystem, field.TypeString, value)
	}
	if value, ok := rdgu.mutation.ToPackageID(); ok {
		_spec.SetField(reportdependencygraph.FieldToPackageID, field.TypeString, value)
	}
	if value, ok := rdgu.mutation.ToPackageName(); ok {
		_spec.SetField(reportdependencygraph.FieldToPackageName, field.TypeString, value)
	}
	if value, ok := rdgu.mutation.ToPackageVersion(); ok {
		_spec.SetField(reportdependencygraph.FieldToPackageVersion, field.TypeString, value)
	}
	if value, ok := rdgu.mutation.ToPackageEcosystem(); ok {
		_spec.SetField(reportdependencygraph.FieldToPackageEcosystem, field.TypeString, value)
	}
	if value, ok := rdgu.mutation.DependencyType(); ok {
		_spec.SetField(reportdependencygraph.FieldDependencyType, field.TypeString, value)
	}
	if rdgu.mutation.DependencyTypeCleared() {
		_spec.ClearField(reportdependencygraph.FieldDependencyType, field.TypeString)
	}
	if value, ok := rdgu.mutation.VersionConstraint(); ok {
		_spec.SetField(reportdependencygraph.FieldVersionConstraint, field.TypeString, value)
	}
	if rdgu.mutation.VersionConstraintCleared() {
		_spec.ClearField(reportdependencygraph.FieldVersionConstraint, field.TypeString)
	}
	if value, ok := rdgu.mutation.Depth(); ok {
		_spec.SetField(reportdependencygraph.FieldDepth, field.TypeInt, value)
	}
	if value, ok := rdgu.mutation.AddedDepth(); ok {
		_spec.AddField(reportdependencygraph.FieldDepth, field.TypeInt, value)
	}
	if value, ok := rdgu.mutation.IsDirect(); ok {
		_spec.SetField(reportdependencygraph.FieldIsDirect, field.TypeBool, value)
	}
	if value, ok := rdgu.mutation.IsRootEdge(); ok {
		_spec.SetField(reportdependencygraph.FieldIsRootEdge, field.TypeBool, value)
	}
	if value, ok := rdgu.mutation.ManifestID(); ok {
		_spec.SetField(reportdependencygraph.FieldManifestID, field.TypeString, value)
	}
	if value, ok := rdgu.mutation.CreatedAt(); ok {
		_spec.SetField(reportdependencygraph.FieldCreatedAt, field.TypeTime, value)
	}
	if rdgu.mutation.CreatedAtCleared() {
		_spec.ClearField(reportdependencygraph.FieldCreatedAt, field.TypeTime)
	}
	if value, ok := rdgu.mutation.UpdatedAt(); ok {
		_spec.SetField(reportdependencygraph.FieldUpdatedAt, field.TypeTime, value)
	}
	if rdgu.mutation.UpdatedAtCleared() {
		_spec.ClearField(reportdependencygraph.FieldUpdatedAt, field.TypeTime)
	}
	if n, err = sqlgraph.UpdateNodes(ctx, rdgu.driver, _spec); err != nil {
		if _, ok := err.(*sqlgraph.NotFoundError); ok {
			err = &NotFoundError{reportdependencygraph.Label}
		} else if sqlgraph.IsConstraintError(err) {
			err = &ConstraintError{msg: err.Error(), wrap: err}
		}
		return 0, err
	}
	rdgu.mutation.done = true
	return n, nil
}

// ReportDependencyGraphUpdateOne is the builder for updating a single ReportDependencyGraph entity.
type ReportDependencyGraphUpdateOne struct {
	config
	fields   []string
	hooks    []Hook
	mutation *ReportDependencyGraphMutation
}

// SetFromPackageID sets the "from_package_id" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetFromPackageID(s string) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetFromPackageID(s)
	return rdguo
}

// SetNillableFromPackageID sets the "from_package_id" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableFromPackageID(s *string) *ReportDependencyGraphUpdateOne {
	if s != nil {
		rdguo.SetFromPackageID(*s)
	}
	return rdguo
}

// SetFromPackageName sets the "from_package_name" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetFromPackageName(s string) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetFromPackageName(s)
	return rdguo
}

// SetNillableFromPackageName sets the "from_package_name" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableFromPackageName(s *string) *ReportDependencyGraphUpdateOne {
	if s != nil {
		rdguo.SetFromPackageName(*s)
	}
	return rdguo
}

// SetFromPackageVersion sets the "from_package_version" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetFromPackageVersion(s string) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetFromPackageVersion(s)
	return rdguo
}

// SetNillableFromPackageVersion sets the "from_package_version" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableFromPackageVersion(s *string) *ReportDependencyGraphUpdateOne {
	if s != nil {
		rdguo.SetFromPackageVersion(*s)
	}
	return rdguo
}

// SetFromPackageEcosystem sets the "from_package_ecosystem" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetFromPackageEcosystem(s string) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetFromPackageEcosystem(s)
	return rdguo
}

// SetNillableFromPackageEcosystem sets the "from_package_ecosystem" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableFromPackageEcosystem(s *string) *ReportDependencyGraphUpdateOne {
	if s != nil {
		rdguo.SetFromPackageEcosystem(*s)
	}
	return rdguo
}

// SetToPackageID sets the "to_package_id" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetToPackageID(s string) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetToPackageID(s)
	return rdguo
}

// SetNillableToPackageID sets the "to_package_id" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableToPackageID(s *string) *ReportDependencyGraphUpdateOne {
	if s != nil {
		rdguo.SetToPackageID(*s)
	}
	return rdguo
}

// SetToPackageName sets the "to_package_name" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetToPackageName(s string) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetToPackageName(s)
	return rdguo
}

// SetNillableToPackageName sets the "to_package_name" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableToPackageName(s *string) *ReportDependencyGraphUpdateOne {
	if s != nil {
		rdguo.SetToPackageName(*s)
	}
	return rdguo
}

// SetToPackageVersion sets the "to_package_version" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetToPackageVersion(s string) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetToPackageVersion(s)
	return rdguo
}

// SetNillableToPackageVersion sets the "to_package_version" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableToPackageVersion(s *string) *ReportDependencyGraphUpdateOne {
	if s != nil {
		rdguo.SetToPackageVersion(*s)
	}
	return rdguo
}

// SetToPackageEcosystem sets the "to_package_ecosystem" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetToPackageEcosystem(s string) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetToPackageEcosystem(s)
	return rdguo
}

// SetNillableToPackageEcosystem sets the "to_package_ecosystem" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableToPackageEcosystem(s *string) *ReportDependencyGraphUpdateOne {
	if s != nil {
		rdguo.SetToPackageEcosystem(*s)
	}
	return rdguo
}

// SetDependencyType sets the "dependency_type" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetDependencyType(s string) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetDependencyType(s)
	return rdguo
}

// SetNillableDependencyType sets the "dependency_type" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableDependencyType(s *string) *ReportDependencyGraphUpdateOne {
	if s != nil {
		rdguo.SetDependencyType(*s)
	}
	return rdguo
}

// ClearDependencyType clears the value of the "dependency_type" field.
func (rdguo *ReportDependencyGraphUpdateOne) ClearDependencyType() *ReportDependencyGraphUpdateOne {
	rdguo.mutation.ClearDependencyType()
	return rdguo
}

// SetVersionConstraint sets the "version_constraint" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetVersionConstraint(s string) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetVersionConstraint(s)
	return rdguo
}

// SetNillableVersionConstraint sets the "version_constraint" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableVersionConstraint(s *string) *ReportDependencyGraphUpdateOne {
	if s != nil {
		rdguo.SetVersionConstraint(*s)
	}
	return rdguo
}

// ClearVersionConstraint clears the value of the "version_constraint" field.
func (rdguo *ReportDependencyGraphUpdateOne) ClearVersionConstraint() *ReportDependencyGraphUpdateOne {
	rdguo.mutation.ClearVersionConstraint()
	return rdguo
}

// SetDepth sets the "depth" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetDepth(i int) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.ResetDepth()
	rdguo.mutation.SetDepth(i)
	return rdguo
}

// SetNillableDepth sets the "depth" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableDepth(i *int) *ReportDependencyGraphUpdateOne {
	if i != nil {
		rdguo.SetDepth(*i)
	}
	return rdguo
}

// AddDepth adds i to the "depth" field.
func (rdguo *ReportDependencyGraphUpdateOne) AddDepth(i int) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.AddDepth(i)
	return rdguo
}

// SetIsDirect sets the "is_direct" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetIsDirect(b bool) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetIsDirect(b)
	return rdguo
}

// SetNillableIsDirect sets the "is_direct" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableIsDirect(b *bool) *ReportDependencyGraphUpdateOne {
	if b != nil {
		rdguo.SetIsDirect(*b)
	}
	return rdguo
}

// SetIsRootEdge sets the "is_root_edge" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetIsRootEdge(b bool) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetIsRootEdge(b)
	return rdguo
}

// SetNillableIsRootEdge sets the "is_root_edge" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableIsRootEdge(b *bool) *ReportDependencyGraphUpdateOne {
	if b != nil {
		rdguo.SetIsRootEdge(*b)
	}
	return rdguo
}

// SetManifestID sets the "manifest_id" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetManifestID(s string) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetManifestID(s)
	return rdguo
}

// SetNillableManifestID sets the "manifest_id" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableManifestID(s *string) *ReportDependencyGraphUpdateOne {
	if s != nil {
		rdguo.SetManifestID(*s)
	}
	return rdguo
}

// SetCreatedAt sets the "created_at" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetCreatedAt(t time.Time) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetCreatedAt(t)
	return rdguo
}

// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableCreatedAt(t *time.Time) *ReportDependencyGraphUpdateOne {
	if t != nil {
		rdguo.SetCreatedAt(*t)
	}
	return rdguo
}

// ClearCreatedAt clears the value of the "created_at" field.
func (rdguo *ReportDependencyGraphUpdateOne) ClearCreatedAt() *ReportDependencyGraphUpdateOne {
	rdguo.mutation.ClearCreatedAt()
	return rdguo
}

// SetUpdatedAt sets the "updated_at" field.
func (rdguo *ReportDependencyGraphUpdateOne) SetUpdatedAt(t time.Time) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.SetUpdatedAt(t)
	return rdguo
}

// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
func (rdguo *ReportDependencyGraphUpdateOne) SetNillableUpdatedAt(t *time.Time) *ReportDependencyGraphUpdateOne {
	if t != nil {
		rdguo.SetUpdatedAt(*t)
	}
	return rdguo
}

// ClearUpdatedAt clears the value of the "updated_at" field.
func (rdguo *ReportDependencyGraphUpdateOne) ClearUpdatedAt() *ReportDependencyGraphUpdateOne {
	rdguo.mutation.ClearUpdatedAt()
	return rdguo
}

// Mutation returns the ReportDependencyGraphMutation object of the builder.
func (rdguo *ReportDependencyGraphUpdateOne) Mutation() *ReportDependencyGraphMutation {
	return rdguo.mutation
}

// Where appends a list predicates to the ReportDependencyGraphUpdate builder.
func (rdguo *ReportDependencyGraphUpdateOne) Where(ps ...predicate.ReportDependencyGraph) *ReportDependencyGraphUpdateOne {
	rdguo.mutation.Where(ps...)
	return rdguo
}

// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (rdguo *ReportDependencyGraphUpdateOne) Select(field string, fields ...string) *ReportDependencyGraphUpdateOne {
	rdguo.fields = append([]string{field}, fields...)
	return rdguo
}

// Save executes the query and returns the updated ReportDependencyGraph entity.
func (rdguo *ReportDependencyGraphUpdateOne) Save(ctx context.Context) (*ReportDependencyGraph, error) {
	return withHooks(ctx, rdguo.sqlSave, rdguo.mutation, rdguo.hooks)
}

// SaveX is like Save, but panics if an error occurs.
func (rdguo *ReportDependencyGraphUpdateOne) SaveX(ctx context.Context) *ReportDependencyGraph {
	node, err := rdguo.Save(ctx)
	if err != nil {
		panic(err)
	}
	return node
}

// Exec executes the query on the entity.
func (rdguo *ReportDependencyGraphUpdateOne) Exec(ctx context.Context) error {
	_, err := rdguo.Save(ctx)
	return err
}

// ExecX is like Exec, but panics if an error occurs.
func (rdguo *ReportDependencyGraphUpdateOne) ExecX(ctx context.Context) {
	if err := rdguo.Exec(ctx); err != nil {
		panic(err)
	}
}

// check runs all checks and user-defined validators on the builder.
func (rdguo *ReportDependencyGraphUpdateOne) check() error {
	if v, ok := rdguo.mutation.FromPackageID(); ok {
		if err := reportdependencygraph.FromPackageIDValidator(v); err != nil {
			return &ValidationError{Name: "from_package_id", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.from_package_id": %w`, err)}
		}
	}
	if v, ok := rdguo.mutation.FromPackageName(); ok {
		if err := reportdependencygraph.FromPackageNameValidator(v); err != nil {
			return &ValidationError{Name: "from_package_name", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.from_package_name": %w`, err)}
		}
	}
	if v, ok := rdguo.mutation.FromPackageVersion(); ok {
		if err := reportdependencygraph.FromPackageVersionValidator(v); err != nil {
			return &ValidationError{Name: "from_package_version", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.from_package_version": %w`, err)}
		}
	}
	if v, ok := rdguo.mutation.FromPackageEcosystem(); ok {
		if err := reportdependencygraph.FromPackageEcosystemValidator(v); err != nil {
			return &ValidationError{Name: "from_package_ecosystem", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.from_package_ecosystem": %w`, err)}
		}
	}
	if v, ok := rdguo.mutation.ToPackageID(); ok {
		if err := reportdependencygraph.ToPackageIDValidator(v); err != nil {
			return &ValidationError{Name: "to_package_id", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.to_package_id": %w`, err)}
		}
	}
	if v, ok := rdguo.mutation.ToPackageName(); ok {
		if err := reportdependencygraph.ToPackageNameValidator(v); err != nil {
			return &ValidationError{Name: "to_package_name", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.to_package_name": %w`, err)}
		}
	}
	if v, ok := rdguo.mutation.ToPackageVersion(); ok {
		if err := reportdependencygraph.ToPackageVersionValidator(v); err != nil {
			return &ValidationError{Name: "to_package_version", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.to_package_version": %w`, err)}
		}
	}
	if v, ok := rdguo.mutation.ToPackageEcosystem(); ok {
		if err := reportdependencygraph.ToPackageEcosystemValidator(v); err != nil {
			return &ValidationError{Name: "to_package_ecosystem", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.to_package_ecosystem": %w`, err)}
		}
	}
	if v, ok := rdguo.mutation.ManifestID(); ok {
		if err := reportdependencygraph.ManifestIDValidator(v); err != nil {
			return &ValidationError{Name: "manifest_id", err: fmt.Errorf(`ent: validator failed for field "ReportDependencyGraph.manifest_id": %w`, err)}
		}
	}
	return nil
}

func (rdguo *ReportDependencyGraphUpdateOne) sqlSave(ctx context.Context) (_node *ReportDependencyGraph, err error) {
	if err := rdguo.check(); err != nil {
		return _node, err
	}
	_spec := sqlgraph.NewUpdateSpec(reportdependencygraph.Table, reportdependencygraph.Columns, sqlgraph.NewFieldSpec(reportdependencygraph.FieldID, field.TypeInt))
	id, ok := rdguo.mutation.ID()
	if !ok {
		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "ReportDependencyGraph.id" for update`)}
	}
	_spec.Node.ID.Value = id
	if fields := rdguo.fields; len(fields) > 0 {
		_spec.Node.Columns = make([]string, 0, len(fields))
		_spec.Node.Columns = append(_spec.Node.Columns, reportdependencygraph.FieldID)
		for _, f := range fields {
			if !reportdependencygraph.ValidColumn(f) {
				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
			}
			if f != reportdependencygraph.FieldID {
				_spec.Node.Columns = append(_spec.Node.Columns, f)
			}
		}
	}
	if ps := rdguo.mutation.predicates; len(ps) > 0 {
		_spec.Predicate = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	if value, ok := rdguo.mutation.FromPackageID(); ok {
		_spec.SetField(reportdependencygraph.FieldFromPackageID, field.TypeString, value)
	}
	if value, ok := rdguo.mutation.FromPackageName(); ok {
		_spec.SetField(reportdependencygraph.FieldFromPackageName, field.TypeString, value)
	}
	if value, ok := rdguo.mutation.FromPackageVersion(); ok {
		_spec.SetField(reportdependencygraph.FieldFromPackageVersion, field.TypeString, value)
	}
	if value, ok := rdguo.mutation.FromPackageEcosystem(); ok {
		_spec.SetField(reportdependencygraph.FieldFromPackageEcosystem, field.TypeString, value)
	}
	if value, ok := rdguo.mutation.ToPackageID(); ok {
		_spec.SetField(reportdependencygraph.FieldToPackageID, field.TypeString, value)
	}
	if value, ok := rdguo.mutation.ToPackageName(); ok {
		_spec.SetField(reportdependencygraph.FieldToPackageName, field.TypeString, value)
	}
	if value, ok := rdguo.mutation.ToPackageVersion(); ok {
		_spec.SetField(reportdependencygraph.FieldToPackageVersion, field.TypeString, value)
	}
	if value, ok := rdguo.mutation.ToPackageEcosystem(); ok {
		_spec.SetField(reportdependencygraph.FieldToPackageEcosystem, field.TypeString, value)
	}
	if value, ok := rdguo.mutation.DependencyType(); ok {
		_spec.SetField(reportdependencygraph.FieldDependencyType, field.TypeString, value)
	}
	if rdguo.mutation.DependencyTypeCleared() {
		_spec.ClearField(reportdependencygraph.FieldDependencyType, field.TypeString)
	}
	if value, ok := rdguo.mutation.VersionConstraint(); ok {
		_spec.SetField(reportdependencygraph.FieldVersionConstraint, field.TypeString, value)
	}
	if rdguo.mutation.VersionConstraintCleared() {
		_spec.ClearField(reportdependencygraph.FieldVersionConstraint, field.TypeString)
	}
	if value, ok := rdguo.mutation.Depth(); ok {
		_spec.SetField(reportdependencygraph.FieldDepth, field.TypeInt, value)
	}
	if value, ok := rdguo.mutation.AddedDepth(); ok {
		_spec.AddField(reportdependencygraph.FieldDepth, field.TypeInt, value)
	}
	if value, ok := rdguo.mutation.IsDirect(); ok {
		_spec.SetField(reportdependencygraph.FieldIsDirect, field.TypeBool, value)
	}
	if value, ok := rdguo.mutation.IsRootEdge(); ok {
		_spec.SetField(reportdependencygraph.FieldIsRootEdge, field.TypeBool, value)
	}
	if value, ok := rdguo.mutation.ManifestID(); ok {
		_spec.SetField(reportdependencygraph.FieldManifestID, field.TypeString, value)
	}
	if value, ok := rdguo.mutation.CreatedAt(); ok {
		_spec.SetField(reportdependencygraph.FieldCreatedAt, field.TypeTime, value)
	}
	if rdguo.mutation.CreatedAtCleared() {
		_spec.ClearField(reportdependencygraph.FieldCreatedAt, field.TypeTime)
	}
	if value, ok := rdguo.mutation.UpdatedAt(); ok {
		_spec.SetField(reportdependencygraph.FieldUpdatedAt, field.TypeTime, value)
	}
	if rdguo.mutation.UpdatedAtCleared() {
		_spec.ClearField(reportdependencygraph.FieldUpdatedAt, field.TypeTime)
	}
	_node = &ReportDependencyGraph{config: rdguo.config}
	_spec.Assign = _node.assignValues
	_spec.ScanValues = _node.scanValues
	if err = sqlgraph.UpdateNode(ctx, rdguo.driver, _spec); err != nil {
		if _, ok := err.(*sqlgraph.NotFoundError); ok {
			err = &NotFoundError{reportdependencygraph.Label}
		} else if sqlgraph.IsConstraintError(err) {
			err = &ConstraintError{msg: err.Error(), wrap: err}
		}
		return nil, err
	}
	rdguo.mutation.done = true
	return _node, nil
}