instance_update.go

// Code generated by entc, 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/google/uuid"
	"github.com/vorteil/direktiv/pkg/flow/ent/events"
	"github.com/vorteil/direktiv/pkg/flow/ent/instance"
	"github.com/vorteil/direktiv/pkg/flow/ent/instanceruntime"
	"github.com/vorteil/direktiv/pkg/flow/ent/logmsg"
	"github.com/vorteil/direktiv/pkg/flow/ent/namespace"
	"github.com/vorteil/direktiv/pkg/flow/ent/predicate"
	"github.com/vorteil/direktiv/pkg/flow/ent/revision"
	"github.com/vorteil/direktiv/pkg/flow/ent/varref"
	"github.com/vorteil/direktiv/pkg/flow/ent/workflow"
)

// InstanceUpdate is the builder for updating Instance entities.
type InstanceUpdate struct {
	config
	hooks    []Hook
	mutation *InstanceMutation
}

// Where appends a list predicates to the InstanceUpdate builder.
func (iu *InstanceUpdate) Where(ps ...predicate.Instance) *InstanceUpdate {
	iu.mutation.Where(ps...)
	return iu
}

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

// SetEndAt sets the "end_at" field.
func (iu *InstanceUpdate) SetEndAt(t time.Time) *InstanceUpdate {
	iu.mutation.SetEndAt(t)
	return iu
}

// SetNillableEndAt sets the "end_at" field if the given value is not nil.
func (iu *InstanceUpdate) SetNillableEndAt(t *time.Time) *InstanceUpdate {
	if t != nil {
		iu.SetEndAt(*t)
	}
	return iu
}

// ClearEndAt clears the value of the "end_at" field.
func (iu *InstanceUpdate) ClearEndAt() *InstanceUpdate {
	iu.mutation.ClearEndAt()
	return iu
}

// SetStatus sets the "status" field.
func (iu *InstanceUpdate) SetStatus(s string) *InstanceUpdate {
	iu.mutation.SetStatus(s)
	return iu
}

// SetErrorCode sets the "errorCode" field.
func (iu *InstanceUpdate) SetErrorCode(s string) *InstanceUpdate {
	iu.mutation.SetErrorCode(s)
	return iu
}

// SetNillableErrorCode sets the "errorCode" field if the given value is not nil.
func (iu *InstanceUpdate) SetNillableErrorCode(s *string) *InstanceUpdate {
	if s != nil {
		iu.SetErrorCode(*s)
	}
	return iu
}

// ClearErrorCode clears the value of the "errorCode" field.
func (iu *InstanceUpdate) ClearErrorCode() *InstanceUpdate {
	iu.mutation.ClearErrorCode()
	return iu
}

// SetErrorMessage sets the "errorMessage" field.
func (iu *InstanceUpdate) SetErrorMessage(s string) *InstanceUpdate {
	iu.mutation.SetErrorMessage(s)
	return iu
}

// SetNillableErrorMessage sets the "errorMessage" field if the given value is not nil.
func (iu *InstanceUpdate) SetNillableErrorMessage(s *string) *InstanceUpdate {
	if s != nil {
		iu.SetErrorMessage(*s)
	}
	return iu
}

// ClearErrorMessage clears the value of the "errorMessage" field.
func (iu *InstanceUpdate) ClearErrorMessage() *InstanceUpdate {
	iu.mutation.ClearErrorMessage()
	return iu
}

// SetNamespaceID sets the "namespace" edge to the Namespace entity by ID.
func (iu *InstanceUpdate) SetNamespaceID(id uuid.UUID) *InstanceUpdate {
	iu.mutation.SetNamespaceID(id)
	return iu
}

// SetNamespace sets the "namespace" edge to the Namespace entity.
func (iu *InstanceUpdate) SetNamespace(n *Namespace) *InstanceUpdate {
	return iu.SetNamespaceID(n.ID)
}

// SetWorkflowID sets the "workflow" edge to the Workflow entity by ID.
func (iu *InstanceUpdate) SetWorkflowID(id uuid.UUID) *InstanceUpdate {
	iu.mutation.SetWorkflowID(id)
	return iu
}

// SetWorkflow sets the "workflow" edge to the Workflow entity.
func (iu *InstanceUpdate) SetWorkflow(w *Workflow) *InstanceUpdate {
	return iu.SetWorkflowID(w.ID)
}

// SetRevisionID sets the "revision" edge to the Revision entity by ID.
func (iu *InstanceUpdate) SetRevisionID(id uuid.UUID) *InstanceUpdate {
	iu.mutation.SetRevisionID(id)
	return iu
}

// SetRevision sets the "revision" edge to the Revision entity.
func (iu *InstanceUpdate) SetRevision(r *Revision) *InstanceUpdate {
	return iu.SetRevisionID(r.ID)
}

// AddLogIDs adds the "logs" edge to the LogMsg entity by IDs.
func (iu *InstanceUpdate) AddLogIDs(ids ...uuid.UUID) *InstanceUpdate {
	iu.mutation.AddLogIDs(ids...)
	return iu
}

// AddLogs adds the "logs" edges to the LogMsg entity.
func (iu *InstanceUpdate) AddLogs(l ...*LogMsg) *InstanceUpdate {
	ids := make([]uuid.UUID, len(l))
	for i := range l {
		ids[i] = l[i].ID
	}
	return iu.AddLogIDs(ids...)
}

// AddVarIDs adds the "vars" edge to the VarRef entity by IDs.
func (iu *InstanceUpdate) AddVarIDs(ids ...uuid.UUID) *InstanceUpdate {
	iu.mutation.AddVarIDs(ids...)
	return iu
}

// AddVars adds the "vars" edges to the VarRef entity.
func (iu *InstanceUpdate) AddVars(v ...*VarRef) *InstanceUpdate {
	ids := make([]uuid.UUID, len(v))
	for i := range v {
		ids[i] = v[i].ID
	}
	return iu.AddVarIDs(ids...)
}

// SetRuntimeID sets the "runtime" edge to the InstanceRuntime entity by ID.
func (iu *InstanceUpdate) SetRuntimeID(id uuid.UUID) *InstanceUpdate {
	iu.mutation.SetRuntimeID(id)
	return iu
}

// SetRuntime sets the "runtime" edge to the InstanceRuntime entity.
func (iu *InstanceUpdate) SetRuntime(i *InstanceRuntime) *InstanceUpdate {
	return iu.SetRuntimeID(i.ID)
}

// AddChildIDs adds the "children" edge to the InstanceRuntime entity by IDs.
func (iu *InstanceUpdate) AddChildIDs(ids ...uuid.UUID) *InstanceUpdate {
	iu.mutation.AddChildIDs(ids...)
	return iu
}

// AddChildren adds the "children" edges to the InstanceRuntime entity.
func (iu *InstanceUpdate) AddChildren(i ...*InstanceRuntime) *InstanceUpdate {
	ids := make([]uuid.UUID, len(i))
	for j := range i {
		ids[j] = i[j].ID
	}
	return iu.AddChildIDs(ids...)
}

// AddEventlistenerIDs adds the "eventlisteners" edge to the Events entity by IDs.
func (iu *InstanceUpdate) AddEventlistenerIDs(ids ...uuid.UUID) *InstanceUpdate {
	iu.mutation.AddEventlistenerIDs(ids...)
	return iu
}

// AddEventlisteners adds the "eventlisteners" edges to the Events entity.
func (iu *InstanceUpdate) AddEventlisteners(e ...*Events) *InstanceUpdate {
	ids := make([]uuid.UUID, len(e))
	for i := range e {
		ids[i] = e[i].ID
	}
	return iu.AddEventlistenerIDs(ids...)
}

// Mutation returns the InstanceMutation object of the builder.
func (iu *InstanceUpdate) Mutation() *InstanceMutation {
	return iu.mutation
}

// ClearNamespace clears the "namespace" edge to the Namespace entity.
func (iu *InstanceUpdate) ClearNamespace() *InstanceUpdate {
	iu.mutation.ClearNamespace()
	return iu
}

// ClearWorkflow clears the "workflow" edge to the Workflow entity.
func (iu *InstanceUpdate) ClearWorkflow() *InstanceUpdate {
	iu.mutation.ClearWorkflow()
	return iu
}

// ClearRevision clears the "revision" edge to the Revision entity.
func (iu *InstanceUpdate) ClearRevision() *InstanceUpdate {
	iu.mutation.ClearRevision()
	return iu
}

// ClearLogs clears all "logs" edges to the LogMsg entity.
func (iu *InstanceUpdate) ClearLogs() *InstanceUpdate {
	iu.mutation.ClearLogs()
	return iu
}

// RemoveLogIDs removes the "logs" edge to LogMsg entities by IDs.
func (iu *InstanceUpdate) RemoveLogIDs(ids ...uuid.UUID) *InstanceUpdate {
	iu.mutation.RemoveLogIDs(ids...)
	return iu
}

// RemoveLogs removes "logs" edges to LogMsg entities.
func (iu *InstanceUpdate) RemoveLogs(l ...*LogMsg) *InstanceUpdate {
	ids := make([]uuid.UUID, len(l))
	for i := range l {
		ids[i] = l[i].ID
	}
	return iu.RemoveLogIDs(ids...)
}

// ClearVars clears all "vars" edges to the VarRef entity.
func (iu *InstanceUpdate) ClearVars() *InstanceUpdate {
	iu.mutation.ClearVars()
	return iu
}

// RemoveVarIDs removes the "vars" edge to VarRef entities by IDs.
func (iu *InstanceUpdate) RemoveVarIDs(ids ...uuid.UUID) *InstanceUpdate {
	iu.mutation.RemoveVarIDs(ids...)
	return iu
}

// RemoveVars removes "vars" edges to VarRef entities.
func (iu *InstanceUpdate) RemoveVars(v ...*VarRef) *InstanceUpdate {
	ids := make([]uuid.UUID, len(v))
	for i := range v {
		ids[i] = v[i].ID
	}
	return iu.RemoveVarIDs(ids...)
}

// ClearRuntime clears the "runtime" edge to the InstanceRuntime entity.
func (iu *InstanceUpdate) ClearRuntime() *InstanceUpdate {
	iu.mutation.ClearRuntime()
	return iu
}

// ClearChildren clears all "children" edges to the InstanceRuntime entity.
func (iu *InstanceUpdate) ClearChildren() *InstanceUpdate {
	iu.mutation.ClearChildren()
	return iu
}

// RemoveChildIDs removes the "children" edge to InstanceRuntime entities by IDs.
func (iu *InstanceUpdate) RemoveChildIDs(ids ...uuid.UUID) *InstanceUpdate {
	iu.mutation.RemoveChildIDs(ids...)
	return iu
}

// RemoveChildren removes "children" edges to InstanceRuntime entities.
func (iu *InstanceUpdate) RemoveChildren(i ...*InstanceRuntime) *InstanceUpdate {
	ids := make([]uuid.UUID, len(i))
	for j := range i {
		ids[j] = i[j].ID
	}
	return iu.RemoveChildIDs(ids...)
}

// ClearEventlisteners clears all "eventlisteners" edges to the Events entity.
func (iu *InstanceUpdate) ClearEventlisteners() *InstanceUpdate {
	iu.mutation.ClearEventlisteners()
	return iu
}

// RemoveEventlistenerIDs removes the "eventlisteners" edge to Events entities by IDs.
func (iu *InstanceUpdate) RemoveEventlistenerIDs(ids ...uuid.UUID) *InstanceUpdate {
	iu.mutation.RemoveEventlistenerIDs(ids...)
	return iu
}

// RemoveEventlisteners removes "eventlisteners" edges to Events entities.
func (iu *InstanceUpdate) RemoveEventlisteners(e ...*Events) *InstanceUpdate {
	ids := make([]uuid.UUID, len(e))
	for i := range e {
		ids[i] = e[i].ID
	}
	return iu.RemoveEventlistenerIDs(ids...)
}

// Save executes the query and returns the number of nodes affected by the update operation.
func (iu *InstanceUpdate) Save(ctx context.Context) (int, error) {
	var (
		err      error
		affected int
	)
	iu.defaults()
	if len(iu.hooks) == 0 {
		if err = iu.check(); err != nil {
			return 0, err
		}
		affected, err = iu.sqlSave(ctx)
	} else {
		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
			mutation, ok := m.(*InstanceMutation)
			if !ok {
				return nil, fmt.Errorf("unexpected mutation type %T", m)
			}
			if err = iu.check(); err != nil {
				return 0, err
			}
			iu.mutation = mutation
			affected, err = iu.sqlSave(ctx)
			mutation.done = true
			return affected, err
		})
		for i := len(iu.hooks) - 1; i >= 0; i-- {
			if iu.hooks[i] == nil {
				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
			}
			mut = iu.hooks[i](mut)
		}
		if _, err := mut.Mutate(ctx, iu.mutation); err != nil {
			return 0, err
		}
	}
	return affected, err
}

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

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

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

// defaults sets the default values of the builder before save.
func (iu *InstanceUpdate) defaults() {
	if _, ok := iu.mutation.UpdatedAt(); !ok {
		v := instance.UpdateDefaultUpdatedAt()
		iu.mutation.SetUpdatedAt(v)
	}
}

// check runs all checks and user-defined validators on the builder.
func (iu *InstanceUpdate) check() error {
	if _, ok := iu.mutation.NamespaceID(); iu.mutation.NamespaceCleared() && !ok {
		return errors.New("ent: clearing a required unique edge \"namespace\"")
	}
	if _, ok := iu.mutation.WorkflowID(); iu.mutation.WorkflowCleared() && !ok {
		return errors.New("ent: clearing a required unique edge \"workflow\"")
	}
	if _, ok := iu.mutation.RevisionID(); iu.mutation.RevisionCleared() && !ok {
		return errors.New("ent: clearing a required unique edge \"revision\"")
	}
	if _, ok := iu.mutation.RuntimeID(); iu.mutation.RuntimeCleared() && !ok {
		return errors.New("ent: clearing a required unique edge \"runtime\"")
	}
	return nil
}

func (iu *InstanceUpdate) sqlSave(ctx context.Context) (n int, err error) {
	_spec := &sqlgraph.UpdateSpec{
		Node: &sqlgraph.NodeSpec{
			Table:   instance.Table,
			Columns: instance.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUUID,
				Column: instance.FieldID,
			},
		},
	}
	if ps := iu.mutation.predicates; len(ps) > 0 {
		_spec.Predicate = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	if value, ok := iu.mutation.UpdatedAt(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeTime,
			Value:  value,
			Column: instance.FieldUpdatedAt,
		})
	}
	if value, ok := iu.mutation.EndAt(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeTime,
			Value:  value,
			Column: instance.FieldEndAt,
		})
	}
	if iu.mutation.EndAtCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeTime,
			Column: instance.FieldEndAt,
		})
	}
	if value, ok := iu.mutation.Status(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: instance.FieldStatus,
		})
	}
	if value, ok := iu.mutation.ErrorCode(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: instance.FieldErrorCode,
		})
	}
	if iu.mutation.ErrorCodeCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Column: instance.FieldErrorCode,
		})
	}
	if value, ok := iu.mutation.ErrorMessage(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: instance.FieldErrorMessage,
		})
	}
	if iu.mutation.ErrorMessageCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Column: instance.FieldErrorMessage,
		})
	}
	if iu.mutation.NamespaceCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   instance.NamespaceTable,
			Columns: []string{instance.NamespaceColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: namespace.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iu.mutation.NamespaceIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   instance.NamespaceTable,
			Columns: []string{instance.NamespaceColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: namespace.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iu.mutation.WorkflowCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   instance.WorkflowTable,
			Columns: []string{instance.WorkflowColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: workflow.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iu.mutation.WorkflowIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   instance.WorkflowTable,
			Columns: []string{instance.WorkflowColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: workflow.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iu.mutation.RevisionCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   instance.RevisionTable,
			Columns: []string{instance.RevisionColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: revision.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iu.mutation.RevisionIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   instance.RevisionTable,
			Columns: []string{instance.RevisionColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: revision.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iu.mutation.LogsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.LogsTable,
			Columns: []string{instance.LogsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: logmsg.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iu.mutation.RemovedLogsIDs(); len(nodes) > 0 && !iu.mutation.LogsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.LogsTable,
			Columns: []string{instance.LogsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: logmsg.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iu.mutation.LogsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.LogsTable,
			Columns: []string{instance.LogsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: logmsg.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iu.mutation.VarsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.VarsTable,
			Columns: []string{instance.VarsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: varref.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iu.mutation.RemovedVarsIDs(); len(nodes) > 0 && !iu.mutation.VarsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.VarsTable,
			Columns: []string{instance.VarsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: varref.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iu.mutation.VarsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.VarsTable,
			Columns: []string{instance.VarsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: varref.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iu.mutation.RuntimeCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2O,
			Inverse: false,
			Table:   instance.RuntimeTable,
			Columns: []string{instance.RuntimeColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: instanceruntime.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iu.mutation.RuntimeIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2O,
			Inverse: false,
			Table:   instance.RuntimeTable,
			Columns: []string{instance.RuntimeColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: instanceruntime.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iu.mutation.ChildrenCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.ChildrenTable,
			Columns: []string{instance.ChildrenColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: instanceruntime.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iu.mutation.RemovedChildrenIDs(); len(nodes) > 0 && !iu.mutation.ChildrenCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.ChildrenTable,
			Columns: []string{instance.ChildrenColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: instanceruntime.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iu.mutation.ChildrenIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.ChildrenTable,
			Columns: []string{instance.ChildrenColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: instanceruntime.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iu.mutation.EventlistenersCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.EventlistenersTable,
			Columns: []string{instance.EventlistenersColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: events.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iu.mutation.RemovedEventlistenersIDs(); len(nodes) > 0 && !iu.mutation.EventlistenersCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.EventlistenersTable,
			Columns: []string{instance.EventlistenersColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: events.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iu.mutation.EventlistenersIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.EventlistenersTable,
			Columns: []string{instance.EventlistenersColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: events.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if n, err = sqlgraph.UpdateNodes(ctx, iu.driver, _spec); err != nil {
		if _, ok := err.(*sqlgraph.NotFoundError); ok {
			err = &NotFoundError{instance.Label}
		} else if sqlgraph.IsConstraintError(err) {
			err = &ConstraintError{err.Error(), err}
		}
		return 0, err
	}
	return n, nil
}

// InstanceUpdateOne is the builder for updating a single Instance entity.
type InstanceUpdateOne struct {
	config
	fields   []string
	hooks    []Hook
	mutation *InstanceMutation
}

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

// SetEndAt sets the "end_at" field.
func (iuo *InstanceUpdateOne) SetEndAt(t time.Time) *InstanceUpdateOne {
	iuo.mutation.SetEndAt(t)
	return iuo
}

// SetNillableEndAt sets the "end_at" field if the given value is not nil.
func (iuo *InstanceUpdateOne) SetNillableEndAt(t *time.Time) *InstanceUpdateOne {
	if t != nil {
		iuo.SetEndAt(*t)
	}
	return iuo
}

// ClearEndAt clears the value of the "end_at" field.
func (iuo *InstanceUpdateOne) ClearEndAt() *InstanceUpdateOne {
	iuo.mutation.ClearEndAt()
	return iuo
}

// SetStatus sets the "status" field.
func (iuo *InstanceUpdateOne) SetStatus(s string) *InstanceUpdateOne {
	iuo.mutation.SetStatus(s)
	return iuo
}

// SetErrorCode sets the "errorCode" field.
func (iuo *InstanceUpdateOne) SetErrorCode(s string) *InstanceUpdateOne {
	iuo.mutation.SetErrorCode(s)
	return iuo
}

// SetNillableErrorCode sets the "errorCode" field if the given value is not nil.
func (iuo *InstanceUpdateOne) SetNillableErrorCode(s *string) *InstanceUpdateOne {
	if s != nil {
		iuo.SetErrorCode(*s)
	}
	return iuo
}

// ClearErrorCode clears the value of the "errorCode" field.
func (iuo *InstanceUpdateOne) ClearErrorCode() *InstanceUpdateOne {
	iuo.mutation.ClearErrorCode()
	return iuo
}

// SetErrorMessage sets the "errorMessage" field.
func (iuo *InstanceUpdateOne) SetErrorMessage(s string) *InstanceUpdateOne {
	iuo.mutation.SetErrorMessage(s)
	return iuo
}

// SetNillableErrorMessage sets the "errorMessage" field if the given value is not nil.
func (iuo *InstanceUpdateOne) SetNillableErrorMessage(s *string) *InstanceUpdateOne {
	if s != nil {
		iuo.SetErrorMessage(*s)
	}
	return iuo
}

// ClearErrorMessage clears the value of the "errorMessage" field.
func (iuo *InstanceUpdateOne) ClearErrorMessage() *InstanceUpdateOne {
	iuo.mutation.ClearErrorMessage()
	return iuo
}

// SetNamespaceID sets the "namespace" edge to the Namespace entity by ID.
func (iuo *InstanceUpdateOne) SetNamespaceID(id uuid.UUID) *InstanceUpdateOne {
	iuo.mutation.SetNamespaceID(id)
	return iuo
}

// SetNamespace sets the "namespace" edge to the Namespace entity.
func (iuo *InstanceUpdateOne) SetNamespace(n *Namespace) *InstanceUpdateOne {
	return iuo.SetNamespaceID(n.ID)
}

// SetWorkflowID sets the "workflow" edge to the Workflow entity by ID.
func (iuo *InstanceUpdateOne) SetWorkflowID(id uuid.UUID) *InstanceUpdateOne {
	iuo.mutation.SetWorkflowID(id)
	return iuo
}

// SetWorkflow sets the "workflow" edge to the Workflow entity.
func (iuo *InstanceUpdateOne) SetWorkflow(w *Workflow) *InstanceUpdateOne {
	return iuo.SetWorkflowID(w.ID)
}

// SetRevisionID sets the "revision" edge to the Revision entity by ID.
func (iuo *InstanceUpdateOne) SetRevisionID(id uuid.UUID) *InstanceUpdateOne {
	iuo.mutation.SetRevisionID(id)
	return iuo
}

// SetRevision sets the "revision" edge to the Revision entity.
func (iuo *InstanceUpdateOne) SetRevision(r *Revision) *InstanceUpdateOne {
	return iuo.SetRevisionID(r.ID)
}

// AddLogIDs adds the "logs" edge to the LogMsg entity by IDs.
func (iuo *InstanceUpdateOne) AddLogIDs(ids ...uuid.UUID) *InstanceUpdateOne {
	iuo.mutation.AddLogIDs(ids...)
	return iuo
}

// AddLogs adds the "logs" edges to the LogMsg entity.
func (iuo *InstanceUpdateOne) AddLogs(l ...*LogMsg) *InstanceUpdateOne {
	ids := make([]uuid.UUID, len(l))
	for i := range l {
		ids[i] = l[i].ID
	}
	return iuo.AddLogIDs(ids...)
}

// AddVarIDs adds the "vars" edge to the VarRef entity by IDs.
func (iuo *InstanceUpdateOne) AddVarIDs(ids ...uuid.UUID) *InstanceUpdateOne {
	iuo.mutation.AddVarIDs(ids...)
	return iuo
}

// AddVars adds the "vars" edges to the VarRef entity.
func (iuo *InstanceUpdateOne) AddVars(v ...*VarRef) *InstanceUpdateOne {
	ids := make([]uuid.UUID, len(v))
	for i := range v {
		ids[i] = v[i].ID
	}
	return iuo.AddVarIDs(ids...)
}

// SetRuntimeID sets the "runtime" edge to the InstanceRuntime entity by ID.
func (iuo *InstanceUpdateOne) SetRuntimeID(id uuid.UUID) *InstanceUpdateOne {
	iuo.mutation.SetRuntimeID(id)
	return iuo
}

// SetRuntime sets the "runtime" edge to the InstanceRuntime entity.
func (iuo *InstanceUpdateOne) SetRuntime(i *InstanceRuntime) *InstanceUpdateOne {
	return iuo.SetRuntimeID(i.ID)
}

// AddChildIDs adds the "children" edge to the InstanceRuntime entity by IDs.
func (iuo *InstanceUpdateOne) AddChildIDs(ids ...uuid.UUID) *InstanceUpdateOne {
	iuo.mutation.AddChildIDs(ids...)
	return iuo
}

// AddChildren adds the "children" edges to the InstanceRuntime entity.
func (iuo *InstanceUpdateOne) AddChildren(i ...*InstanceRuntime) *InstanceUpdateOne {
	ids := make([]uuid.UUID, len(i))
	for j := range i {
		ids[j] = i[j].ID
	}
	return iuo.AddChildIDs(ids...)
}

// AddEventlistenerIDs adds the "eventlisteners" edge to the Events entity by IDs.
func (iuo *InstanceUpdateOne) AddEventlistenerIDs(ids ...uuid.UUID) *InstanceUpdateOne {
	iuo.mutation.AddEventlistenerIDs(ids...)
	return iuo
}

// AddEventlisteners adds the "eventlisteners" edges to the Events entity.
func (iuo *InstanceUpdateOne) AddEventlisteners(e ...*Events) *InstanceUpdateOne {
	ids := make([]uuid.UUID, len(e))
	for i := range e {
		ids[i] = e[i].ID
	}
	return iuo.AddEventlistenerIDs(ids...)
}

// Mutation returns the InstanceMutation object of the builder.
func (iuo *InstanceUpdateOne) Mutation() *InstanceMutation {
	return iuo.mutation
}

// ClearNamespace clears the "namespace" edge to the Namespace entity.
func (iuo *InstanceUpdateOne) ClearNamespace() *InstanceUpdateOne {
	iuo.mutation.ClearNamespace()
	return iuo
}

// ClearWorkflow clears the "workflow" edge to the Workflow entity.
func (iuo *InstanceUpdateOne) ClearWorkflow() *InstanceUpdateOne {
	iuo.mutation.ClearWorkflow()
	return iuo
}

// ClearRevision clears the "revision" edge to the Revision entity.
func (iuo *InstanceUpdateOne) ClearRevision() *InstanceUpdateOne {
	iuo.mutation.ClearRevision()
	return iuo
}

// ClearLogs clears all "logs" edges to the LogMsg entity.
func (iuo *InstanceUpdateOne) ClearLogs() *InstanceUpdateOne {
	iuo.mutation.ClearLogs()
	return iuo
}

// RemoveLogIDs removes the "logs" edge to LogMsg entities by IDs.
func (iuo *InstanceUpdateOne) RemoveLogIDs(ids ...uuid.UUID) *InstanceUpdateOne {
	iuo.mutation.RemoveLogIDs(ids...)
	return iuo
}

// RemoveLogs removes "logs" edges to LogMsg entities.
func (iuo *InstanceUpdateOne) RemoveLogs(l ...*LogMsg) *InstanceUpdateOne {
	ids := make([]uuid.UUID, len(l))
	for i := range l {
		ids[i] = l[i].ID
	}
	return iuo.RemoveLogIDs(ids...)
}

// ClearVars clears all "vars" edges to the VarRef entity.
func (iuo *InstanceUpdateOne) ClearVars() *InstanceUpdateOne {
	iuo.mutation.ClearVars()
	return iuo
}

// RemoveVarIDs removes the "vars" edge to VarRef entities by IDs.
func (iuo *InstanceUpdateOne) RemoveVarIDs(ids ...uuid.UUID) *InstanceUpdateOne {
	iuo.mutation.RemoveVarIDs(ids...)
	return iuo
}

// RemoveVars removes "vars" edges to VarRef entities.
func (iuo *InstanceUpdateOne) RemoveVars(v ...*VarRef) *InstanceUpdateOne {
	ids := make([]uuid.UUID, len(v))
	for i := range v {
		ids[i] = v[i].ID
	}
	return iuo.RemoveVarIDs(ids...)
}

// ClearRuntime clears the "runtime" edge to the InstanceRuntime entity.
func (iuo *InstanceUpdateOne) ClearRuntime() *InstanceUpdateOne {
	iuo.mutation.ClearRuntime()
	return iuo
}

// ClearChildren clears all "children" edges to the InstanceRuntime entity.
func (iuo *InstanceUpdateOne) ClearChildren() *InstanceUpdateOne {
	iuo.mutation.ClearChildren()
	return iuo
}

// RemoveChildIDs removes the "children" edge to InstanceRuntime entities by IDs.
func (iuo *InstanceUpdateOne) RemoveChildIDs(ids ...uuid.UUID) *InstanceUpdateOne {
	iuo.mutation.RemoveChildIDs(ids...)
	return iuo
}

// RemoveChildren removes "children" edges to InstanceRuntime entities.
func (iuo *InstanceUpdateOne) RemoveChildren(i ...*InstanceRuntime) *InstanceUpdateOne {
	ids := make([]uuid.UUID, len(i))
	for j := range i {
		ids[j] = i[j].ID
	}
	return iuo.RemoveChildIDs(ids...)
}

// ClearEventlisteners clears all "eventlisteners" edges to the Events entity.
func (iuo *InstanceUpdateOne) ClearEventlisteners() *InstanceUpdateOne {
	iuo.mutation.ClearEventlisteners()
	return iuo
}

// RemoveEventlistenerIDs removes the "eventlisteners" edge to Events entities by IDs.
func (iuo *InstanceUpdateOne) RemoveEventlistenerIDs(ids ...uuid.UUID) *InstanceUpdateOne {
	iuo.mutation.RemoveEventlistenerIDs(ids...)
	return iuo
}

// RemoveEventlisteners removes "eventlisteners" edges to Events entities.
func (iuo *InstanceUpdateOne) RemoveEventlisteners(e ...*Events) *InstanceUpdateOne {
	ids := make([]uuid.UUID, len(e))
	for i := range e {
		ids[i] = e[i].ID
	}
	return iuo.RemoveEventlistenerIDs(ids...)
}

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

// Save executes the query and returns the updated Instance entity.
func (iuo *InstanceUpdateOne) Save(ctx context.Context) (*Instance, error) {
	var (
		err  error
		node *Instance
	)
	iuo.defaults()
	if len(iuo.hooks) == 0 {
		if err = iuo.check(); err != nil {
			return nil, err
		}
		node, err = iuo.sqlSave(ctx)
	} else {
		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
			mutation, ok := m.(*InstanceMutation)
			if !ok {
				return nil, fmt.Errorf("unexpected mutation type %T", m)
			}
			if err = iuo.check(); err != nil {
				return nil, err
			}
			iuo.mutation = mutation
			node, err = iuo.sqlSave(ctx)
			mutation.done = true
			return node, err
		})
		for i := len(iuo.hooks) - 1; i >= 0; i-- {
			if iuo.hooks[i] == nil {
				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
			}
			mut = iuo.hooks[i](mut)
		}
		if _, err := mut.Mutate(ctx, iuo.mutation); err != nil {
			return nil, err
		}
	}
	return node, err
}

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

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

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

// defaults sets the default values of the builder before save.
func (iuo *InstanceUpdateOne) defaults() {
	if _, ok := iuo.mutation.UpdatedAt(); !ok {
		v := instance.UpdateDefaultUpdatedAt()
		iuo.mutation.SetUpdatedAt(v)
	}
}

// check runs all checks and user-defined validators on the builder.
func (iuo *InstanceUpdateOne) check() error {
	if _, ok := iuo.mutation.NamespaceID(); iuo.mutation.NamespaceCleared() && !ok {
		return errors.New("ent: clearing a required unique edge \"namespace\"")
	}
	if _, ok := iuo.mutation.WorkflowID(); iuo.mutation.WorkflowCleared() && !ok {
		return errors.New("ent: clearing a required unique edge \"workflow\"")
	}
	if _, ok := iuo.mutation.RevisionID(); iuo.mutation.RevisionCleared() && !ok {
		return errors.New("ent: clearing a required unique edge \"revision\"")
	}
	if _, ok := iuo.mutation.RuntimeID(); iuo.mutation.RuntimeCleared() && !ok {
		return errors.New("ent: clearing a required unique edge \"runtime\"")
	}
	return nil
}

func (iuo *InstanceUpdateOne) sqlSave(ctx context.Context) (_node *Instance, err error) {
	_spec := &sqlgraph.UpdateSpec{
		Node: &sqlgraph.NodeSpec{
			Table:   instance.Table,
			Columns: instance.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUUID,
				Column: instance.FieldID,
			},
		},
	}
	id, ok := iuo.mutation.ID()
	if !ok {
		return nil, &ValidationError{Name: "ID", err: fmt.Errorf("missing Instance.ID for update")}
	}
	_spec.Node.ID.Value = id
	if fields := iuo.fields; len(fields) > 0 {
		_spec.Node.Columns = make([]string, 0, len(fields))
		_spec.Node.Columns = append(_spec.Node.Columns, instance.FieldID)
		for _, f := range fields {
			if !instance.ValidColumn(f) {
				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
			}
			if f != instance.FieldID {
				_spec.Node.Columns = append(_spec.Node.Columns, f)
			}
		}
	}
	if ps := iuo.mutation.predicates; len(ps) > 0 {
		_spec.Predicate = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	if value, ok := iuo.mutation.UpdatedAt(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeTime,
			Value:  value,
			Column: instance.FieldUpdatedAt,
		})
	}
	if value, ok := iuo.mutation.EndAt(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeTime,
			Value:  value,
			Column: instance.FieldEndAt,
		})
	}
	if iuo.mutation.EndAtCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeTime,
			Column: instance.FieldEndAt,
		})
	}
	if value, ok := iuo.mutation.Status(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: instance.FieldStatus,
		})
	}
	if value, ok := iuo.mutation.ErrorCode(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: instance.FieldErrorCode,
		})
	}
	if iuo.mutation.ErrorCodeCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Column: instance.FieldErrorCode,
		})
	}
	if value, ok := iuo.mutation.ErrorMessage(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: instance.FieldErrorMessage,
		})
	}
	if iuo.mutation.ErrorMessageCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Column: instance.FieldErrorMessage,
		})
	}
	if iuo.mutation.NamespaceCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   instance.NamespaceTable,
			Columns: []string{instance.NamespaceColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: namespace.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iuo.mutation.NamespaceIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   instance.NamespaceTable,
			Columns: []string{instance.NamespaceColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: namespace.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iuo.mutation.WorkflowCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   instance.WorkflowTable,
			Columns: []string{instance.WorkflowColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: workflow.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iuo.mutation.WorkflowIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   instance.WorkflowTable,
			Columns: []string{instance.WorkflowColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: workflow.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iuo.mutation.RevisionCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   instance.RevisionTable,
			Columns: []string{instance.RevisionColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: revision.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iuo.mutation.RevisionIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   instance.RevisionTable,
			Columns: []string{instance.RevisionColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: revision.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iuo.mutation.LogsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.LogsTable,
			Columns: []string{instance.LogsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: logmsg.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iuo.mutation.RemovedLogsIDs(); len(nodes) > 0 && !iuo.mutation.LogsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.LogsTable,
			Columns: []string{instance.LogsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: logmsg.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iuo.mutation.LogsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.LogsTable,
			Columns: []string{instance.LogsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: logmsg.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iuo.mutation.VarsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.VarsTable,
			Columns: []string{instance.VarsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: varref.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iuo.mutation.RemovedVarsIDs(); len(nodes) > 0 && !iuo.mutation.VarsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.VarsTable,
			Columns: []string{instance.VarsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: varref.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iuo.mutation.VarsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.VarsTable,
			Columns: []string{instance.VarsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: varref.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iuo.mutation.RuntimeCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2O,
			Inverse: false,
			Table:   instance.RuntimeTable,
			Columns: []string{instance.RuntimeColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: instanceruntime.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iuo.mutation.RuntimeIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2O,
			Inverse: false,
			Table:   instance.RuntimeTable,
			Columns: []string{instance.RuntimeColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: instanceruntime.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iuo.mutation.ChildrenCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.ChildrenTable,
			Columns: []string{instance.ChildrenColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: instanceruntime.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iuo.mutation.RemovedChildrenIDs(); len(nodes) > 0 && !iuo.mutation.ChildrenCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.ChildrenTable,
			Columns: []string{instance.ChildrenColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: instanceruntime.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iuo.mutation.ChildrenIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.ChildrenTable,
			Columns: []string{instance.ChildrenColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: instanceruntime.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if iuo.mutation.EventlistenersCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.EventlistenersTable,
			Columns: []string{instance.EventlistenersColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: events.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iuo.mutation.RemovedEventlistenersIDs(); len(nodes) > 0 && !iuo.mutation.EventlistenersCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.EventlistenersTable,
			Columns: []string{instance.EventlistenersColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: events.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := iuo.mutation.EventlistenersIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   instance.EventlistenersTable,
			Columns: []string{instance.EventlistenersColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: events.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	_node = &Instance{config: iuo.config}
	_spec.Assign = _node.assignValues
	_spec.ScanValues = _node.scanValues
	if err = sqlgraph.UpdateNode(ctx, iuo.driver, _spec); err != nil {
		if _, ok := err.(*sqlgraph.NotFoundError); ok {
			err = &NotFoundError{instance.Label}
		} else if sqlgraph.IsConstraintError(err) {
			err = &ConstraintError{err.Error(), err}
		}
		return nil, err
	}
	return _node, nil
}