moduleversion_update.go

// Code generated by entc, DO NOT EDIT.

package ent

import (
	"context"
	"errors"
	"fmt"

	"github.com/facebookincubator/ent/dialect/sql"
	"github.com/meringu/terraform-private-registry/internal/ent/module"
	"github.com/meringu/terraform-private-registry/internal/ent/moduleversion"
	"github.com/meringu/terraform-private-registry/internal/ent/predicate"
)

// ModuleVersionUpdate is the builder for updating ModuleVersion entities.
type ModuleVersionUpdate struct {
	config
	major         *int
	addmajor      *int
	minor         *int
	addminor      *int
	patch         *int
	addpatch      *int
	tag           *string
	module        map[int]struct{}
	clearedModule bool
	predicates    []predicate.ModuleVersion
}

// Where adds a new predicate for the builder.
func (mvu *ModuleVersionUpdate) Where(ps ...predicate.ModuleVersion) *ModuleVersionUpdate {
	mvu.predicates = append(mvu.predicates, ps...)
	return mvu
}

// SetMajor sets the major field.
func (mvu *ModuleVersionUpdate) SetMajor(i int) *ModuleVersionUpdate {
	mvu.major = &i
	mvu.addmajor = nil
	return mvu
}

// AddMajor adds i to major.
func (mvu *ModuleVersionUpdate) AddMajor(i int) *ModuleVersionUpdate {
	if mvu.addmajor == nil {
		mvu.addmajor = &i
	} else {
		*mvu.addmajor += i
	}
	return mvu
}

// SetMinor sets the minor field.
func (mvu *ModuleVersionUpdate) SetMinor(i int) *ModuleVersionUpdate {
	mvu.minor = &i
	mvu.addminor = nil
	return mvu
}

// AddMinor adds i to minor.
func (mvu *ModuleVersionUpdate) AddMinor(i int) *ModuleVersionUpdate {
	if mvu.addminor == nil {
		mvu.addminor = &i
	} else {
		*mvu.addminor += i
	}
	return mvu
}

// SetPatch sets the patch field.
func (mvu *ModuleVersionUpdate) SetPatch(i int) *ModuleVersionUpdate {
	mvu.patch = &i
	mvu.addpatch = nil
	return mvu
}

// AddPatch adds i to patch.
func (mvu *ModuleVersionUpdate) AddPatch(i int) *ModuleVersionUpdate {
	if mvu.addpatch == nil {
		mvu.addpatch = &i
	} else {
		*mvu.addpatch += i
	}
	return mvu
}

// SetTag sets the tag field.
func (mvu *ModuleVersionUpdate) SetTag(s string) *ModuleVersionUpdate {
	mvu.tag = &s
	return mvu
}

// SetModuleID sets the module edge to Module by id.
func (mvu *ModuleVersionUpdate) SetModuleID(id int) *ModuleVersionUpdate {
	if mvu.module == nil {
		mvu.module = make(map[int]struct{})
	}
	mvu.module[id] = struct{}{}
	return mvu
}

// SetModule sets the module edge to Module.
func (mvu *ModuleVersionUpdate) SetModule(m *Module) *ModuleVersionUpdate {
	return mvu.SetModuleID(m.ID)
}

// ClearModule clears the module edge to Module.
func (mvu *ModuleVersionUpdate) ClearModule() *ModuleVersionUpdate {
	mvu.clearedModule = true
	return mvu
}

// Save executes the query and returns the number of rows/vertices matched by this operation.
func (mvu *ModuleVersionUpdate) Save(ctx context.Context) (int, error) {
	if mvu.major != nil {
		if err := moduleversion.MajorValidator(*mvu.major); err != nil {
			return 0, fmt.Errorf("ent: validator failed for field \"major\": %v", err)
		}
	}
	if mvu.minor != nil {
		if err := moduleversion.MinorValidator(*mvu.minor); err != nil {
			return 0, fmt.Errorf("ent: validator failed for field \"minor\": %v", err)
		}
	}
	if mvu.patch != nil {
		if err := moduleversion.PatchValidator(*mvu.patch); err != nil {
			return 0, fmt.Errorf("ent: validator failed for field \"patch\": %v", err)
		}
	}
	if len(mvu.module) > 1 {
		return 0, errors.New("ent: multiple assignments on a unique edge \"module\"")
	}
	if mvu.clearedModule && mvu.module == nil {
		return 0, errors.New("ent: clearing a unique edge \"module\"")
	}
	return mvu.sqlSave(ctx)
}

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

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

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

func (mvu *ModuleVersionUpdate) sqlSave(ctx context.Context) (n int, err error) {
	selector := sql.Select(moduleversion.FieldID).From(sql.Table(moduleversion.Table))
	for _, p := range mvu.predicates {
		p(selector)
	}
	rows := &sql.Rows{}
	query, args := selector.Query()
	if err = mvu.driver.Query(ctx, query, args, rows); err != nil {
		return 0, err
	}
	defer rows.Close()
	var ids []int
	for rows.Next() {
		var id int
		if err := rows.Scan(&id); err != nil {
			return 0, fmt.Errorf("ent: failed reading id: %v", err)
		}
		ids = append(ids, id)
	}
	if len(ids) == 0 {
		return 0, nil
	}

	tx, err := mvu.driver.Tx(ctx)
	if err != nil {
		return 0, err
	}
	var (
		res     sql.Result
		builder = sql.Update(moduleversion.Table).Where(sql.InInts(moduleversion.FieldID, ids...))
	)
	if value := mvu.major; value != nil {
		builder.Set(moduleversion.FieldMajor, *value)
	}
	if value := mvu.addmajor; value != nil {
		builder.Add(moduleversion.FieldMajor, *value)
	}
	if value := mvu.minor; value != nil {
		builder.Set(moduleversion.FieldMinor, *value)
	}
	if value := mvu.addminor; value != nil {
		builder.Add(moduleversion.FieldMinor, *value)
	}
	if value := mvu.patch; value != nil {
		builder.Set(moduleversion.FieldPatch, *value)
	}
	if value := mvu.addpatch; value != nil {
		builder.Add(moduleversion.FieldPatch, *value)
	}
	if value := mvu.tag; value != nil {
		builder.Set(moduleversion.FieldTag, *value)
	}
	if !builder.Empty() {
		query, args := builder.Query()
		if err := tx.Exec(ctx, query, args, &res); err != nil {
			return 0, rollback(tx, err)
		}
	}
	if mvu.clearedModule {
		query, args := sql.Update(moduleversion.ModuleTable).
			SetNull(moduleversion.ModuleColumn).
			Where(sql.InInts(module.FieldID, ids...)).
			Query()
		if err := tx.Exec(ctx, query, args, &res); err != nil {
			return 0, rollback(tx, err)
		}
	}
	if len(mvu.module) > 0 {
		for eid := range mvu.module {
			query, args := sql.Update(moduleversion.ModuleTable).
				Set(moduleversion.ModuleColumn, eid).
				Where(sql.InInts(moduleversion.FieldID, ids...)).
				Query()
			if err := tx.Exec(ctx, query, args, &res); err != nil {
				return 0, rollback(tx, err)
			}
		}
	}
	if err = tx.Commit(); err != nil {
		return 0, err
	}
	return len(ids), nil
}

// ModuleVersionUpdateOne is the builder for updating a single ModuleVersion entity.
type ModuleVersionUpdateOne struct {
	config
	id            int
	major         *int
	addmajor      *int
	minor         *int
	addminor      *int
	patch         *int
	addpatch      *int
	tag           *string
	module        map[int]struct{}
	clearedModule bool
}

// SetMajor sets the major field.
func (mvuo *ModuleVersionUpdateOne) SetMajor(i int) *ModuleVersionUpdateOne {
	mvuo.major = &i
	mvuo.addmajor = nil
	return mvuo
}

// AddMajor adds i to major.
func (mvuo *ModuleVersionUpdateOne) AddMajor(i int) *ModuleVersionUpdateOne {
	if mvuo.addmajor == nil {
		mvuo.addmajor = &i
	} else {
		*mvuo.addmajor += i
	}
	return mvuo
}

// SetMinor sets the minor field.
func (mvuo *ModuleVersionUpdateOne) SetMinor(i int) *ModuleVersionUpdateOne {
	mvuo.minor = &i
	mvuo.addminor = nil
	return mvuo
}

// AddMinor adds i to minor.
func (mvuo *ModuleVersionUpdateOne) AddMinor(i int) *ModuleVersionUpdateOne {
	if mvuo.addminor == nil {
		mvuo.addminor = &i
	} else {
		*mvuo.addminor += i
	}
	return mvuo
}

// SetPatch sets the patch field.
func (mvuo *ModuleVersionUpdateOne) SetPatch(i int) *ModuleVersionUpdateOne {
	mvuo.patch = &i
	mvuo.addpatch = nil
	return mvuo
}

// AddPatch adds i to patch.
func (mvuo *ModuleVersionUpdateOne) AddPatch(i int) *ModuleVersionUpdateOne {
	if mvuo.addpatch == nil {
		mvuo.addpatch = &i
	} else {
		*mvuo.addpatch += i
	}
	return mvuo
}

// SetTag sets the tag field.
func (mvuo *ModuleVersionUpdateOne) SetTag(s string) *ModuleVersionUpdateOne {
	mvuo.tag = &s
	return mvuo
}

// SetModuleID sets the module edge to Module by id.
func (mvuo *ModuleVersionUpdateOne) SetModuleID(id int) *ModuleVersionUpdateOne {
	if mvuo.module == nil {
		mvuo.module = make(map[int]struct{})
	}
	mvuo.module[id] = struct{}{}
	return mvuo
}

// SetModule sets the module edge to Module.
func (mvuo *ModuleVersionUpdateOne) SetModule(m *Module) *ModuleVersionUpdateOne {
	return mvuo.SetModuleID(m.ID)
}

// ClearModule clears the module edge to Module.
func (mvuo *ModuleVersionUpdateOne) ClearModule() *ModuleVersionUpdateOne {
	mvuo.clearedModule = true
	return mvuo
}

// Save executes the query and returns the updated entity.
func (mvuo *ModuleVersionUpdateOne) Save(ctx context.Context) (*ModuleVersion, error) {
	if mvuo.major != nil {
		if err := moduleversion.MajorValidator(*mvuo.major); err != nil {
			return nil, fmt.Errorf("ent: validator failed for field \"major\": %v", err)
		}
	}
	if mvuo.minor != nil {
		if err := moduleversion.MinorValidator(*mvuo.minor); err != nil {
			return nil, fmt.Errorf("ent: validator failed for field \"minor\": %v", err)
		}
	}
	if mvuo.patch != nil {
		if err := moduleversion.PatchValidator(*mvuo.patch); err != nil {
			return nil, fmt.Errorf("ent: validator failed for field \"patch\": %v", err)
		}
	}
	if len(mvuo.module) > 1 {
		return nil, errors.New("ent: multiple assignments on a unique edge \"module\"")
	}
	if mvuo.clearedModule && mvuo.module == nil {
		return nil, errors.New("ent: clearing a unique edge \"module\"")
	}
	return mvuo.sqlSave(ctx)
}

// SaveX is like Save, but panics if an error occurs.
func (mvuo *ModuleVersionUpdateOne) SaveX(ctx context.Context) *ModuleVersion {
	mv, err := mvuo.Save(ctx)
	if err != nil {
		panic(err)
	}
	return mv
}

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

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

func (mvuo *ModuleVersionUpdateOne) sqlSave(ctx context.Context) (mv *ModuleVersion, err error) {
	selector := sql.Select(moduleversion.Columns...).From(sql.Table(moduleversion.Table))
	moduleversion.ID(mvuo.id)(selector)
	rows := &sql.Rows{}
	query, args := selector.Query()
	if err = mvuo.driver.Query(ctx, query, args, rows); err != nil {
		return nil, err
	}
	defer rows.Close()
	var ids []int
	for rows.Next() {
		var id int
		mv = &ModuleVersion{config: mvuo.config}
		if err := mv.FromRows(rows); err != nil {
			return nil, fmt.Errorf("ent: failed scanning row into ModuleVersion: %v", err)
		}
		id = mv.ID
		ids = append(ids, id)
	}
	switch n := len(ids); {
	case n == 0:
		return nil, &ErrNotFound{fmt.Sprintf("ModuleVersion with id: %v", mvuo.id)}
	case n > 1:
		return nil, fmt.Errorf("ent: more than one ModuleVersion with the same id: %v", mvuo.id)
	}

	tx, err := mvuo.driver.Tx(ctx)
	if err != nil {
		return nil, err
	}
	var (
		res     sql.Result
		builder = sql.Update(moduleversion.Table).Where(sql.InInts(moduleversion.FieldID, ids...))
	)
	if value := mvuo.major; value != nil {
		builder.Set(moduleversion.FieldMajor, *value)
		mv.Major = *value
	}
	if value := mvuo.addmajor; value != nil {
		builder.Add(moduleversion.FieldMajor, *value)
		mv.Major += *value
	}
	if value := mvuo.minor; value != nil {
		builder.Set(moduleversion.FieldMinor, *value)
		mv.Minor = *value
	}
	if value := mvuo.addminor; value != nil {
		builder.Add(moduleversion.FieldMinor, *value)
		mv.Minor += *value
	}
	if value := mvuo.patch; value != nil {
		builder.Set(moduleversion.FieldPatch, *value)
		mv.Patch = *value
	}
	if value := mvuo.addpatch; value != nil {
		builder.Add(moduleversion.FieldPatch, *value)
		mv.Patch += *value
	}
	if value := mvuo.tag; value != nil {
		builder.Set(moduleversion.FieldTag, *value)
		mv.Tag = *value
	}
	if !builder.Empty() {
		query, args := builder.Query()
		if err := tx.Exec(ctx, query, args, &res); err != nil {
			return nil, rollback(tx, err)
		}
	}
	if mvuo.clearedModule {
		query, args := sql.Update(moduleversion.ModuleTable).
			SetNull(moduleversion.ModuleColumn).
			Where(sql.InInts(module.FieldID, ids...)).
			Query()
		if err := tx.Exec(ctx, query, args, &res); err != nil {
			return nil, rollback(tx, err)
		}
	}
	if len(mvuo.module) > 0 {
		for eid := range mvuo.module {
			query, args := sql.Update(moduleversion.ModuleTable).
				Set(moduleversion.ModuleColumn, eid).
				Where(sql.InInts(moduleversion.FieldID, ids...)).
				Query()
			if err := tx.Exec(ctx, query, args, &res); err != nil {
				return nil, rollback(tx, err)
			}
		}
	}
	if err = tx.Commit(); err != nil {
		return nil, err
	}
	return mv, nil
}