fieldtype_update.go

// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.

// Code generated by entc, DO NOT EDIT.

package ent

import (
	"context"
	"fmt"

	"github.com/facebookincubator/ent/dialect/sql"
	"github.com/facebookincubator/ent/dialect/sql/sqlgraph"
	"github.com/facebookincubator/ent/entc/integration/ent/fieldtype"
	"github.com/facebookincubator/ent/entc/integration/ent/predicate"
	"github.com/facebookincubator/ent/schema/field"
)

// FieldTypeUpdate is the builder for updating FieldType entities.
type FieldTypeUpdate struct {
	config
	int                          *int
	addint                       *int
	int8                         *int8
	addint8                      *int8
	int16                        *int16
	addint16                     *int16
	int32                        *int32
	addint32                     *int32
	int64                        *int64
	addint64                     *int64
	optional_int                 *int
	addoptional_int              *int
	clearoptional_int            bool
	optional_int8                *int8
	addoptional_int8             *int8
	clearoptional_int8           bool
	optional_int16               *int16
	addoptional_int16            *int16
	clearoptional_int16          bool
	optional_int32               *int32
	addoptional_int32            *int32
	clearoptional_int32          bool
	optional_int64               *int64
	addoptional_int64            *int64
	clearoptional_int64          bool
	nillable_int                 *int
	addnillable_int              *int
	clearnillable_int            bool
	nillable_int8                *int8
	addnillable_int8             *int8
	clearnillable_int8           bool
	nillable_int16               *int16
	addnillable_int16            *int16
	clearnillable_int16          bool
	nillable_int32               *int32
	addnillable_int32            *int32
	clearnillable_int32          bool
	nillable_int64               *int64
	addnillable_int64            *int64
	clearnillable_int64          bool
	validate_optional_int32      *int32
	addvalidate_optional_int32   *int32
	clearvalidate_optional_int32 bool
	optional_uint                *uint
	addoptional_uint             *uint
	clearoptional_uint           bool
	optional_uint8               *uint8
	addoptional_uint8            *uint8
	clearoptional_uint8          bool
	optional_uint16              *uint16
	addoptional_uint16           *uint16
	clearoptional_uint16         bool
	optional_uint32              *uint32
	addoptional_uint32           *uint32
	clearoptional_uint32         bool
	optional_uint64              *uint64
	addoptional_uint64           *uint64
	clearoptional_uint64         bool
	state                        *fieldtype.State
	clearstate                   bool
	optional_float               *float64
	addoptional_float            *float64
	clearoptional_float          bool
	optional_float32             *float32
	addoptional_float32          *float32
	clearoptional_float32        bool
	predicates                   []predicate.FieldType
}

// Where adds a new predicate for the builder.
func (ftu *FieldTypeUpdate) Where(ps ...predicate.FieldType) *FieldTypeUpdate {
	ftu.predicates = append(ftu.predicates, ps...)
	return ftu
}

// SetInt sets the int field.
func (ftu *FieldTypeUpdate) SetInt(i int) *FieldTypeUpdate {
	ftu.int = &i
	ftu.addint = nil
	return ftu
}

// AddInt adds i to int.
func (ftu *FieldTypeUpdate) AddInt(i int) *FieldTypeUpdate {
	if ftu.addint == nil {
		ftu.addint = &i
	} else {
		*ftu.addint += i
	}
	return ftu
}

// SetInt8 sets the int8 field.
func (ftu *FieldTypeUpdate) SetInt8(i int8) *FieldTypeUpdate {
	ftu.int8 = &i
	ftu.addint8 = nil
	return ftu
}

// AddInt8 adds i to int8.
func (ftu *FieldTypeUpdate) AddInt8(i int8) *FieldTypeUpdate {
	if ftu.addint8 == nil {
		ftu.addint8 = &i
	} else {
		*ftu.addint8 += i
	}
	return ftu
}

// SetInt16 sets the int16 field.
func (ftu *FieldTypeUpdate) SetInt16(i int16) *FieldTypeUpdate {
	ftu.int16 = &i
	ftu.addint16 = nil
	return ftu
}

// AddInt16 adds i to int16.
func (ftu *FieldTypeUpdate) AddInt16(i int16) *FieldTypeUpdate {
	if ftu.addint16 == nil {
		ftu.addint16 = &i
	} else {
		*ftu.addint16 += i
	}
	return ftu
}

// SetInt32 sets the int32 field.
func (ftu *FieldTypeUpdate) SetInt32(i int32) *FieldTypeUpdate {
	ftu.int32 = &i
	ftu.addint32 = nil
	return ftu
}

// AddInt32 adds i to int32.
func (ftu *FieldTypeUpdate) AddInt32(i int32) *FieldTypeUpdate {
	if ftu.addint32 == nil {
		ftu.addint32 = &i
	} else {
		*ftu.addint32 += i
	}
	return ftu
}

// SetInt64 sets the int64 field.
func (ftu *FieldTypeUpdate) SetInt64(i int64) *FieldTypeUpdate {
	ftu.int64 = &i
	ftu.addint64 = nil
	return ftu
}

// AddInt64 adds i to int64.
func (ftu *FieldTypeUpdate) AddInt64(i int64) *FieldTypeUpdate {
	if ftu.addint64 == nil {
		ftu.addint64 = &i
	} else {
		*ftu.addint64 += i
	}
	return ftu
}

// SetOptionalInt sets the optional_int field.
func (ftu *FieldTypeUpdate) SetOptionalInt(i int) *FieldTypeUpdate {
	ftu.optional_int = &i
	ftu.addoptional_int = nil
	return ftu
}

// SetNillableOptionalInt sets the optional_int field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableOptionalInt(i *int) *FieldTypeUpdate {
	if i != nil {
		ftu.SetOptionalInt(*i)
	}
	return ftu
}

// AddOptionalInt adds i to optional_int.
func (ftu *FieldTypeUpdate) AddOptionalInt(i int) *FieldTypeUpdate {
	if ftu.addoptional_int == nil {
		ftu.addoptional_int = &i
	} else {
		*ftu.addoptional_int += i
	}
	return ftu
}

// ClearOptionalInt clears the value of optional_int.
func (ftu *FieldTypeUpdate) ClearOptionalInt() *FieldTypeUpdate {
	ftu.optional_int = nil
	ftu.clearoptional_int = true
	return ftu
}

// SetOptionalInt8 sets the optional_int8 field.
func (ftu *FieldTypeUpdate) SetOptionalInt8(i int8) *FieldTypeUpdate {
	ftu.optional_int8 = &i
	ftu.addoptional_int8 = nil
	return ftu
}

// SetNillableOptionalInt8 sets the optional_int8 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableOptionalInt8(i *int8) *FieldTypeUpdate {
	if i != nil {
		ftu.SetOptionalInt8(*i)
	}
	return ftu
}

// AddOptionalInt8 adds i to optional_int8.
func (ftu *FieldTypeUpdate) AddOptionalInt8(i int8) *FieldTypeUpdate {
	if ftu.addoptional_int8 == nil {
		ftu.addoptional_int8 = &i
	} else {
		*ftu.addoptional_int8 += i
	}
	return ftu
}

// ClearOptionalInt8 clears the value of optional_int8.
func (ftu *FieldTypeUpdate) ClearOptionalInt8() *FieldTypeUpdate {
	ftu.optional_int8 = nil
	ftu.clearoptional_int8 = true
	return ftu
}

// SetOptionalInt16 sets the optional_int16 field.
func (ftu *FieldTypeUpdate) SetOptionalInt16(i int16) *FieldTypeUpdate {
	ftu.optional_int16 = &i
	ftu.addoptional_int16 = nil
	return ftu
}

// SetNillableOptionalInt16 sets the optional_int16 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableOptionalInt16(i *int16) *FieldTypeUpdate {
	if i != nil {
		ftu.SetOptionalInt16(*i)
	}
	return ftu
}

// AddOptionalInt16 adds i to optional_int16.
func (ftu *FieldTypeUpdate) AddOptionalInt16(i int16) *FieldTypeUpdate {
	if ftu.addoptional_int16 == nil {
		ftu.addoptional_int16 = &i
	} else {
		*ftu.addoptional_int16 += i
	}
	return ftu
}

// ClearOptionalInt16 clears the value of optional_int16.
func (ftu *FieldTypeUpdate) ClearOptionalInt16() *FieldTypeUpdate {
	ftu.optional_int16 = nil
	ftu.clearoptional_int16 = true
	return ftu
}

// SetOptionalInt32 sets the optional_int32 field.
func (ftu *FieldTypeUpdate) SetOptionalInt32(i int32) *FieldTypeUpdate {
	ftu.optional_int32 = &i
	ftu.addoptional_int32 = nil
	return ftu
}

// SetNillableOptionalInt32 sets the optional_int32 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableOptionalInt32(i *int32) *FieldTypeUpdate {
	if i != nil {
		ftu.SetOptionalInt32(*i)
	}
	return ftu
}

// AddOptionalInt32 adds i to optional_int32.
func (ftu *FieldTypeUpdate) AddOptionalInt32(i int32) *FieldTypeUpdate {
	if ftu.addoptional_int32 == nil {
		ftu.addoptional_int32 = &i
	} else {
		*ftu.addoptional_int32 += i
	}
	return ftu
}

// ClearOptionalInt32 clears the value of optional_int32.
func (ftu *FieldTypeUpdate) ClearOptionalInt32() *FieldTypeUpdate {
	ftu.optional_int32 = nil
	ftu.clearoptional_int32 = true
	return ftu
}

// SetOptionalInt64 sets the optional_int64 field.
func (ftu *FieldTypeUpdate) SetOptionalInt64(i int64) *FieldTypeUpdate {
	ftu.optional_int64 = &i
	ftu.addoptional_int64 = nil
	return ftu
}

// SetNillableOptionalInt64 sets the optional_int64 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableOptionalInt64(i *int64) *FieldTypeUpdate {
	if i != nil {
		ftu.SetOptionalInt64(*i)
	}
	return ftu
}

// AddOptionalInt64 adds i to optional_int64.
func (ftu *FieldTypeUpdate) AddOptionalInt64(i int64) *FieldTypeUpdate {
	if ftu.addoptional_int64 == nil {
		ftu.addoptional_int64 = &i
	} else {
		*ftu.addoptional_int64 += i
	}
	return ftu
}

// ClearOptionalInt64 clears the value of optional_int64.
func (ftu *FieldTypeUpdate) ClearOptionalInt64() *FieldTypeUpdate {
	ftu.optional_int64 = nil
	ftu.clearoptional_int64 = true
	return ftu
}

// SetNillableInt sets the nillable_int field.
func (ftu *FieldTypeUpdate) SetNillableInt(i int) *FieldTypeUpdate {
	ftu.nillable_int = &i
	ftu.addnillable_int = nil
	return ftu
}

// SetNillableNillableInt sets the nillable_int field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableNillableInt(i *int) *FieldTypeUpdate {
	if i != nil {
		ftu.SetNillableInt(*i)
	}
	return ftu
}

// AddNillableInt adds i to nillable_int.
func (ftu *FieldTypeUpdate) AddNillableInt(i int) *FieldTypeUpdate {
	if ftu.addnillable_int == nil {
		ftu.addnillable_int = &i
	} else {
		*ftu.addnillable_int += i
	}
	return ftu
}

// ClearNillableInt clears the value of nillable_int.
func (ftu *FieldTypeUpdate) ClearNillableInt() *FieldTypeUpdate {
	ftu.nillable_int = nil
	ftu.clearnillable_int = true
	return ftu
}

// SetNillableInt8 sets the nillable_int8 field.
func (ftu *FieldTypeUpdate) SetNillableInt8(i int8) *FieldTypeUpdate {
	ftu.nillable_int8 = &i
	ftu.addnillable_int8 = nil
	return ftu
}

// SetNillableNillableInt8 sets the nillable_int8 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableNillableInt8(i *int8) *FieldTypeUpdate {
	if i != nil {
		ftu.SetNillableInt8(*i)
	}
	return ftu
}

// AddNillableInt8 adds i to nillable_int8.
func (ftu *FieldTypeUpdate) AddNillableInt8(i int8) *FieldTypeUpdate {
	if ftu.addnillable_int8 == nil {
		ftu.addnillable_int8 = &i
	} else {
		*ftu.addnillable_int8 += i
	}
	return ftu
}

// ClearNillableInt8 clears the value of nillable_int8.
func (ftu *FieldTypeUpdate) ClearNillableInt8() *FieldTypeUpdate {
	ftu.nillable_int8 = nil
	ftu.clearnillable_int8 = true
	return ftu
}

// SetNillableInt16 sets the nillable_int16 field.
func (ftu *FieldTypeUpdate) SetNillableInt16(i int16) *FieldTypeUpdate {
	ftu.nillable_int16 = &i
	ftu.addnillable_int16 = nil
	return ftu
}

// SetNillableNillableInt16 sets the nillable_int16 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableNillableInt16(i *int16) *FieldTypeUpdate {
	if i != nil {
		ftu.SetNillableInt16(*i)
	}
	return ftu
}

// AddNillableInt16 adds i to nillable_int16.
func (ftu *FieldTypeUpdate) AddNillableInt16(i int16) *FieldTypeUpdate {
	if ftu.addnillable_int16 == nil {
		ftu.addnillable_int16 = &i
	} else {
		*ftu.addnillable_int16 += i
	}
	return ftu
}

// ClearNillableInt16 clears the value of nillable_int16.
func (ftu *FieldTypeUpdate) ClearNillableInt16() *FieldTypeUpdate {
	ftu.nillable_int16 = nil
	ftu.clearnillable_int16 = true
	return ftu
}

// SetNillableInt32 sets the nillable_int32 field.
func (ftu *FieldTypeUpdate) SetNillableInt32(i int32) *FieldTypeUpdate {
	ftu.nillable_int32 = &i
	ftu.addnillable_int32 = nil
	return ftu
}

// SetNillableNillableInt32 sets the nillable_int32 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableNillableInt32(i *int32) *FieldTypeUpdate {
	if i != nil {
		ftu.SetNillableInt32(*i)
	}
	return ftu
}

// AddNillableInt32 adds i to nillable_int32.
func (ftu *FieldTypeUpdate) AddNillableInt32(i int32) *FieldTypeUpdate {
	if ftu.addnillable_int32 == nil {
		ftu.addnillable_int32 = &i
	} else {
		*ftu.addnillable_int32 += i
	}
	return ftu
}

// ClearNillableInt32 clears the value of nillable_int32.
func (ftu *FieldTypeUpdate) ClearNillableInt32() *FieldTypeUpdate {
	ftu.nillable_int32 = nil
	ftu.clearnillable_int32 = true
	return ftu
}

// SetNillableInt64 sets the nillable_int64 field.
func (ftu *FieldTypeUpdate) SetNillableInt64(i int64) *FieldTypeUpdate {
	ftu.nillable_int64 = &i
	ftu.addnillable_int64 = nil
	return ftu
}

// SetNillableNillableInt64 sets the nillable_int64 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableNillableInt64(i *int64) *FieldTypeUpdate {
	if i != nil {
		ftu.SetNillableInt64(*i)
	}
	return ftu
}

// AddNillableInt64 adds i to nillable_int64.
func (ftu *FieldTypeUpdate) AddNillableInt64(i int64) *FieldTypeUpdate {
	if ftu.addnillable_int64 == nil {
		ftu.addnillable_int64 = &i
	} else {
		*ftu.addnillable_int64 += i
	}
	return ftu
}

// ClearNillableInt64 clears the value of nillable_int64.
func (ftu *FieldTypeUpdate) ClearNillableInt64() *FieldTypeUpdate {
	ftu.nillable_int64 = nil
	ftu.clearnillable_int64 = true
	return ftu
}

// SetValidateOptionalInt32 sets the validate_optional_int32 field.
func (ftu *FieldTypeUpdate) SetValidateOptionalInt32(i int32) *FieldTypeUpdate {
	ftu.validate_optional_int32 = &i
	ftu.addvalidate_optional_int32 = nil
	return ftu
}

// SetNillableValidateOptionalInt32 sets the validate_optional_int32 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableValidateOptionalInt32(i *int32) *FieldTypeUpdate {
	if i != nil {
		ftu.SetValidateOptionalInt32(*i)
	}
	return ftu
}

// AddValidateOptionalInt32 adds i to validate_optional_int32.
func (ftu *FieldTypeUpdate) AddValidateOptionalInt32(i int32) *FieldTypeUpdate {
	if ftu.addvalidate_optional_int32 == nil {
		ftu.addvalidate_optional_int32 = &i
	} else {
		*ftu.addvalidate_optional_int32 += i
	}
	return ftu
}

// ClearValidateOptionalInt32 clears the value of validate_optional_int32.
func (ftu *FieldTypeUpdate) ClearValidateOptionalInt32() *FieldTypeUpdate {
	ftu.validate_optional_int32 = nil
	ftu.clearvalidate_optional_int32 = true
	return ftu
}

// SetOptionalUint sets the optional_uint field.
func (ftu *FieldTypeUpdate) SetOptionalUint(u uint) *FieldTypeUpdate {
	ftu.optional_uint = &u
	ftu.addoptional_uint = nil
	return ftu
}

// SetNillableOptionalUint sets the optional_uint field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableOptionalUint(u *uint) *FieldTypeUpdate {
	if u != nil {
		ftu.SetOptionalUint(*u)
	}
	return ftu
}

// AddOptionalUint adds u to optional_uint.
func (ftu *FieldTypeUpdate) AddOptionalUint(u uint) *FieldTypeUpdate {
	if ftu.addoptional_uint == nil {
		ftu.addoptional_uint = &u
	} else {
		*ftu.addoptional_uint += u
	}
	return ftu
}

// ClearOptionalUint clears the value of optional_uint.
func (ftu *FieldTypeUpdate) ClearOptionalUint() *FieldTypeUpdate {
	ftu.optional_uint = nil
	ftu.clearoptional_uint = true
	return ftu
}

// SetOptionalUint8 sets the optional_uint8 field.
func (ftu *FieldTypeUpdate) SetOptionalUint8(u uint8) *FieldTypeUpdate {
	ftu.optional_uint8 = &u
	ftu.addoptional_uint8 = nil
	return ftu
}

// SetNillableOptionalUint8 sets the optional_uint8 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableOptionalUint8(u *uint8) *FieldTypeUpdate {
	if u != nil {
		ftu.SetOptionalUint8(*u)
	}
	return ftu
}

// AddOptionalUint8 adds u to optional_uint8.
func (ftu *FieldTypeUpdate) AddOptionalUint8(u uint8) *FieldTypeUpdate {
	if ftu.addoptional_uint8 == nil {
		ftu.addoptional_uint8 = &u
	} else {
		*ftu.addoptional_uint8 += u
	}
	return ftu
}

// ClearOptionalUint8 clears the value of optional_uint8.
func (ftu *FieldTypeUpdate) ClearOptionalUint8() *FieldTypeUpdate {
	ftu.optional_uint8 = nil
	ftu.clearoptional_uint8 = true
	return ftu
}

// SetOptionalUint16 sets the optional_uint16 field.
func (ftu *FieldTypeUpdate) SetOptionalUint16(u uint16) *FieldTypeUpdate {
	ftu.optional_uint16 = &u
	ftu.addoptional_uint16 = nil
	return ftu
}

// SetNillableOptionalUint16 sets the optional_uint16 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableOptionalUint16(u *uint16) *FieldTypeUpdate {
	if u != nil {
		ftu.SetOptionalUint16(*u)
	}
	return ftu
}

// AddOptionalUint16 adds u to optional_uint16.
func (ftu *FieldTypeUpdate) AddOptionalUint16(u uint16) *FieldTypeUpdate {
	if ftu.addoptional_uint16 == nil {
		ftu.addoptional_uint16 = &u
	} else {
		*ftu.addoptional_uint16 += u
	}
	return ftu
}

// ClearOptionalUint16 clears the value of optional_uint16.
func (ftu *FieldTypeUpdate) ClearOptionalUint16() *FieldTypeUpdate {
	ftu.optional_uint16 = nil
	ftu.clearoptional_uint16 = true
	return ftu
}

// SetOptionalUint32 sets the optional_uint32 field.
func (ftu *FieldTypeUpdate) SetOptionalUint32(u uint32) *FieldTypeUpdate {
	ftu.optional_uint32 = &u
	ftu.addoptional_uint32 = nil
	return ftu
}

// SetNillableOptionalUint32 sets the optional_uint32 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableOptionalUint32(u *uint32) *FieldTypeUpdate {
	if u != nil {
		ftu.SetOptionalUint32(*u)
	}
	return ftu
}

// AddOptionalUint32 adds u to optional_uint32.
func (ftu *FieldTypeUpdate) AddOptionalUint32(u uint32) *FieldTypeUpdate {
	if ftu.addoptional_uint32 == nil {
		ftu.addoptional_uint32 = &u
	} else {
		*ftu.addoptional_uint32 += u
	}
	return ftu
}

// ClearOptionalUint32 clears the value of optional_uint32.
func (ftu *FieldTypeUpdate) ClearOptionalUint32() *FieldTypeUpdate {
	ftu.optional_uint32 = nil
	ftu.clearoptional_uint32 = true
	return ftu
}

// SetOptionalUint64 sets the optional_uint64 field.
func (ftu *FieldTypeUpdate) SetOptionalUint64(u uint64) *FieldTypeUpdate {
	ftu.optional_uint64 = &u
	ftu.addoptional_uint64 = nil
	return ftu
}

// SetNillableOptionalUint64 sets the optional_uint64 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableOptionalUint64(u *uint64) *FieldTypeUpdate {
	if u != nil {
		ftu.SetOptionalUint64(*u)
	}
	return ftu
}

// AddOptionalUint64 adds u to optional_uint64.
func (ftu *FieldTypeUpdate) AddOptionalUint64(u uint64) *FieldTypeUpdate {
	if ftu.addoptional_uint64 == nil {
		ftu.addoptional_uint64 = &u
	} else {
		*ftu.addoptional_uint64 += u
	}
	return ftu
}

// ClearOptionalUint64 clears the value of optional_uint64.
func (ftu *FieldTypeUpdate) ClearOptionalUint64() *FieldTypeUpdate {
	ftu.optional_uint64 = nil
	ftu.clearoptional_uint64 = true
	return ftu
}

// SetState sets the state field.
func (ftu *FieldTypeUpdate) SetState(f fieldtype.State) *FieldTypeUpdate {
	ftu.state = &f
	return ftu
}

// SetNillableState sets the state field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableState(f *fieldtype.State) *FieldTypeUpdate {
	if f != nil {
		ftu.SetState(*f)
	}
	return ftu
}

// ClearState clears the value of state.
func (ftu *FieldTypeUpdate) ClearState() *FieldTypeUpdate {
	ftu.state = nil
	ftu.clearstate = true
	return ftu
}

// SetOptionalFloat sets the optional_float field.
func (ftu *FieldTypeUpdate) SetOptionalFloat(f float64) *FieldTypeUpdate {
	ftu.optional_float = &f
	ftu.addoptional_float = nil
	return ftu
}

// SetNillableOptionalFloat sets the optional_float field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableOptionalFloat(f *float64) *FieldTypeUpdate {
	if f != nil {
		ftu.SetOptionalFloat(*f)
	}
	return ftu
}

// AddOptionalFloat adds f to optional_float.
func (ftu *FieldTypeUpdate) AddOptionalFloat(f float64) *FieldTypeUpdate {
	if ftu.addoptional_float == nil {
		ftu.addoptional_float = &f
	} else {
		*ftu.addoptional_float += f
	}
	return ftu
}

// ClearOptionalFloat clears the value of optional_float.
func (ftu *FieldTypeUpdate) ClearOptionalFloat() *FieldTypeUpdate {
	ftu.optional_float = nil
	ftu.clearoptional_float = true
	return ftu
}

// SetOptionalFloat32 sets the optional_float32 field.
func (ftu *FieldTypeUpdate) SetOptionalFloat32(f float32) *FieldTypeUpdate {
	ftu.optional_float32 = &f
	ftu.addoptional_float32 = nil
	return ftu
}

// SetNillableOptionalFloat32 sets the optional_float32 field if the given value is not nil.
func (ftu *FieldTypeUpdate) SetNillableOptionalFloat32(f *float32) *FieldTypeUpdate {
	if f != nil {
		ftu.SetOptionalFloat32(*f)
	}
	return ftu
}

// AddOptionalFloat32 adds f to optional_float32.
func (ftu *FieldTypeUpdate) AddOptionalFloat32(f float32) *FieldTypeUpdate {
	if ftu.addoptional_float32 == nil {
		ftu.addoptional_float32 = &f
	} else {
		*ftu.addoptional_float32 += f
	}
	return ftu
}

// ClearOptionalFloat32 clears the value of optional_float32.
func (ftu *FieldTypeUpdate) ClearOptionalFloat32() *FieldTypeUpdate {
	ftu.optional_float32 = nil
	ftu.clearoptional_float32 = true
	return ftu
}

// Save executes the query and returns the number of rows/vertices matched by this operation.
func (ftu *FieldTypeUpdate) Save(ctx context.Context) (int, error) {
	if ftu.validate_optional_int32 != nil {
		if err := fieldtype.ValidateOptionalInt32Validator(*ftu.validate_optional_int32); err != nil {
			return 0, fmt.Errorf("ent: validator failed for field \"validate_optional_int32\": %v", err)
		}
	}
	if ftu.state != nil {
		if err := fieldtype.StateValidator(*ftu.state); err != nil {
			return 0, fmt.Errorf("ent: validator failed for field \"state\": %v", err)
		}
	}
	return ftu.sqlSave(ctx)
}

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

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

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

func (ftu *FieldTypeUpdate) sqlSave(ctx context.Context) (n int, err error) {
	_spec := &sqlgraph.UpdateSpec{
		Node: &sqlgraph.NodeSpec{
			Table:   fieldtype.Table,
			Columns: fieldtype.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: fieldtype.FieldID,
			},
		},
	}
	if ps := ftu.predicates; len(ps) > 0 {
		_spec.Predicate = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	if value := ftu.int; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  *value,
			Column: fieldtype.FieldInt,
		})
	}
	if value := ftu.addint; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  *value,
			Column: fieldtype.FieldInt,
		})
	}
	if value := ftu.int8; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  *value,
			Column: fieldtype.FieldInt8,
		})
	}
	if value := ftu.addint8; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  *value,
			Column: fieldtype.FieldInt8,
		})
	}
	if value := ftu.int16; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Value:  *value,
			Column: fieldtype.FieldInt16,
		})
	}
	if value := ftu.addint16; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Value:  *value,
			Column: fieldtype.FieldInt16,
		})
	}
	if value := ftu.int32; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldInt32,
		})
	}
	if value := ftu.addint32; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldInt32,
		})
	}
	if value := ftu.int64; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  *value,
			Column: fieldtype.FieldInt64,
		})
	}
	if value := ftu.addint64; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  *value,
			Column: fieldtype.FieldInt64,
		})
	}
	if value := ftu.optional_int; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt,
		})
	}
	if value := ftu.addoptional_int; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt,
		})
	}
	if ftu.clearoptional_int {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Column: fieldtype.FieldOptionalInt,
		})
	}
	if value := ftu.optional_int8; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt8,
		})
	}
	if value := ftu.addoptional_int8; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt8,
		})
	}
	if ftu.clearoptional_int8 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Column: fieldtype.FieldOptionalInt8,
		})
	}
	if value := ftu.optional_int16; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt16,
		})
	}
	if value := ftu.addoptional_int16; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt16,
		})
	}
	if ftu.clearoptional_int16 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Column: fieldtype.FieldOptionalInt16,
		})
	}
	if value := ftu.optional_int32; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt32,
		})
	}
	if value := ftu.addoptional_int32; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt32,
		})
	}
	if ftu.clearoptional_int32 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Column: fieldtype.FieldOptionalInt32,
		})
	}
	if value := ftu.optional_int64; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt64,
		})
	}
	if value := ftu.addoptional_int64; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt64,
		})
	}
	if ftu.clearoptional_int64 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Column: fieldtype.FieldOptionalInt64,
		})
	}
	if value := ftu.nillable_int; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  *value,
			Column: fieldtype.FieldNillableInt,
		})
	}
	if value := ftu.addnillable_int; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  *value,
			Column: fieldtype.FieldNillableInt,
		})
	}
	if ftu.clearnillable_int {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Column: fieldtype.FieldNillableInt,
		})
	}
	if value := ftu.nillable_int8; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  *value,
			Column: fieldtype.FieldNillableInt8,
		})
	}
	if value := ftu.addnillable_int8; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  *value,
			Column: fieldtype.FieldNillableInt8,
		})
	}
	if ftu.clearnillable_int8 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Column: fieldtype.FieldNillableInt8,
		})
	}
	if value := ftu.nillable_int16; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Value:  *value,
			Column: fieldtype.FieldNillableInt16,
		})
	}
	if value := ftu.addnillable_int16; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Value:  *value,
			Column: fieldtype.FieldNillableInt16,
		})
	}
	if ftu.clearnillable_int16 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Column: fieldtype.FieldNillableInt16,
		})
	}
	if value := ftu.nillable_int32; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldNillableInt32,
		})
	}
	if value := ftu.addnillable_int32; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldNillableInt32,
		})
	}
	if ftu.clearnillable_int32 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Column: fieldtype.FieldNillableInt32,
		})
	}
	if value := ftu.nillable_int64; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  *value,
			Column: fieldtype.FieldNillableInt64,
		})
	}
	if value := ftu.addnillable_int64; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  *value,
			Column: fieldtype.FieldNillableInt64,
		})
	}
	if ftu.clearnillable_int64 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Column: fieldtype.FieldNillableInt64,
		})
	}
	if value := ftu.validate_optional_int32; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldValidateOptionalInt32,
		})
	}
	if value := ftu.addvalidate_optional_int32; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldValidateOptionalInt32,
		})
	}
	if ftu.clearvalidate_optional_int32 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Column: fieldtype.FieldValidateOptionalInt32,
		})
	}
	if value := ftu.optional_uint; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUint,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint,
		})
	}
	if value := ftu.addoptional_uint; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeUint,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint,
		})
	}
	if ftu.clearoptional_uint {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeUint,
			Column: fieldtype.FieldOptionalUint,
		})
	}
	if value := ftu.optional_uint8; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUint8,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint8,
		})
	}
	if value := ftu.addoptional_uint8; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeUint8,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint8,
		})
	}
	if ftu.clearoptional_uint8 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeUint8,
			Column: fieldtype.FieldOptionalUint8,
		})
	}
	if value := ftu.optional_uint16; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUint16,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint16,
		})
	}
	if value := ftu.addoptional_uint16; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeUint16,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint16,
		})
	}
	if ftu.clearoptional_uint16 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeUint16,
			Column: fieldtype.FieldOptionalUint16,
		})
	}
	if value := ftu.optional_uint32; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUint32,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint32,
		})
	}
	if value := ftu.addoptional_uint32; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeUint32,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint32,
		})
	}
	if ftu.clearoptional_uint32 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeUint32,
			Column: fieldtype.FieldOptionalUint32,
		})
	}
	if value := ftu.optional_uint64; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUint64,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint64,
		})
	}
	if value := ftu.addoptional_uint64; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeUint64,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint64,
		})
	}
	if ftu.clearoptional_uint64 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeUint64,
			Column: fieldtype.FieldOptionalUint64,
		})
	}
	if value := ftu.state; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeEnum,
			Value:  *value,
			Column: fieldtype.FieldState,
		})
	}
	if ftu.clearstate {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeEnum,
			Column: fieldtype.FieldState,
		})
	}
	if value := ftu.optional_float; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeFloat64,
			Value:  *value,
			Column: fieldtype.FieldOptionalFloat,
		})
	}
	if value := ftu.addoptional_float; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeFloat64,
			Value:  *value,
			Column: fieldtype.FieldOptionalFloat,
		})
	}
	if ftu.clearoptional_float {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeFloat64,
			Column: fieldtype.FieldOptionalFloat,
		})
	}
	if value := ftu.optional_float32; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeFloat32,
			Value:  *value,
			Column: fieldtype.FieldOptionalFloat32,
		})
	}
	if value := ftu.addoptional_float32; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeFloat32,
			Value:  *value,
			Column: fieldtype.FieldOptionalFloat32,
		})
	}
	if ftu.clearoptional_float32 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeFloat32,
			Column: fieldtype.FieldOptionalFloat32,
		})
	}
	if n, err = sqlgraph.UpdateNodes(ctx, ftu.driver, _spec); err != nil {
		if _, ok := err.(*sqlgraph.NotFoundError); ok {
			err = &NotFoundError{fieldtype.Label}
		} else if cerr, ok := isSQLConstraintError(err); ok {
			err = cerr
		}
		return 0, err
	}
	return n, nil
}

// FieldTypeUpdateOne is the builder for updating a single FieldType entity.
type FieldTypeUpdateOne struct {
	config
	id                           string
	int                          *int
	addint                       *int
	int8                         *int8
	addint8                      *int8
	int16                        *int16
	addint16                     *int16
	int32                        *int32
	addint32                     *int32
	int64                        *int64
	addint64                     *int64
	optional_int                 *int
	addoptional_int              *int
	clearoptional_int            bool
	optional_int8                *int8
	addoptional_int8             *int8
	clearoptional_int8           bool
	optional_int16               *int16
	addoptional_int16            *int16
	clearoptional_int16          bool
	optional_int32               *int32
	addoptional_int32            *int32
	clearoptional_int32          bool
	optional_int64               *int64
	addoptional_int64            *int64
	clearoptional_int64          bool
	nillable_int                 *int
	addnillable_int              *int
	clearnillable_int            bool
	nillable_int8                *int8
	addnillable_int8             *int8
	clearnillable_int8           bool
	nillable_int16               *int16
	addnillable_int16            *int16
	clearnillable_int16          bool
	nillable_int32               *int32
	addnillable_int32            *int32
	clearnillable_int32          bool
	nillable_int64               *int64
	addnillable_int64            *int64
	clearnillable_int64          bool
	validate_optional_int32      *int32
	addvalidate_optional_int32   *int32
	clearvalidate_optional_int32 bool
	optional_uint                *uint
	addoptional_uint             *uint
	clearoptional_uint           bool
	optional_uint8               *uint8
	addoptional_uint8            *uint8
	clearoptional_uint8          bool
	optional_uint16              *uint16
	addoptional_uint16           *uint16
	clearoptional_uint16         bool
	optional_uint32              *uint32
	addoptional_uint32           *uint32
	clearoptional_uint32         bool
	optional_uint64              *uint64
	addoptional_uint64           *uint64
	clearoptional_uint64         bool
	state                        *fieldtype.State
	clearstate                   bool
	optional_float               *float64
	addoptional_float            *float64
	clearoptional_float          bool
	optional_float32             *float32
	addoptional_float32          *float32
	clearoptional_float32        bool
}

// SetInt sets the int field.
func (ftuo *FieldTypeUpdateOne) SetInt(i int) *FieldTypeUpdateOne {
	ftuo.int = &i
	ftuo.addint = nil
	return ftuo
}

// AddInt adds i to int.
func (ftuo *FieldTypeUpdateOne) AddInt(i int) *FieldTypeUpdateOne {
	if ftuo.addint == nil {
		ftuo.addint = &i
	} else {
		*ftuo.addint += i
	}
	return ftuo
}

// SetInt8 sets the int8 field.
func (ftuo *FieldTypeUpdateOne) SetInt8(i int8) *FieldTypeUpdateOne {
	ftuo.int8 = &i
	ftuo.addint8 = nil
	return ftuo
}

// AddInt8 adds i to int8.
func (ftuo *FieldTypeUpdateOne) AddInt8(i int8) *FieldTypeUpdateOne {
	if ftuo.addint8 == nil {
		ftuo.addint8 = &i
	} else {
		*ftuo.addint8 += i
	}
	return ftuo
}

// SetInt16 sets the int16 field.
func (ftuo *FieldTypeUpdateOne) SetInt16(i int16) *FieldTypeUpdateOne {
	ftuo.int16 = &i
	ftuo.addint16 = nil
	return ftuo
}

// AddInt16 adds i to int16.
func (ftuo *FieldTypeUpdateOne) AddInt16(i int16) *FieldTypeUpdateOne {
	if ftuo.addint16 == nil {
		ftuo.addint16 = &i
	} else {
		*ftuo.addint16 += i
	}
	return ftuo
}

// SetInt32 sets the int32 field.
func (ftuo *FieldTypeUpdateOne) SetInt32(i int32) *FieldTypeUpdateOne {
	ftuo.int32 = &i
	ftuo.addint32 = nil
	return ftuo
}

// AddInt32 adds i to int32.
func (ftuo *FieldTypeUpdateOne) AddInt32(i int32) *FieldTypeUpdateOne {
	if ftuo.addint32 == nil {
		ftuo.addint32 = &i
	} else {
		*ftuo.addint32 += i
	}
	return ftuo
}

// SetInt64 sets the int64 field.
func (ftuo *FieldTypeUpdateOne) SetInt64(i int64) *FieldTypeUpdateOne {
	ftuo.int64 = &i
	ftuo.addint64 = nil
	return ftuo
}

// AddInt64 adds i to int64.
func (ftuo *FieldTypeUpdateOne) AddInt64(i int64) *FieldTypeUpdateOne {
	if ftuo.addint64 == nil {
		ftuo.addint64 = &i
	} else {
		*ftuo.addint64 += i
	}
	return ftuo
}

// SetOptionalInt sets the optional_int field.
func (ftuo *FieldTypeUpdateOne) SetOptionalInt(i int) *FieldTypeUpdateOne {
	ftuo.optional_int = &i
	ftuo.addoptional_int = nil
	return ftuo
}

// SetNillableOptionalInt sets the optional_int field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableOptionalInt(i *int) *FieldTypeUpdateOne {
	if i != nil {
		ftuo.SetOptionalInt(*i)
	}
	return ftuo
}

// AddOptionalInt adds i to optional_int.
func (ftuo *FieldTypeUpdateOne) AddOptionalInt(i int) *FieldTypeUpdateOne {
	if ftuo.addoptional_int == nil {
		ftuo.addoptional_int = &i
	} else {
		*ftuo.addoptional_int += i
	}
	return ftuo
}

// ClearOptionalInt clears the value of optional_int.
func (ftuo *FieldTypeUpdateOne) ClearOptionalInt() *FieldTypeUpdateOne {
	ftuo.optional_int = nil
	ftuo.clearoptional_int = true
	return ftuo
}

// SetOptionalInt8 sets the optional_int8 field.
func (ftuo *FieldTypeUpdateOne) SetOptionalInt8(i int8) *FieldTypeUpdateOne {
	ftuo.optional_int8 = &i
	ftuo.addoptional_int8 = nil
	return ftuo
}

// SetNillableOptionalInt8 sets the optional_int8 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableOptionalInt8(i *int8) *FieldTypeUpdateOne {
	if i != nil {
		ftuo.SetOptionalInt8(*i)
	}
	return ftuo
}

// AddOptionalInt8 adds i to optional_int8.
func (ftuo *FieldTypeUpdateOne) AddOptionalInt8(i int8) *FieldTypeUpdateOne {
	if ftuo.addoptional_int8 == nil {
		ftuo.addoptional_int8 = &i
	} else {
		*ftuo.addoptional_int8 += i
	}
	return ftuo
}

// ClearOptionalInt8 clears the value of optional_int8.
func (ftuo *FieldTypeUpdateOne) ClearOptionalInt8() *FieldTypeUpdateOne {
	ftuo.optional_int8 = nil
	ftuo.clearoptional_int8 = true
	return ftuo
}

// SetOptionalInt16 sets the optional_int16 field.
func (ftuo *FieldTypeUpdateOne) SetOptionalInt16(i int16) *FieldTypeUpdateOne {
	ftuo.optional_int16 = &i
	ftuo.addoptional_int16 = nil
	return ftuo
}

// SetNillableOptionalInt16 sets the optional_int16 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableOptionalInt16(i *int16) *FieldTypeUpdateOne {
	if i != nil {
		ftuo.SetOptionalInt16(*i)
	}
	return ftuo
}

// AddOptionalInt16 adds i to optional_int16.
func (ftuo *FieldTypeUpdateOne) AddOptionalInt16(i int16) *FieldTypeUpdateOne {
	if ftuo.addoptional_int16 == nil {
		ftuo.addoptional_int16 = &i
	} else {
		*ftuo.addoptional_int16 += i
	}
	return ftuo
}

// ClearOptionalInt16 clears the value of optional_int16.
func (ftuo *FieldTypeUpdateOne) ClearOptionalInt16() *FieldTypeUpdateOne {
	ftuo.optional_int16 = nil
	ftuo.clearoptional_int16 = true
	return ftuo
}

// SetOptionalInt32 sets the optional_int32 field.
func (ftuo *FieldTypeUpdateOne) SetOptionalInt32(i int32) *FieldTypeUpdateOne {
	ftuo.optional_int32 = &i
	ftuo.addoptional_int32 = nil
	return ftuo
}

// SetNillableOptionalInt32 sets the optional_int32 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableOptionalInt32(i *int32) *FieldTypeUpdateOne {
	if i != nil {
		ftuo.SetOptionalInt32(*i)
	}
	return ftuo
}

// AddOptionalInt32 adds i to optional_int32.
func (ftuo *FieldTypeUpdateOne) AddOptionalInt32(i int32) *FieldTypeUpdateOne {
	if ftuo.addoptional_int32 == nil {
		ftuo.addoptional_int32 = &i
	} else {
		*ftuo.addoptional_int32 += i
	}
	return ftuo
}

// ClearOptionalInt32 clears the value of optional_int32.
func (ftuo *FieldTypeUpdateOne) ClearOptionalInt32() *FieldTypeUpdateOne {
	ftuo.optional_int32 = nil
	ftuo.clearoptional_int32 = true
	return ftuo
}

// SetOptionalInt64 sets the optional_int64 field.
func (ftuo *FieldTypeUpdateOne) SetOptionalInt64(i int64) *FieldTypeUpdateOne {
	ftuo.optional_int64 = &i
	ftuo.addoptional_int64 = nil
	return ftuo
}

// SetNillableOptionalInt64 sets the optional_int64 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableOptionalInt64(i *int64) *FieldTypeUpdateOne {
	if i != nil {
		ftuo.SetOptionalInt64(*i)
	}
	return ftuo
}

// AddOptionalInt64 adds i to optional_int64.
func (ftuo *FieldTypeUpdateOne) AddOptionalInt64(i int64) *FieldTypeUpdateOne {
	if ftuo.addoptional_int64 == nil {
		ftuo.addoptional_int64 = &i
	} else {
		*ftuo.addoptional_int64 += i
	}
	return ftuo
}

// ClearOptionalInt64 clears the value of optional_int64.
func (ftuo *FieldTypeUpdateOne) ClearOptionalInt64() *FieldTypeUpdateOne {
	ftuo.optional_int64 = nil
	ftuo.clearoptional_int64 = true
	return ftuo
}

// SetNillableInt sets the nillable_int field.
func (ftuo *FieldTypeUpdateOne) SetNillableInt(i int) *FieldTypeUpdateOne {
	ftuo.nillable_int = &i
	ftuo.addnillable_int = nil
	return ftuo
}

// SetNillableNillableInt sets the nillable_int field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableNillableInt(i *int) *FieldTypeUpdateOne {
	if i != nil {
		ftuo.SetNillableInt(*i)
	}
	return ftuo
}

// AddNillableInt adds i to nillable_int.
func (ftuo *FieldTypeUpdateOne) AddNillableInt(i int) *FieldTypeUpdateOne {
	if ftuo.addnillable_int == nil {
		ftuo.addnillable_int = &i
	} else {
		*ftuo.addnillable_int += i
	}
	return ftuo
}

// ClearNillableInt clears the value of nillable_int.
func (ftuo *FieldTypeUpdateOne) ClearNillableInt() *FieldTypeUpdateOne {
	ftuo.nillable_int = nil
	ftuo.clearnillable_int = true
	return ftuo
}

// SetNillableInt8 sets the nillable_int8 field.
func (ftuo *FieldTypeUpdateOne) SetNillableInt8(i int8) *FieldTypeUpdateOne {
	ftuo.nillable_int8 = &i
	ftuo.addnillable_int8 = nil
	return ftuo
}

// SetNillableNillableInt8 sets the nillable_int8 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableNillableInt8(i *int8) *FieldTypeUpdateOne {
	if i != nil {
		ftuo.SetNillableInt8(*i)
	}
	return ftuo
}

// AddNillableInt8 adds i to nillable_int8.
func (ftuo *FieldTypeUpdateOne) AddNillableInt8(i int8) *FieldTypeUpdateOne {
	if ftuo.addnillable_int8 == nil {
		ftuo.addnillable_int8 = &i
	} else {
		*ftuo.addnillable_int8 += i
	}
	return ftuo
}

// ClearNillableInt8 clears the value of nillable_int8.
func (ftuo *FieldTypeUpdateOne) ClearNillableInt8() *FieldTypeUpdateOne {
	ftuo.nillable_int8 = nil
	ftuo.clearnillable_int8 = true
	return ftuo
}

// SetNillableInt16 sets the nillable_int16 field.
func (ftuo *FieldTypeUpdateOne) SetNillableInt16(i int16) *FieldTypeUpdateOne {
	ftuo.nillable_int16 = &i
	ftuo.addnillable_int16 = nil
	return ftuo
}

// SetNillableNillableInt16 sets the nillable_int16 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableNillableInt16(i *int16) *FieldTypeUpdateOne {
	if i != nil {
		ftuo.SetNillableInt16(*i)
	}
	return ftuo
}

// AddNillableInt16 adds i to nillable_int16.
func (ftuo *FieldTypeUpdateOne) AddNillableInt16(i int16) *FieldTypeUpdateOne {
	if ftuo.addnillable_int16 == nil {
		ftuo.addnillable_int16 = &i
	} else {
		*ftuo.addnillable_int16 += i
	}
	return ftuo
}

// ClearNillableInt16 clears the value of nillable_int16.
func (ftuo *FieldTypeUpdateOne) ClearNillableInt16() *FieldTypeUpdateOne {
	ftuo.nillable_int16 = nil
	ftuo.clearnillable_int16 = true
	return ftuo
}

// SetNillableInt32 sets the nillable_int32 field.
func (ftuo *FieldTypeUpdateOne) SetNillableInt32(i int32) *FieldTypeUpdateOne {
	ftuo.nillable_int32 = &i
	ftuo.addnillable_int32 = nil
	return ftuo
}

// SetNillableNillableInt32 sets the nillable_int32 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableNillableInt32(i *int32) *FieldTypeUpdateOne {
	if i != nil {
		ftuo.SetNillableInt32(*i)
	}
	return ftuo
}

// AddNillableInt32 adds i to nillable_int32.
func (ftuo *FieldTypeUpdateOne) AddNillableInt32(i int32) *FieldTypeUpdateOne {
	if ftuo.addnillable_int32 == nil {
		ftuo.addnillable_int32 = &i
	} else {
		*ftuo.addnillable_int32 += i
	}
	return ftuo
}

// ClearNillableInt32 clears the value of nillable_int32.
func (ftuo *FieldTypeUpdateOne) ClearNillableInt32() *FieldTypeUpdateOne {
	ftuo.nillable_int32 = nil
	ftuo.clearnillable_int32 = true
	return ftuo
}

// SetNillableInt64 sets the nillable_int64 field.
func (ftuo *FieldTypeUpdateOne) SetNillableInt64(i int64) *FieldTypeUpdateOne {
	ftuo.nillable_int64 = &i
	ftuo.addnillable_int64 = nil
	return ftuo
}

// SetNillableNillableInt64 sets the nillable_int64 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableNillableInt64(i *int64) *FieldTypeUpdateOne {
	if i != nil {
		ftuo.SetNillableInt64(*i)
	}
	return ftuo
}

// AddNillableInt64 adds i to nillable_int64.
func (ftuo *FieldTypeUpdateOne) AddNillableInt64(i int64) *FieldTypeUpdateOne {
	if ftuo.addnillable_int64 == nil {
		ftuo.addnillable_int64 = &i
	} else {
		*ftuo.addnillable_int64 += i
	}
	return ftuo
}

// ClearNillableInt64 clears the value of nillable_int64.
func (ftuo *FieldTypeUpdateOne) ClearNillableInt64() *FieldTypeUpdateOne {
	ftuo.nillable_int64 = nil
	ftuo.clearnillable_int64 = true
	return ftuo
}

// SetValidateOptionalInt32 sets the validate_optional_int32 field.
func (ftuo *FieldTypeUpdateOne) SetValidateOptionalInt32(i int32) *FieldTypeUpdateOne {
	ftuo.validate_optional_int32 = &i
	ftuo.addvalidate_optional_int32 = nil
	return ftuo
}

// SetNillableValidateOptionalInt32 sets the validate_optional_int32 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableValidateOptionalInt32(i *int32) *FieldTypeUpdateOne {
	if i != nil {
		ftuo.SetValidateOptionalInt32(*i)
	}
	return ftuo
}

// AddValidateOptionalInt32 adds i to validate_optional_int32.
func (ftuo *FieldTypeUpdateOne) AddValidateOptionalInt32(i int32) *FieldTypeUpdateOne {
	if ftuo.addvalidate_optional_int32 == nil {
		ftuo.addvalidate_optional_int32 = &i
	} else {
		*ftuo.addvalidate_optional_int32 += i
	}
	return ftuo
}

// ClearValidateOptionalInt32 clears the value of validate_optional_int32.
func (ftuo *FieldTypeUpdateOne) ClearValidateOptionalInt32() *FieldTypeUpdateOne {
	ftuo.validate_optional_int32 = nil
	ftuo.clearvalidate_optional_int32 = true
	return ftuo
}

// SetOptionalUint sets the optional_uint field.
func (ftuo *FieldTypeUpdateOne) SetOptionalUint(u uint) *FieldTypeUpdateOne {
	ftuo.optional_uint = &u
	ftuo.addoptional_uint = nil
	return ftuo
}

// SetNillableOptionalUint sets the optional_uint field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableOptionalUint(u *uint) *FieldTypeUpdateOne {
	if u != nil {
		ftuo.SetOptionalUint(*u)
	}
	return ftuo
}

// AddOptionalUint adds u to optional_uint.
func (ftuo *FieldTypeUpdateOne) AddOptionalUint(u uint) *FieldTypeUpdateOne {
	if ftuo.addoptional_uint == nil {
		ftuo.addoptional_uint = &u
	} else {
		*ftuo.addoptional_uint += u
	}
	return ftuo
}

// ClearOptionalUint clears the value of optional_uint.
func (ftuo *FieldTypeUpdateOne) ClearOptionalUint() *FieldTypeUpdateOne {
	ftuo.optional_uint = nil
	ftuo.clearoptional_uint = true
	return ftuo
}

// SetOptionalUint8 sets the optional_uint8 field.
func (ftuo *FieldTypeUpdateOne) SetOptionalUint8(u uint8) *FieldTypeUpdateOne {
	ftuo.optional_uint8 = &u
	ftuo.addoptional_uint8 = nil
	return ftuo
}

// SetNillableOptionalUint8 sets the optional_uint8 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableOptionalUint8(u *uint8) *FieldTypeUpdateOne {
	if u != nil {
		ftuo.SetOptionalUint8(*u)
	}
	return ftuo
}

// AddOptionalUint8 adds u to optional_uint8.
func (ftuo *FieldTypeUpdateOne) AddOptionalUint8(u uint8) *FieldTypeUpdateOne {
	if ftuo.addoptional_uint8 == nil {
		ftuo.addoptional_uint8 = &u
	} else {
		*ftuo.addoptional_uint8 += u
	}
	return ftuo
}

// ClearOptionalUint8 clears the value of optional_uint8.
func (ftuo *FieldTypeUpdateOne) ClearOptionalUint8() *FieldTypeUpdateOne {
	ftuo.optional_uint8 = nil
	ftuo.clearoptional_uint8 = true
	return ftuo
}

// SetOptionalUint16 sets the optional_uint16 field.
func (ftuo *FieldTypeUpdateOne) SetOptionalUint16(u uint16) *FieldTypeUpdateOne {
	ftuo.optional_uint16 = &u
	ftuo.addoptional_uint16 = nil
	return ftuo
}

// SetNillableOptionalUint16 sets the optional_uint16 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableOptionalUint16(u *uint16) *FieldTypeUpdateOne {
	if u != nil {
		ftuo.SetOptionalUint16(*u)
	}
	return ftuo
}

// AddOptionalUint16 adds u to optional_uint16.
func (ftuo *FieldTypeUpdateOne) AddOptionalUint16(u uint16) *FieldTypeUpdateOne {
	if ftuo.addoptional_uint16 == nil {
		ftuo.addoptional_uint16 = &u
	} else {
		*ftuo.addoptional_uint16 += u
	}
	return ftuo
}

// ClearOptionalUint16 clears the value of optional_uint16.
func (ftuo *FieldTypeUpdateOne) ClearOptionalUint16() *FieldTypeUpdateOne {
	ftuo.optional_uint16 = nil
	ftuo.clearoptional_uint16 = true
	return ftuo
}

// SetOptionalUint32 sets the optional_uint32 field.
func (ftuo *FieldTypeUpdateOne) SetOptionalUint32(u uint32) *FieldTypeUpdateOne {
	ftuo.optional_uint32 = &u
	ftuo.addoptional_uint32 = nil
	return ftuo
}

// SetNillableOptionalUint32 sets the optional_uint32 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableOptionalUint32(u *uint32) *FieldTypeUpdateOne {
	if u != nil {
		ftuo.SetOptionalUint32(*u)
	}
	return ftuo
}

// AddOptionalUint32 adds u to optional_uint32.
func (ftuo *FieldTypeUpdateOne) AddOptionalUint32(u uint32) *FieldTypeUpdateOne {
	if ftuo.addoptional_uint32 == nil {
		ftuo.addoptional_uint32 = &u
	} else {
		*ftuo.addoptional_uint32 += u
	}
	return ftuo
}

// ClearOptionalUint32 clears the value of optional_uint32.
func (ftuo *FieldTypeUpdateOne) ClearOptionalUint32() *FieldTypeUpdateOne {
	ftuo.optional_uint32 = nil
	ftuo.clearoptional_uint32 = true
	return ftuo
}

// SetOptionalUint64 sets the optional_uint64 field.
func (ftuo *FieldTypeUpdateOne) SetOptionalUint64(u uint64) *FieldTypeUpdateOne {
	ftuo.optional_uint64 = &u
	ftuo.addoptional_uint64 = nil
	return ftuo
}

// SetNillableOptionalUint64 sets the optional_uint64 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableOptionalUint64(u *uint64) *FieldTypeUpdateOne {
	if u != nil {
		ftuo.SetOptionalUint64(*u)
	}
	return ftuo
}

// AddOptionalUint64 adds u to optional_uint64.
func (ftuo *FieldTypeUpdateOne) AddOptionalUint64(u uint64) *FieldTypeUpdateOne {
	if ftuo.addoptional_uint64 == nil {
		ftuo.addoptional_uint64 = &u
	} else {
		*ftuo.addoptional_uint64 += u
	}
	return ftuo
}

// ClearOptionalUint64 clears the value of optional_uint64.
func (ftuo *FieldTypeUpdateOne) ClearOptionalUint64() *FieldTypeUpdateOne {
	ftuo.optional_uint64 = nil
	ftuo.clearoptional_uint64 = true
	return ftuo
}

// SetState sets the state field.
func (ftuo *FieldTypeUpdateOne) SetState(f fieldtype.State) *FieldTypeUpdateOne {
	ftuo.state = &f
	return ftuo
}

// SetNillableState sets the state field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableState(f *fieldtype.State) *FieldTypeUpdateOne {
	if f != nil {
		ftuo.SetState(*f)
	}
	return ftuo
}

// ClearState clears the value of state.
func (ftuo *FieldTypeUpdateOne) ClearState() *FieldTypeUpdateOne {
	ftuo.state = nil
	ftuo.clearstate = true
	return ftuo
}

// SetOptionalFloat sets the optional_float field.
func (ftuo *FieldTypeUpdateOne) SetOptionalFloat(f float64) *FieldTypeUpdateOne {
	ftuo.optional_float = &f
	ftuo.addoptional_float = nil
	return ftuo
}

// SetNillableOptionalFloat sets the optional_float field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableOptionalFloat(f *float64) *FieldTypeUpdateOne {
	if f != nil {
		ftuo.SetOptionalFloat(*f)
	}
	return ftuo
}

// AddOptionalFloat adds f to optional_float.
func (ftuo *FieldTypeUpdateOne) AddOptionalFloat(f float64) *FieldTypeUpdateOne {
	if ftuo.addoptional_float == nil {
		ftuo.addoptional_float = &f
	} else {
		*ftuo.addoptional_float += f
	}
	return ftuo
}

// ClearOptionalFloat clears the value of optional_float.
func (ftuo *FieldTypeUpdateOne) ClearOptionalFloat() *FieldTypeUpdateOne {
	ftuo.optional_float = nil
	ftuo.clearoptional_float = true
	return ftuo
}

// SetOptionalFloat32 sets the optional_float32 field.
func (ftuo *FieldTypeUpdateOne) SetOptionalFloat32(f float32) *FieldTypeUpdateOne {
	ftuo.optional_float32 = &f
	ftuo.addoptional_float32 = nil
	return ftuo
}

// SetNillableOptionalFloat32 sets the optional_float32 field if the given value is not nil.
func (ftuo *FieldTypeUpdateOne) SetNillableOptionalFloat32(f *float32) *FieldTypeUpdateOne {
	if f != nil {
		ftuo.SetOptionalFloat32(*f)
	}
	return ftuo
}

// AddOptionalFloat32 adds f to optional_float32.
func (ftuo *FieldTypeUpdateOne) AddOptionalFloat32(f float32) *FieldTypeUpdateOne {
	if ftuo.addoptional_float32 == nil {
		ftuo.addoptional_float32 = &f
	} else {
		*ftuo.addoptional_float32 += f
	}
	return ftuo
}

// ClearOptionalFloat32 clears the value of optional_float32.
func (ftuo *FieldTypeUpdateOne) ClearOptionalFloat32() *FieldTypeUpdateOne {
	ftuo.optional_float32 = nil
	ftuo.clearoptional_float32 = true
	return ftuo
}

// Save executes the query and returns the updated entity.
func (ftuo *FieldTypeUpdateOne) Save(ctx context.Context) (*FieldType, error) {
	if ftuo.validate_optional_int32 != nil {
		if err := fieldtype.ValidateOptionalInt32Validator(*ftuo.validate_optional_int32); err != nil {
			return nil, fmt.Errorf("ent: validator failed for field \"validate_optional_int32\": %v", err)
		}
	}
	if ftuo.state != nil {
		if err := fieldtype.StateValidator(*ftuo.state); err != nil {
			return nil, fmt.Errorf("ent: validator failed for field \"state\": %v", err)
		}
	}
	return ftuo.sqlSave(ctx)
}

// SaveX is like Save, but panics if an error occurs.
func (ftuo *FieldTypeUpdateOne) SaveX(ctx context.Context) *FieldType {
	ft, err := ftuo.Save(ctx)
	if err != nil {
		panic(err)
	}
	return ft
}

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

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

func (ftuo *FieldTypeUpdateOne) sqlSave(ctx context.Context) (ft *FieldType, err error) {
	_spec := &sqlgraph.UpdateSpec{
		Node: &sqlgraph.NodeSpec{
			Table:   fieldtype.Table,
			Columns: fieldtype.Columns,
			ID: &sqlgraph.FieldSpec{
				Value:  ftuo.id,
				Type:   field.TypeString,
				Column: fieldtype.FieldID,
			},
		},
	}
	if value := ftuo.int; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  *value,
			Column: fieldtype.FieldInt,
		})
	}
	if value := ftuo.addint; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  *value,
			Column: fieldtype.FieldInt,
		})
	}
	if value := ftuo.int8; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  *value,
			Column: fieldtype.FieldInt8,
		})
	}
	if value := ftuo.addint8; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  *value,
			Column: fieldtype.FieldInt8,
		})
	}
	if value := ftuo.int16; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Value:  *value,
			Column: fieldtype.FieldInt16,
		})
	}
	if value := ftuo.addint16; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Value:  *value,
			Column: fieldtype.FieldInt16,
		})
	}
	if value := ftuo.int32; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldInt32,
		})
	}
	if value := ftuo.addint32; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldInt32,
		})
	}
	if value := ftuo.int64; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  *value,
			Column: fieldtype.FieldInt64,
		})
	}
	if value := ftuo.addint64; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  *value,
			Column: fieldtype.FieldInt64,
		})
	}
	if value := ftuo.optional_int; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt,
		})
	}
	if value := ftuo.addoptional_int; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt,
		})
	}
	if ftuo.clearoptional_int {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Column: fieldtype.FieldOptionalInt,
		})
	}
	if value := ftuo.optional_int8; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt8,
		})
	}
	if value := ftuo.addoptional_int8; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt8,
		})
	}
	if ftuo.clearoptional_int8 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Column: fieldtype.FieldOptionalInt8,
		})
	}
	if value := ftuo.optional_int16; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt16,
		})
	}
	if value := ftuo.addoptional_int16; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt16,
		})
	}
	if ftuo.clearoptional_int16 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Column: fieldtype.FieldOptionalInt16,
		})
	}
	if value := ftuo.optional_int32; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt32,
		})
	}
	if value := ftuo.addoptional_int32; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt32,
		})
	}
	if ftuo.clearoptional_int32 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Column: fieldtype.FieldOptionalInt32,
		})
	}
	if value := ftuo.optional_int64; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt64,
		})
	}
	if value := ftuo.addoptional_int64; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  *value,
			Column: fieldtype.FieldOptionalInt64,
		})
	}
	if ftuo.clearoptional_int64 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Column: fieldtype.FieldOptionalInt64,
		})
	}
	if value := ftuo.nillable_int; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  *value,
			Column: fieldtype.FieldNillableInt,
		})
	}
	if value := ftuo.addnillable_int; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  *value,
			Column: fieldtype.FieldNillableInt,
		})
	}
	if ftuo.clearnillable_int {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Column: fieldtype.FieldNillableInt,
		})
	}
	if value := ftuo.nillable_int8; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  *value,
			Column: fieldtype.FieldNillableInt8,
		})
	}
	if value := ftuo.addnillable_int8; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  *value,
			Column: fieldtype.FieldNillableInt8,
		})
	}
	if ftuo.clearnillable_int8 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Column: fieldtype.FieldNillableInt8,
		})
	}
	if value := ftuo.nillable_int16; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Value:  *value,
			Column: fieldtype.FieldNillableInt16,
		})
	}
	if value := ftuo.addnillable_int16; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Value:  *value,
			Column: fieldtype.FieldNillableInt16,
		})
	}
	if ftuo.clearnillable_int16 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt16,
			Column: fieldtype.FieldNillableInt16,
		})
	}
	if value := ftuo.nillable_int32; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldNillableInt32,
		})
	}
	if value := ftuo.addnillable_int32; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldNillableInt32,
		})
	}
	if ftuo.clearnillable_int32 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Column: fieldtype.FieldNillableInt32,
		})
	}
	if value := ftuo.nillable_int64; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  *value,
			Column: fieldtype.FieldNillableInt64,
		})
	}
	if value := ftuo.addnillable_int64; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  *value,
			Column: fieldtype.FieldNillableInt64,
		})
	}
	if ftuo.clearnillable_int64 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Column: fieldtype.FieldNillableInt64,
		})
	}
	if value := ftuo.validate_optional_int32; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldValidateOptionalInt32,
		})
	}
	if value := ftuo.addvalidate_optional_int32; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Value:  *value,
			Column: fieldtype.FieldValidateOptionalInt32,
		})
	}
	if ftuo.clearvalidate_optional_int32 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt32,
			Column: fieldtype.FieldValidateOptionalInt32,
		})
	}
	if value := ftuo.optional_uint; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUint,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint,
		})
	}
	if value := ftuo.addoptional_uint; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeUint,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint,
		})
	}
	if ftuo.clearoptional_uint {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeUint,
			Column: fieldtype.FieldOptionalUint,
		})
	}
	if value := ftuo.optional_uint8; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUint8,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint8,
		})
	}
	if value := ftuo.addoptional_uint8; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeUint8,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint8,
		})
	}
	if ftuo.clearoptional_uint8 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeUint8,
			Column: fieldtype.FieldOptionalUint8,
		})
	}
	if value := ftuo.optional_uint16; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUint16,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint16,
		})
	}
	if value := ftuo.addoptional_uint16; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeUint16,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint16,
		})
	}
	if ftuo.clearoptional_uint16 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeUint16,
			Column: fieldtype.FieldOptionalUint16,
		})
	}
	if value := ftuo.optional_uint32; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUint32,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint32,
		})
	}
	if value := ftuo.addoptional_uint32; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeUint32,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint32,
		})
	}
	if ftuo.clearoptional_uint32 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeUint32,
			Column: fieldtype.FieldOptionalUint32,
		})
	}
	if value := ftuo.optional_uint64; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUint64,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint64,
		})
	}
	if value := ftuo.addoptional_uint64; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeUint64,
			Value:  *value,
			Column: fieldtype.FieldOptionalUint64,
		})
	}
	if ftuo.clearoptional_uint64 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeUint64,
			Column: fieldtype.FieldOptionalUint64,
		})
	}
	if value := ftuo.state; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeEnum,
			Value:  *value,
			Column: fieldtype.FieldState,
		})
	}
	if ftuo.clearstate {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeEnum,
			Column: fieldtype.FieldState,
		})
	}
	if value := ftuo.optional_float; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeFloat64,
			Value:  *value,
			Column: fieldtype.FieldOptionalFloat,
		})
	}
	if value := ftuo.addoptional_float; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeFloat64,
			Value:  *value,
			Column: fieldtype.FieldOptionalFloat,
		})
	}
	if ftuo.clearoptional_float {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeFloat64,
			Column: fieldtype.FieldOptionalFloat,
		})
	}
	if value := ftuo.optional_float32; value != nil {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeFloat32,
			Value:  *value,
			Column: fieldtype.FieldOptionalFloat32,
		})
	}
	if value := ftuo.addoptional_float32; value != nil {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeFloat32,
			Value:  *value,
			Column: fieldtype.FieldOptionalFloat32,
		})
	}
	if ftuo.clearoptional_float32 {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeFloat32,
			Column: fieldtype.FieldOptionalFloat32,
		})
	}
	ft = &FieldType{config: ftuo.config}
	_spec.Assign = ft.assignValues
	_spec.ScanValues = ft.scanValues()
	if err = sqlgraph.UpdateNode(ctx, ftuo.driver, _spec); err != nil {
		if _, ok := err.(*sqlgraph.NotFoundError); ok {
			err = &NotFoundError{fieldtype.Label}
		} else if cerr, ok := isSQLConstraintError(err); ok {
			err = cerr
		}
		return nil, err
	}
	return ft, nil
}