From ed979ced9923043f2150a74fbb3e93242950fa4f Mon Sep 17 00:00:00 2001 From: Giovanni Harting <539@idlegandalf.com> Date: Fri, 17 Oct 2025 20:42:22 +0200 Subject: [PATCH] update deps & regen ent --- ent/client.go | 8 +- ent/dbpackage.go | 118 ++--- ent/dbpackage_create.go | 394 +++++++------- ent/dbpackage_delete.go | 38 +- ent/dbpackage_query.go | 296 +++++------ ent/dbpackage_update.go | 1096 +++++++++++++++++++-------------------- ent/ent.go | 4 +- ent/runtime/runtime.go | 4 +- go.mod | 39 +- go.sum | 114 ++-- 10 files changed, 1046 insertions(+), 1065 deletions(-) diff --git a/ent/client.go b/ent/client.go index 7217d17..9ea02ff 100644 --- a/ent/client.go +++ b/ent/client.go @@ -251,8 +251,8 @@ func (c *DBPackageClient) Update() *DBPackageUpdate { } // UpdateOne returns an update builder for the given entity. -func (c *DBPackageClient) UpdateOne(dp *DBPackage) *DBPackageUpdateOne { - mutation := newDBPackageMutation(c.config, OpUpdateOne, withDBPackage(dp)) +func (c *DBPackageClient) UpdateOne(_m *DBPackage) *DBPackageUpdateOne { + mutation := newDBPackageMutation(c.config, OpUpdateOne, withDBPackage(_m)) return &DBPackageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} } @@ -269,8 +269,8 @@ func (c *DBPackageClient) Delete() *DBPackageDelete { } // DeleteOne returns a builder for deleting the given entity. -func (c *DBPackageClient) DeleteOne(dp *DBPackage) *DBPackageDeleteOne { - return c.DeleteOneID(dp.ID) +func (c *DBPackageClient) DeleteOne(_m *DBPackage) *DBPackageDeleteOne { + return c.DeleteOneID(_m.ID) } // DeleteOneID returns a builder for deleting the given entity by its id. diff --git a/ent/dbpackage.go b/ent/dbpackage.go index 532d41a..957dcd8 100644 --- a/ent/dbpackage.go +++ b/ent/dbpackage.go @@ -83,7 +83,7 @@ func (*DBPackage) scanValues(columns []string) ([]any, error) { // assignValues assigns the values that were returned from sql.Rows (after scanning) // to the DBPackage fields. -func (dp *DBPackage) assignValues(columns []string, values []any) error { +func (_m *DBPackage) assignValues(columns []string, values []any) error { if m, n := len(values), len(columns); m < n { return fmt.Errorf("mismatch number of scan values: %d != %d", m, n) } @@ -94,18 +94,18 @@ func (dp *DBPackage) assignValues(columns []string, values []any) error { if !ok { return fmt.Errorf("unexpected type %T for field id", value) } - dp.ID = int(value.Int64) + _m.ID = int(value.Int64) case dbpackage.FieldPkgbase: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field pkgbase", values[i]) } else if value.Valid { - dp.Pkgbase = value.String + _m.Pkgbase = value.String } case dbpackage.FieldPackages: if value, ok := values[i].(*[]byte); !ok { return fmt.Errorf("unexpected type %T for field packages", values[i]) } else if value != nil && len(*value) > 0 { - if err := json.Unmarshal(*value, &dp.Packages); err != nil { + if err := json.Unmarshal(*value, &_m.Packages); err != nil { return fmt.Errorf("unmarshal field packages: %w", err) } } @@ -113,118 +113,118 @@ func (dp *DBPackage) assignValues(columns []string, values []any) error { if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field status", values[i]) } else if value.Valid { - dp.Status = dbpackage.Status(value.String) + _m.Status = dbpackage.Status(value.String) } case dbpackage.FieldSkipReason: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field skip_reason", values[i]) } else if value.Valid { - dp.SkipReason = value.String + _m.SkipReason = value.String } case dbpackage.FieldRepository: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field repository", values[i]) } else if value.Valid { - dp.Repository = dbpackage.Repository(value.String) + _m.Repository = dbpackage.Repository(value.String) } case dbpackage.FieldMarch: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field march", values[i]) } else if value.Valid { - dp.March = value.String + _m.March = value.String } case dbpackage.FieldVersion: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field version", values[i]) } else if value.Valid { - dp.Version = value.String + _m.Version = value.String } case dbpackage.FieldRepoVersion: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field repo_version", values[i]) } else if value.Valid { - dp.RepoVersion = value.String + _m.RepoVersion = value.String } case dbpackage.FieldBuildTimeStart: if value, ok := values[i].(*sql.NullTime); !ok { return fmt.Errorf("unexpected type %T for field build_time_start", values[i]) } else if value.Valid { - dp.BuildTimeStart = value.Time + _m.BuildTimeStart = value.Time } case dbpackage.FieldUpdated: if value, ok := values[i].(*sql.NullTime); !ok { return fmt.Errorf("unexpected type %T for field updated", values[i]) } else if value.Valid { - dp.Updated = value.Time + _m.Updated = value.Time } case dbpackage.FieldLto: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field lto", values[i]) } else if value.Valid { - dp.Lto = dbpackage.Lto(value.String) + _m.Lto = dbpackage.Lto(value.String) } case dbpackage.FieldLastVersionBuild: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field last_version_build", values[i]) } else if value.Valid { - dp.LastVersionBuild = value.String + _m.LastVersionBuild = value.String } case dbpackage.FieldLastVerified: if value, ok := values[i].(*sql.NullTime); !ok { return fmt.Errorf("unexpected type %T for field last_verified", values[i]) } else if value.Valid { - dp.LastVerified = value.Time + _m.LastVerified = value.Time } case dbpackage.FieldDebugSymbols: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field debug_symbols", values[i]) } else if value.Valid { - dp.DebugSymbols = dbpackage.DebugSymbols(value.String) + _m.DebugSymbols = dbpackage.DebugSymbols(value.String) } case dbpackage.FieldMaxRss: if value, ok := values[i].(*sql.NullInt64); !ok { return fmt.Errorf("unexpected type %T for field max_rss", values[i]) } else if value.Valid { - dp.MaxRss = new(int64) - *dp.MaxRss = value.Int64 + _m.MaxRss = new(int64) + *_m.MaxRss = value.Int64 } case dbpackage.FieldUTime: if value, ok := values[i].(*sql.NullInt64); !ok { return fmt.Errorf("unexpected type %T for field u_time", values[i]) } else if value.Valid { - dp.UTime = new(int64) - *dp.UTime = value.Int64 + _m.UTime = new(int64) + *_m.UTime = value.Int64 } case dbpackage.FieldSTime: if value, ok := values[i].(*sql.NullInt64); !ok { return fmt.Errorf("unexpected type %T for field s_time", values[i]) } else if value.Valid { - dp.STime = new(int64) - *dp.STime = value.Int64 + _m.STime = new(int64) + *_m.STime = value.Int64 } case dbpackage.FieldIoIn: if value, ok := values[i].(*sql.NullInt64); !ok { return fmt.Errorf("unexpected type %T for field io_in", values[i]) } else if value.Valid { - dp.IoIn = new(int64) - *dp.IoIn = value.Int64 + _m.IoIn = new(int64) + *_m.IoIn = value.Int64 } case dbpackage.FieldIoOut: if value, ok := values[i].(*sql.NullInt64); !ok { return fmt.Errorf("unexpected type %T for field io_out", values[i]) } else if value.Valid { - dp.IoOut = new(int64) - *dp.IoOut = value.Int64 + _m.IoOut = new(int64) + *_m.IoOut = value.Int64 } case dbpackage.FieldTagRev: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field tag_rev", values[i]) } else if value.Valid { - dp.TagRev = new(string) - *dp.TagRev = value.String + _m.TagRev = new(string) + *_m.TagRev = value.String } default: - dp.selectValues.Set(columns[i], values[i]) + _m.selectValues.Set(columns[i], values[i]) } } return nil @@ -232,101 +232,101 @@ func (dp *DBPackage) assignValues(columns []string, values []any) error { // Value returns the ent.Value that was dynamically selected and assigned to the DBPackage. // This includes values selected through modifiers, order, etc. -func (dp *DBPackage) Value(name string) (ent.Value, error) { - return dp.selectValues.Get(name) +func (_m *DBPackage) Value(name string) (ent.Value, error) { + return _m.selectValues.Get(name) } // Update returns a builder for updating this DBPackage. // Note that you need to call DBPackage.Unwrap() before calling this method if this DBPackage // was returned from a transaction, and the transaction was committed or rolled back. -func (dp *DBPackage) Update() *DBPackageUpdateOne { - return NewDBPackageClient(dp.config).UpdateOne(dp) +func (_m *DBPackage) Update() *DBPackageUpdateOne { + return NewDBPackageClient(_m.config).UpdateOne(_m) } // Unwrap unwraps the DBPackage entity that was returned from a transaction after it was closed, // so that all future queries will be executed through the driver which created the transaction. -func (dp *DBPackage) Unwrap() *DBPackage { - _tx, ok := dp.config.driver.(*txDriver) +func (_m *DBPackage) Unwrap() *DBPackage { + _tx, ok := _m.config.driver.(*txDriver) if !ok { panic("ent: DBPackage is not a transactional entity") } - dp.config.driver = _tx.drv - return dp + _m.config.driver = _tx.drv + return _m } // String implements the fmt.Stringer. -func (dp *DBPackage) String() string { +func (_m *DBPackage) String() string { var builder strings.Builder builder.WriteString("DBPackage(") - builder.WriteString(fmt.Sprintf("id=%v, ", dp.ID)) + builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID)) builder.WriteString("pkgbase=") - builder.WriteString(dp.Pkgbase) + builder.WriteString(_m.Pkgbase) builder.WriteString(", ") builder.WriteString("packages=") - builder.WriteString(fmt.Sprintf("%v", dp.Packages)) + builder.WriteString(fmt.Sprintf("%v", _m.Packages)) builder.WriteString(", ") builder.WriteString("status=") - builder.WriteString(fmt.Sprintf("%v", dp.Status)) + builder.WriteString(fmt.Sprintf("%v", _m.Status)) builder.WriteString(", ") builder.WriteString("skip_reason=") - builder.WriteString(dp.SkipReason) + builder.WriteString(_m.SkipReason) builder.WriteString(", ") builder.WriteString("repository=") - builder.WriteString(fmt.Sprintf("%v", dp.Repository)) + builder.WriteString(fmt.Sprintf("%v", _m.Repository)) builder.WriteString(", ") builder.WriteString("march=") - builder.WriteString(dp.March) + builder.WriteString(_m.March) builder.WriteString(", ") builder.WriteString("version=") - builder.WriteString(dp.Version) + builder.WriteString(_m.Version) builder.WriteString(", ") builder.WriteString("repo_version=") - builder.WriteString(dp.RepoVersion) + builder.WriteString(_m.RepoVersion) builder.WriteString(", ") builder.WriteString("build_time_start=") - builder.WriteString(dp.BuildTimeStart.Format(time.ANSIC)) + builder.WriteString(_m.BuildTimeStart.Format(time.ANSIC)) builder.WriteString(", ") builder.WriteString("updated=") - builder.WriteString(dp.Updated.Format(time.ANSIC)) + builder.WriteString(_m.Updated.Format(time.ANSIC)) builder.WriteString(", ") builder.WriteString("lto=") - builder.WriteString(fmt.Sprintf("%v", dp.Lto)) + builder.WriteString(fmt.Sprintf("%v", _m.Lto)) builder.WriteString(", ") builder.WriteString("last_version_build=") - builder.WriteString(dp.LastVersionBuild) + builder.WriteString(_m.LastVersionBuild) builder.WriteString(", ") builder.WriteString("last_verified=") - builder.WriteString(dp.LastVerified.Format(time.ANSIC)) + builder.WriteString(_m.LastVerified.Format(time.ANSIC)) builder.WriteString(", ") builder.WriteString("debug_symbols=") - builder.WriteString(fmt.Sprintf("%v", dp.DebugSymbols)) + builder.WriteString(fmt.Sprintf("%v", _m.DebugSymbols)) builder.WriteString(", ") - if v := dp.MaxRss; v != nil { + if v := _m.MaxRss; v != nil { builder.WriteString("max_rss=") builder.WriteString(fmt.Sprintf("%v", *v)) } builder.WriteString(", ") - if v := dp.UTime; v != nil { + if v := _m.UTime; v != nil { builder.WriteString("u_time=") builder.WriteString(fmt.Sprintf("%v", *v)) } builder.WriteString(", ") - if v := dp.STime; v != nil { + if v := _m.STime; v != nil { builder.WriteString("s_time=") builder.WriteString(fmt.Sprintf("%v", *v)) } builder.WriteString(", ") - if v := dp.IoIn; v != nil { + if v := _m.IoIn; v != nil { builder.WriteString("io_in=") builder.WriteString(fmt.Sprintf("%v", *v)) } builder.WriteString(", ") - if v := dp.IoOut; v != nil { + if v := _m.IoOut; v != nil { builder.WriteString("io_out=") builder.WriteString(fmt.Sprintf("%v", *v)) } builder.WriteString(", ") - if v := dp.TagRev; v != nil { + if v := _m.TagRev; v != nil { builder.WriteString("tag_rev=") builder.WriteString(*v) } diff --git a/ent/dbpackage_create.go b/ent/dbpackage_create.go index 83c051e..ac47280 100644 --- a/ent/dbpackage_create.go +++ b/ent/dbpackage_create.go @@ -21,267 +21,267 @@ type DBPackageCreate struct { } // SetPkgbase sets the "pkgbase" field. -func (dpc *DBPackageCreate) SetPkgbase(s string) *DBPackageCreate { - dpc.mutation.SetPkgbase(s) - return dpc +func (_c *DBPackageCreate) SetPkgbase(v string) *DBPackageCreate { + _c.mutation.SetPkgbase(v) + return _c } // SetPackages sets the "packages" field. -func (dpc *DBPackageCreate) SetPackages(s []string) *DBPackageCreate { - dpc.mutation.SetPackages(s) - return dpc +func (_c *DBPackageCreate) SetPackages(v []string) *DBPackageCreate { + _c.mutation.SetPackages(v) + return _c } // SetStatus sets the "status" field. -func (dpc *DBPackageCreate) SetStatus(d dbpackage.Status) *DBPackageCreate { - dpc.mutation.SetStatus(d) - return dpc +func (_c *DBPackageCreate) SetStatus(v dbpackage.Status) *DBPackageCreate { + _c.mutation.SetStatus(v) + return _c } // SetNillableStatus sets the "status" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableStatus(d *dbpackage.Status) *DBPackageCreate { - if d != nil { - dpc.SetStatus(*d) +func (_c *DBPackageCreate) SetNillableStatus(v *dbpackage.Status) *DBPackageCreate { + if v != nil { + _c.SetStatus(*v) } - return dpc + return _c } // SetSkipReason sets the "skip_reason" field. -func (dpc *DBPackageCreate) SetSkipReason(s string) *DBPackageCreate { - dpc.mutation.SetSkipReason(s) - return dpc +func (_c *DBPackageCreate) SetSkipReason(v string) *DBPackageCreate { + _c.mutation.SetSkipReason(v) + return _c } // SetNillableSkipReason sets the "skip_reason" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableSkipReason(s *string) *DBPackageCreate { - if s != nil { - dpc.SetSkipReason(*s) +func (_c *DBPackageCreate) SetNillableSkipReason(v *string) *DBPackageCreate { + if v != nil { + _c.SetSkipReason(*v) } - return dpc + return _c } // SetRepository sets the "repository" field. -func (dpc *DBPackageCreate) SetRepository(d dbpackage.Repository) *DBPackageCreate { - dpc.mutation.SetRepository(d) - return dpc +func (_c *DBPackageCreate) SetRepository(v dbpackage.Repository) *DBPackageCreate { + _c.mutation.SetRepository(v) + return _c } // SetMarch sets the "march" field. -func (dpc *DBPackageCreate) SetMarch(s string) *DBPackageCreate { - dpc.mutation.SetMarch(s) - return dpc +func (_c *DBPackageCreate) SetMarch(v string) *DBPackageCreate { + _c.mutation.SetMarch(v) + return _c } // SetVersion sets the "version" field. -func (dpc *DBPackageCreate) SetVersion(s string) *DBPackageCreate { - dpc.mutation.SetVersion(s) - return dpc +func (_c *DBPackageCreate) SetVersion(v string) *DBPackageCreate { + _c.mutation.SetVersion(v) + return _c } // SetNillableVersion sets the "version" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableVersion(s *string) *DBPackageCreate { - if s != nil { - dpc.SetVersion(*s) +func (_c *DBPackageCreate) SetNillableVersion(v *string) *DBPackageCreate { + if v != nil { + _c.SetVersion(*v) } - return dpc + return _c } // SetRepoVersion sets the "repo_version" field. -func (dpc *DBPackageCreate) SetRepoVersion(s string) *DBPackageCreate { - dpc.mutation.SetRepoVersion(s) - return dpc +func (_c *DBPackageCreate) SetRepoVersion(v string) *DBPackageCreate { + _c.mutation.SetRepoVersion(v) + return _c } // SetNillableRepoVersion sets the "repo_version" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableRepoVersion(s *string) *DBPackageCreate { - if s != nil { - dpc.SetRepoVersion(*s) +func (_c *DBPackageCreate) SetNillableRepoVersion(v *string) *DBPackageCreate { + if v != nil { + _c.SetRepoVersion(*v) } - return dpc + return _c } // SetBuildTimeStart sets the "build_time_start" field. -func (dpc *DBPackageCreate) SetBuildTimeStart(t time.Time) *DBPackageCreate { - dpc.mutation.SetBuildTimeStart(t) - return dpc +func (_c *DBPackageCreate) SetBuildTimeStart(v time.Time) *DBPackageCreate { + _c.mutation.SetBuildTimeStart(v) + return _c } // SetNillableBuildTimeStart sets the "build_time_start" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableBuildTimeStart(t *time.Time) *DBPackageCreate { - if t != nil { - dpc.SetBuildTimeStart(*t) +func (_c *DBPackageCreate) SetNillableBuildTimeStart(v *time.Time) *DBPackageCreate { + if v != nil { + _c.SetBuildTimeStart(*v) } - return dpc + return _c } // SetUpdated sets the "updated" field. -func (dpc *DBPackageCreate) SetUpdated(t time.Time) *DBPackageCreate { - dpc.mutation.SetUpdated(t) - return dpc +func (_c *DBPackageCreate) SetUpdated(v time.Time) *DBPackageCreate { + _c.mutation.SetUpdated(v) + return _c } // SetNillableUpdated sets the "updated" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableUpdated(t *time.Time) *DBPackageCreate { - if t != nil { - dpc.SetUpdated(*t) +func (_c *DBPackageCreate) SetNillableUpdated(v *time.Time) *DBPackageCreate { + if v != nil { + _c.SetUpdated(*v) } - return dpc + return _c } // SetLto sets the "lto" field. -func (dpc *DBPackageCreate) SetLto(d dbpackage.Lto) *DBPackageCreate { - dpc.mutation.SetLto(d) - return dpc +func (_c *DBPackageCreate) SetLto(v dbpackage.Lto) *DBPackageCreate { + _c.mutation.SetLto(v) + return _c } // SetNillableLto sets the "lto" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableLto(d *dbpackage.Lto) *DBPackageCreate { - if d != nil { - dpc.SetLto(*d) +func (_c *DBPackageCreate) SetNillableLto(v *dbpackage.Lto) *DBPackageCreate { + if v != nil { + _c.SetLto(*v) } - return dpc + return _c } // SetLastVersionBuild sets the "last_version_build" field. -func (dpc *DBPackageCreate) SetLastVersionBuild(s string) *DBPackageCreate { - dpc.mutation.SetLastVersionBuild(s) - return dpc +func (_c *DBPackageCreate) SetLastVersionBuild(v string) *DBPackageCreate { + _c.mutation.SetLastVersionBuild(v) + return _c } // SetNillableLastVersionBuild sets the "last_version_build" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableLastVersionBuild(s *string) *DBPackageCreate { - if s != nil { - dpc.SetLastVersionBuild(*s) +func (_c *DBPackageCreate) SetNillableLastVersionBuild(v *string) *DBPackageCreate { + if v != nil { + _c.SetLastVersionBuild(*v) } - return dpc + return _c } // SetLastVerified sets the "last_verified" field. -func (dpc *DBPackageCreate) SetLastVerified(t time.Time) *DBPackageCreate { - dpc.mutation.SetLastVerified(t) - return dpc +func (_c *DBPackageCreate) SetLastVerified(v time.Time) *DBPackageCreate { + _c.mutation.SetLastVerified(v) + return _c } // SetNillableLastVerified sets the "last_verified" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableLastVerified(t *time.Time) *DBPackageCreate { - if t != nil { - dpc.SetLastVerified(*t) +func (_c *DBPackageCreate) SetNillableLastVerified(v *time.Time) *DBPackageCreate { + if v != nil { + _c.SetLastVerified(*v) } - return dpc + return _c } // SetDebugSymbols sets the "debug_symbols" field. -func (dpc *DBPackageCreate) SetDebugSymbols(ds dbpackage.DebugSymbols) *DBPackageCreate { - dpc.mutation.SetDebugSymbols(ds) - return dpc +func (_c *DBPackageCreate) SetDebugSymbols(v dbpackage.DebugSymbols) *DBPackageCreate { + _c.mutation.SetDebugSymbols(v) + return _c } // SetNillableDebugSymbols sets the "debug_symbols" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableDebugSymbols(ds *dbpackage.DebugSymbols) *DBPackageCreate { - if ds != nil { - dpc.SetDebugSymbols(*ds) +func (_c *DBPackageCreate) SetNillableDebugSymbols(v *dbpackage.DebugSymbols) *DBPackageCreate { + if v != nil { + _c.SetDebugSymbols(*v) } - return dpc + return _c } // SetMaxRss sets the "max_rss" field. -func (dpc *DBPackageCreate) SetMaxRss(i int64) *DBPackageCreate { - dpc.mutation.SetMaxRss(i) - return dpc +func (_c *DBPackageCreate) SetMaxRss(v int64) *DBPackageCreate { + _c.mutation.SetMaxRss(v) + return _c } // SetNillableMaxRss sets the "max_rss" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableMaxRss(i *int64) *DBPackageCreate { - if i != nil { - dpc.SetMaxRss(*i) +func (_c *DBPackageCreate) SetNillableMaxRss(v *int64) *DBPackageCreate { + if v != nil { + _c.SetMaxRss(*v) } - return dpc + return _c } // SetUTime sets the "u_time" field. -func (dpc *DBPackageCreate) SetUTime(i int64) *DBPackageCreate { - dpc.mutation.SetUTime(i) - return dpc +func (_c *DBPackageCreate) SetUTime(v int64) *DBPackageCreate { + _c.mutation.SetUTime(v) + return _c } // SetNillableUTime sets the "u_time" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableUTime(i *int64) *DBPackageCreate { - if i != nil { - dpc.SetUTime(*i) +func (_c *DBPackageCreate) SetNillableUTime(v *int64) *DBPackageCreate { + if v != nil { + _c.SetUTime(*v) } - return dpc + return _c } // SetSTime sets the "s_time" field. -func (dpc *DBPackageCreate) SetSTime(i int64) *DBPackageCreate { - dpc.mutation.SetSTime(i) - return dpc +func (_c *DBPackageCreate) SetSTime(v int64) *DBPackageCreate { + _c.mutation.SetSTime(v) + return _c } // SetNillableSTime sets the "s_time" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableSTime(i *int64) *DBPackageCreate { - if i != nil { - dpc.SetSTime(*i) +func (_c *DBPackageCreate) SetNillableSTime(v *int64) *DBPackageCreate { + if v != nil { + _c.SetSTime(*v) } - return dpc + return _c } // SetIoIn sets the "io_in" field. -func (dpc *DBPackageCreate) SetIoIn(i int64) *DBPackageCreate { - dpc.mutation.SetIoIn(i) - return dpc +func (_c *DBPackageCreate) SetIoIn(v int64) *DBPackageCreate { + _c.mutation.SetIoIn(v) + return _c } // SetNillableIoIn sets the "io_in" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableIoIn(i *int64) *DBPackageCreate { - if i != nil { - dpc.SetIoIn(*i) +func (_c *DBPackageCreate) SetNillableIoIn(v *int64) *DBPackageCreate { + if v != nil { + _c.SetIoIn(*v) } - return dpc + return _c } // SetIoOut sets the "io_out" field. -func (dpc *DBPackageCreate) SetIoOut(i int64) *DBPackageCreate { - dpc.mutation.SetIoOut(i) - return dpc +func (_c *DBPackageCreate) SetIoOut(v int64) *DBPackageCreate { + _c.mutation.SetIoOut(v) + return _c } // SetNillableIoOut sets the "io_out" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableIoOut(i *int64) *DBPackageCreate { - if i != nil { - dpc.SetIoOut(*i) +func (_c *DBPackageCreate) SetNillableIoOut(v *int64) *DBPackageCreate { + if v != nil { + _c.SetIoOut(*v) } - return dpc + return _c } // SetTagRev sets the "tag_rev" field. -func (dpc *DBPackageCreate) SetTagRev(s string) *DBPackageCreate { - dpc.mutation.SetTagRev(s) - return dpc +func (_c *DBPackageCreate) SetTagRev(v string) *DBPackageCreate { + _c.mutation.SetTagRev(v) + return _c } // SetNillableTagRev sets the "tag_rev" field if the given value is not nil. -func (dpc *DBPackageCreate) SetNillableTagRev(s *string) *DBPackageCreate { - if s != nil { - dpc.SetTagRev(*s) +func (_c *DBPackageCreate) SetNillableTagRev(v *string) *DBPackageCreate { + if v != nil { + _c.SetTagRev(*v) } - return dpc + return _c } // Mutation returns the DBPackageMutation object of the builder. -func (dpc *DBPackageCreate) Mutation() *DBPackageMutation { - return dpc.mutation +func (_c *DBPackageCreate) Mutation() *DBPackageMutation { + return _c.mutation } // Save creates the DBPackage in the database. -func (dpc *DBPackageCreate) Save(ctx context.Context) (*DBPackage, error) { - dpc.defaults() - return withHooks(ctx, dpc.sqlSave, dpc.mutation, dpc.hooks) +func (_c *DBPackageCreate) Save(ctx context.Context) (*DBPackage, error) { + _c.defaults() + return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks) } // SaveX calls Save and panics if Save returns an error. -func (dpc *DBPackageCreate) SaveX(ctx context.Context) *DBPackage { - v, err := dpc.Save(ctx) +func (_c *DBPackageCreate) SaveX(ctx context.Context) *DBPackage { + v, err := _c.Save(ctx) if err != nil { panic(err) } @@ -289,71 +289,71 @@ func (dpc *DBPackageCreate) SaveX(ctx context.Context) *DBPackage { } // Exec executes the query. -func (dpc *DBPackageCreate) Exec(ctx context.Context) error { - _, err := dpc.Save(ctx) +func (_c *DBPackageCreate) Exec(ctx context.Context) error { + _, err := _c.Save(ctx) return err } // ExecX is like Exec, but panics if an error occurs. -func (dpc *DBPackageCreate) ExecX(ctx context.Context) { - if err := dpc.Exec(ctx); err != nil { +func (_c *DBPackageCreate) ExecX(ctx context.Context) { + if err := _c.Exec(ctx); err != nil { panic(err) } } // defaults sets the default values of the builder before save. -func (dpc *DBPackageCreate) defaults() { - if _, ok := dpc.mutation.Status(); !ok { +func (_c *DBPackageCreate) defaults() { + if _, ok := _c.mutation.Status(); !ok { v := dbpackage.DefaultStatus - dpc.mutation.SetStatus(v) + _c.mutation.SetStatus(v) } - if _, ok := dpc.mutation.Lto(); !ok { + if _, ok := _c.mutation.Lto(); !ok { v := dbpackage.DefaultLto - dpc.mutation.SetLto(v) + _c.mutation.SetLto(v) } - if _, ok := dpc.mutation.DebugSymbols(); !ok { + if _, ok := _c.mutation.DebugSymbols(); !ok { v := dbpackage.DefaultDebugSymbols - dpc.mutation.SetDebugSymbols(v) + _c.mutation.SetDebugSymbols(v) } } // check runs all checks and user-defined validators on the builder. -func (dpc *DBPackageCreate) check() error { - if _, ok := dpc.mutation.Pkgbase(); !ok { +func (_c *DBPackageCreate) check() error { + if _, ok := _c.mutation.Pkgbase(); !ok { return &ValidationError{Name: "pkgbase", err: errors.New(`ent: missing required field "DBPackage.pkgbase"`)} } - if v, ok := dpc.mutation.Pkgbase(); ok { + if v, ok := _c.mutation.Pkgbase(); ok { if err := dbpackage.PkgbaseValidator(v); err != nil { return &ValidationError{Name: "pkgbase", err: fmt.Errorf(`ent: validator failed for field "DBPackage.pkgbase": %w`, err)} } } - if v, ok := dpc.mutation.Status(); ok { + if v, ok := _c.mutation.Status(); ok { if err := dbpackage.StatusValidator(v); err != nil { return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "DBPackage.status": %w`, err)} } } - if _, ok := dpc.mutation.Repository(); !ok { + if _, ok := _c.mutation.Repository(); !ok { return &ValidationError{Name: "repository", err: errors.New(`ent: missing required field "DBPackage.repository"`)} } - if v, ok := dpc.mutation.Repository(); ok { + if v, ok := _c.mutation.Repository(); ok { if err := dbpackage.RepositoryValidator(v); err != nil { return &ValidationError{Name: "repository", err: fmt.Errorf(`ent: validator failed for field "DBPackage.repository": %w`, err)} } } - if _, ok := dpc.mutation.March(); !ok { + if _, ok := _c.mutation.March(); !ok { return &ValidationError{Name: "march", err: errors.New(`ent: missing required field "DBPackage.march"`)} } - if v, ok := dpc.mutation.March(); ok { + if v, ok := _c.mutation.March(); ok { if err := dbpackage.MarchValidator(v); err != nil { return &ValidationError{Name: "march", err: fmt.Errorf(`ent: validator failed for field "DBPackage.march": %w`, err)} } } - if v, ok := dpc.mutation.Lto(); ok { + if v, ok := _c.mutation.Lto(); ok { if err := dbpackage.LtoValidator(v); err != nil { return &ValidationError{Name: "lto", err: fmt.Errorf(`ent: validator failed for field "DBPackage.lto": %w`, err)} } } - if v, ok := dpc.mutation.DebugSymbols(); ok { + if v, ok := _c.mutation.DebugSymbols(); ok { if err := dbpackage.DebugSymbolsValidator(v); err != nil { return &ValidationError{Name: "debug_symbols", err: fmt.Errorf(`ent: validator failed for field "DBPackage.debug_symbols": %w`, err)} } @@ -361,12 +361,12 @@ func (dpc *DBPackageCreate) check() error { return nil } -func (dpc *DBPackageCreate) sqlSave(ctx context.Context) (*DBPackage, error) { - if err := dpc.check(); err != nil { +func (_c *DBPackageCreate) sqlSave(ctx context.Context) (*DBPackage, error) { + if err := _c.check(); err != nil { return nil, err } - _node, _spec := dpc.createSpec() - if err := sqlgraph.CreateNode(ctx, dpc.driver, _spec); err != nil { + _node, _spec := _c.createSpec() + if err := sqlgraph.CreateNode(ctx, _c.driver, _spec); err != nil { if sqlgraph.IsConstraintError(err) { err = &ConstraintError{msg: err.Error(), wrap: err} } @@ -374,93 +374,93 @@ func (dpc *DBPackageCreate) sqlSave(ctx context.Context) (*DBPackage, error) { } id := _spec.ID.Value.(int64) _node.ID = int(id) - dpc.mutation.id = &_node.ID - dpc.mutation.done = true + _c.mutation.id = &_node.ID + _c.mutation.done = true return _node, nil } -func (dpc *DBPackageCreate) createSpec() (*DBPackage, *sqlgraph.CreateSpec) { +func (_c *DBPackageCreate) createSpec() (*DBPackage, *sqlgraph.CreateSpec) { var ( - _node = &DBPackage{config: dpc.config} + _node = &DBPackage{config: _c.config} _spec = sqlgraph.NewCreateSpec(dbpackage.Table, sqlgraph.NewFieldSpec(dbpackage.FieldID, field.TypeInt)) ) - if value, ok := dpc.mutation.Pkgbase(); ok { + if value, ok := _c.mutation.Pkgbase(); ok { _spec.SetField(dbpackage.FieldPkgbase, field.TypeString, value) _node.Pkgbase = value } - if value, ok := dpc.mutation.Packages(); ok { + if value, ok := _c.mutation.Packages(); ok { _spec.SetField(dbpackage.FieldPackages, field.TypeJSON, value) _node.Packages = value } - if value, ok := dpc.mutation.Status(); ok { + if value, ok := _c.mutation.Status(); ok { _spec.SetField(dbpackage.FieldStatus, field.TypeEnum, value) _node.Status = value } - if value, ok := dpc.mutation.SkipReason(); ok { + if value, ok := _c.mutation.SkipReason(); ok { _spec.SetField(dbpackage.FieldSkipReason, field.TypeString, value) _node.SkipReason = value } - if value, ok := dpc.mutation.Repository(); ok { + if value, ok := _c.mutation.Repository(); ok { _spec.SetField(dbpackage.FieldRepository, field.TypeEnum, value) _node.Repository = value } - if value, ok := dpc.mutation.March(); ok { + if value, ok := _c.mutation.March(); ok { _spec.SetField(dbpackage.FieldMarch, field.TypeString, value) _node.March = value } - if value, ok := dpc.mutation.Version(); ok { + if value, ok := _c.mutation.Version(); ok { _spec.SetField(dbpackage.FieldVersion, field.TypeString, value) _node.Version = value } - if value, ok := dpc.mutation.RepoVersion(); ok { + if value, ok := _c.mutation.RepoVersion(); ok { _spec.SetField(dbpackage.FieldRepoVersion, field.TypeString, value) _node.RepoVersion = value } - if value, ok := dpc.mutation.BuildTimeStart(); ok { + if value, ok := _c.mutation.BuildTimeStart(); ok { _spec.SetField(dbpackage.FieldBuildTimeStart, field.TypeTime, value) _node.BuildTimeStart = value } - if value, ok := dpc.mutation.Updated(); ok { + if value, ok := _c.mutation.Updated(); ok { _spec.SetField(dbpackage.FieldUpdated, field.TypeTime, value) _node.Updated = value } - if value, ok := dpc.mutation.Lto(); ok { + if value, ok := _c.mutation.Lto(); ok { _spec.SetField(dbpackage.FieldLto, field.TypeEnum, value) _node.Lto = value } - if value, ok := dpc.mutation.LastVersionBuild(); ok { + if value, ok := _c.mutation.LastVersionBuild(); ok { _spec.SetField(dbpackage.FieldLastVersionBuild, field.TypeString, value) _node.LastVersionBuild = value } - if value, ok := dpc.mutation.LastVerified(); ok { + if value, ok := _c.mutation.LastVerified(); ok { _spec.SetField(dbpackage.FieldLastVerified, field.TypeTime, value) _node.LastVerified = value } - if value, ok := dpc.mutation.DebugSymbols(); ok { + if value, ok := _c.mutation.DebugSymbols(); ok { _spec.SetField(dbpackage.FieldDebugSymbols, field.TypeEnum, value) _node.DebugSymbols = value } - if value, ok := dpc.mutation.MaxRss(); ok { + if value, ok := _c.mutation.MaxRss(); ok { _spec.SetField(dbpackage.FieldMaxRss, field.TypeInt64, value) _node.MaxRss = &value } - if value, ok := dpc.mutation.UTime(); ok { + if value, ok := _c.mutation.UTime(); ok { _spec.SetField(dbpackage.FieldUTime, field.TypeInt64, value) _node.UTime = &value } - if value, ok := dpc.mutation.STime(); ok { + if value, ok := _c.mutation.STime(); ok { _spec.SetField(dbpackage.FieldSTime, field.TypeInt64, value) _node.STime = &value } - if value, ok := dpc.mutation.IoIn(); ok { + if value, ok := _c.mutation.IoIn(); ok { _spec.SetField(dbpackage.FieldIoIn, field.TypeInt64, value) _node.IoIn = &value } - if value, ok := dpc.mutation.IoOut(); ok { + if value, ok := _c.mutation.IoOut(); ok { _spec.SetField(dbpackage.FieldIoOut, field.TypeInt64, value) _node.IoOut = &value } - if value, ok := dpc.mutation.TagRev(); ok { + if value, ok := _c.mutation.TagRev(); ok { _spec.SetField(dbpackage.FieldTagRev, field.TypeString, value) _node.TagRev = &value } @@ -475,16 +475,16 @@ type DBPackageCreateBulk struct { } // Save creates the DBPackage entities in the database. -func (dpcb *DBPackageCreateBulk) Save(ctx context.Context) ([]*DBPackage, error) { - if dpcb.err != nil { - return nil, dpcb.err +func (_c *DBPackageCreateBulk) Save(ctx context.Context) ([]*DBPackage, error) { + if _c.err != nil { + return nil, _c.err } - specs := make([]*sqlgraph.CreateSpec, len(dpcb.builders)) - nodes := make([]*DBPackage, len(dpcb.builders)) - mutators := make([]Mutator, len(dpcb.builders)) - for i := range dpcb.builders { + specs := make([]*sqlgraph.CreateSpec, len(_c.builders)) + nodes := make([]*DBPackage, len(_c.builders)) + mutators := make([]Mutator, len(_c.builders)) + for i := range _c.builders { func(i int, root context.Context) { - builder := dpcb.builders[i] + builder := _c.builders[i] builder.defaults() var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { mutation, ok := m.(*DBPackageMutation) @@ -498,11 +498,11 @@ func (dpcb *DBPackageCreateBulk) Save(ctx context.Context) ([]*DBPackage, error) var err error nodes[i], specs[i] = builder.createSpec() if i < len(mutators)-1 { - _, err = mutators[i+1].Mutate(root, dpcb.builders[i+1].mutation) + _, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation) } else { spec := &sqlgraph.BatchCreateSpec{Nodes: specs} // Invoke the actual operation on the latest mutation in the chain. - if err = sqlgraph.BatchCreate(ctx, dpcb.driver, spec); err != nil { + if err = sqlgraph.BatchCreate(ctx, _c.driver, spec); err != nil { if sqlgraph.IsConstraintError(err) { err = &ConstraintError{msg: err.Error(), wrap: err} } @@ -526,7 +526,7 @@ func (dpcb *DBPackageCreateBulk) Save(ctx context.Context) ([]*DBPackage, error) }(i, ctx) } if len(mutators) > 0 { - if _, err := mutators[0].Mutate(ctx, dpcb.builders[0].mutation); err != nil { + if _, err := mutators[0].Mutate(ctx, _c.builders[0].mutation); err != nil { return nil, err } } @@ -534,8 +534,8 @@ func (dpcb *DBPackageCreateBulk) Save(ctx context.Context) ([]*DBPackage, error) } // SaveX is like Save, but panics if an error occurs. -func (dpcb *DBPackageCreateBulk) SaveX(ctx context.Context) []*DBPackage { - v, err := dpcb.Save(ctx) +func (_c *DBPackageCreateBulk) SaveX(ctx context.Context) []*DBPackage { + v, err := _c.Save(ctx) if err != nil { panic(err) } @@ -543,14 +543,14 @@ func (dpcb *DBPackageCreateBulk) SaveX(ctx context.Context) []*DBPackage { } // Exec executes the query. -func (dpcb *DBPackageCreateBulk) Exec(ctx context.Context) error { - _, err := dpcb.Save(ctx) +func (_c *DBPackageCreateBulk) Exec(ctx context.Context) error { + _, err := _c.Save(ctx) return err } // ExecX is like Exec, but panics if an error occurs. -func (dpcb *DBPackageCreateBulk) ExecX(ctx context.Context) { - if err := dpcb.Exec(ctx); err != nil { +func (_c *DBPackageCreateBulk) ExecX(ctx context.Context) { + if err := _c.Exec(ctx); err != nil { panic(err) } } diff --git a/ent/dbpackage_delete.go b/ent/dbpackage_delete.go index 340f0fa..1a4aa5e 100644 --- a/ent/dbpackage_delete.go +++ b/ent/dbpackage_delete.go @@ -20,56 +20,56 @@ type DBPackageDelete struct { } // Where appends a list predicates to the DBPackageDelete builder. -func (dpd *DBPackageDelete) Where(ps ...predicate.DBPackage) *DBPackageDelete { - dpd.mutation.Where(ps...) - return dpd +func (_d *DBPackageDelete) Where(ps ...predicate.DBPackage) *DBPackageDelete { + _d.mutation.Where(ps...) + return _d } // Exec executes the deletion query and returns how many vertices were deleted. -func (dpd *DBPackageDelete) Exec(ctx context.Context) (int, error) { - return withHooks(ctx, dpd.sqlExec, dpd.mutation, dpd.hooks) +func (_d *DBPackageDelete) Exec(ctx context.Context) (int, error) { + return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks) } // ExecX is like Exec, but panics if an error occurs. -func (dpd *DBPackageDelete) ExecX(ctx context.Context) int { - n, err := dpd.Exec(ctx) +func (_d *DBPackageDelete) ExecX(ctx context.Context) int { + n, err := _d.Exec(ctx) if err != nil { panic(err) } return n } -func (dpd *DBPackageDelete) sqlExec(ctx context.Context) (int, error) { +func (_d *DBPackageDelete) sqlExec(ctx context.Context) (int, error) { _spec := sqlgraph.NewDeleteSpec(dbpackage.Table, sqlgraph.NewFieldSpec(dbpackage.FieldID, field.TypeInt)) - if ps := dpd.mutation.predicates; len(ps) > 0 { + if ps := _d.mutation.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { for i := range ps { ps[i](selector) } } } - affected, err := sqlgraph.DeleteNodes(ctx, dpd.driver, _spec) + affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec) if err != nil && sqlgraph.IsConstraintError(err) { err = &ConstraintError{msg: err.Error(), wrap: err} } - dpd.mutation.done = true + _d.mutation.done = true return affected, err } // DBPackageDeleteOne is the builder for deleting a single DBPackage entity. type DBPackageDeleteOne struct { - dpd *DBPackageDelete + _d *DBPackageDelete } // Where appends a list predicates to the DBPackageDelete builder. -func (dpdo *DBPackageDeleteOne) Where(ps ...predicate.DBPackage) *DBPackageDeleteOne { - dpdo.dpd.mutation.Where(ps...) - return dpdo +func (_d *DBPackageDeleteOne) Where(ps ...predicate.DBPackage) *DBPackageDeleteOne { + _d._d.mutation.Where(ps...) + return _d } // Exec executes the deletion query. -func (dpdo *DBPackageDeleteOne) Exec(ctx context.Context) error { - n, err := dpdo.dpd.Exec(ctx) +func (_d *DBPackageDeleteOne) Exec(ctx context.Context) error { + n, err := _d._d.Exec(ctx) switch { case err != nil: return err @@ -81,8 +81,8 @@ func (dpdo *DBPackageDeleteOne) Exec(ctx context.Context) error { } // ExecX is like Exec, but panics if an error occurs. -func (dpdo *DBPackageDeleteOne) ExecX(ctx context.Context) { - if err := dpdo.Exec(ctx); err != nil { +func (_d *DBPackageDeleteOne) ExecX(ctx context.Context) { + if err := _d.Exec(ctx); err != nil { panic(err) } } diff --git a/ent/dbpackage_query.go b/ent/dbpackage_query.go index d47437a..bbb73fd 100644 --- a/ent/dbpackage_query.go +++ b/ent/dbpackage_query.go @@ -29,40 +29,40 @@ type DBPackageQuery struct { } // Where adds a new predicate for the DBPackageQuery builder. -func (dpq *DBPackageQuery) Where(ps ...predicate.DBPackage) *DBPackageQuery { - dpq.predicates = append(dpq.predicates, ps...) - return dpq +func (_q *DBPackageQuery) Where(ps ...predicate.DBPackage) *DBPackageQuery { + _q.predicates = append(_q.predicates, ps...) + return _q } // Limit the number of records to be returned by this query. -func (dpq *DBPackageQuery) Limit(limit int) *DBPackageQuery { - dpq.ctx.Limit = &limit - return dpq +func (_q *DBPackageQuery) Limit(limit int) *DBPackageQuery { + _q.ctx.Limit = &limit + return _q } // Offset to start from. -func (dpq *DBPackageQuery) Offset(offset int) *DBPackageQuery { - dpq.ctx.Offset = &offset - return dpq +func (_q *DBPackageQuery) Offset(offset int) *DBPackageQuery { + _q.ctx.Offset = &offset + return _q } // Unique configures the query builder to filter duplicate records on query. // By default, unique is set to true, and can be disabled using this method. -func (dpq *DBPackageQuery) Unique(unique bool) *DBPackageQuery { - dpq.ctx.Unique = &unique - return dpq +func (_q *DBPackageQuery) Unique(unique bool) *DBPackageQuery { + _q.ctx.Unique = &unique + return _q } // Order specifies how the records should be ordered. -func (dpq *DBPackageQuery) Order(o ...dbpackage.OrderOption) *DBPackageQuery { - dpq.order = append(dpq.order, o...) - return dpq +func (_q *DBPackageQuery) Order(o ...dbpackage.OrderOption) *DBPackageQuery { + _q.order = append(_q.order, o...) + return _q } // First returns the first DBPackage entity from the query. // Returns a *NotFoundError when no DBPackage was found. -func (dpq *DBPackageQuery) First(ctx context.Context) (*DBPackage, error) { - nodes, err := dpq.Limit(1).All(setContextOp(ctx, dpq.ctx, ent.OpQueryFirst)) +func (_q *DBPackageQuery) First(ctx context.Context) (*DBPackage, error) { + nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst)) if err != nil { return nil, err } @@ -73,8 +73,8 @@ func (dpq *DBPackageQuery) First(ctx context.Context) (*DBPackage, error) { } // FirstX is like First, but panics if an error occurs. -func (dpq *DBPackageQuery) FirstX(ctx context.Context) *DBPackage { - node, err := dpq.First(ctx) +func (_q *DBPackageQuery) FirstX(ctx context.Context) *DBPackage { + node, err := _q.First(ctx) if err != nil && !IsNotFound(err) { panic(err) } @@ -83,9 +83,9 @@ func (dpq *DBPackageQuery) FirstX(ctx context.Context) *DBPackage { // FirstID returns the first DBPackage ID from the query. // Returns a *NotFoundError when no DBPackage ID was found. -func (dpq *DBPackageQuery) FirstID(ctx context.Context) (id int, err error) { +func (_q *DBPackageQuery) FirstID(ctx context.Context) (id int, err error) { var ids []int - if ids, err = dpq.Limit(1).IDs(setContextOp(ctx, dpq.ctx, ent.OpQueryFirstID)); err != nil { + if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil { return } if len(ids) == 0 { @@ -96,8 +96,8 @@ func (dpq *DBPackageQuery) FirstID(ctx context.Context) (id int, err error) { } // FirstIDX is like FirstID, but panics if an error occurs. -func (dpq *DBPackageQuery) FirstIDX(ctx context.Context) int { - id, err := dpq.FirstID(ctx) +func (_q *DBPackageQuery) FirstIDX(ctx context.Context) int { + id, err := _q.FirstID(ctx) if err != nil && !IsNotFound(err) { panic(err) } @@ -107,8 +107,8 @@ func (dpq *DBPackageQuery) FirstIDX(ctx context.Context) int { // Only returns a single DBPackage entity found by the query, ensuring it only returns one. // Returns a *NotSingularError when more than one DBPackage entity is found. // Returns a *NotFoundError when no DBPackage entities are found. -func (dpq *DBPackageQuery) Only(ctx context.Context) (*DBPackage, error) { - nodes, err := dpq.Limit(2).All(setContextOp(ctx, dpq.ctx, ent.OpQueryOnly)) +func (_q *DBPackageQuery) Only(ctx context.Context) (*DBPackage, error) { + nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly)) if err != nil { return nil, err } @@ -123,8 +123,8 @@ func (dpq *DBPackageQuery) Only(ctx context.Context) (*DBPackage, error) { } // OnlyX is like Only, but panics if an error occurs. -func (dpq *DBPackageQuery) OnlyX(ctx context.Context) *DBPackage { - node, err := dpq.Only(ctx) +func (_q *DBPackageQuery) OnlyX(ctx context.Context) *DBPackage { + node, err := _q.Only(ctx) if err != nil { panic(err) } @@ -134,9 +134,9 @@ func (dpq *DBPackageQuery) OnlyX(ctx context.Context) *DBPackage { // OnlyID is like Only, but returns the only DBPackage ID in the query. // Returns a *NotSingularError when more than one DBPackage ID is found. // Returns a *NotFoundError when no entities are found. -func (dpq *DBPackageQuery) OnlyID(ctx context.Context) (id int, err error) { +func (_q *DBPackageQuery) OnlyID(ctx context.Context) (id int, err error) { var ids []int - if ids, err = dpq.Limit(2).IDs(setContextOp(ctx, dpq.ctx, ent.OpQueryOnlyID)); err != nil { + if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil { return } switch len(ids) { @@ -151,8 +151,8 @@ func (dpq *DBPackageQuery) OnlyID(ctx context.Context) (id int, err error) { } // OnlyIDX is like OnlyID, but panics if an error occurs. -func (dpq *DBPackageQuery) OnlyIDX(ctx context.Context) int { - id, err := dpq.OnlyID(ctx) +func (_q *DBPackageQuery) OnlyIDX(ctx context.Context) int { + id, err := _q.OnlyID(ctx) if err != nil { panic(err) } @@ -160,18 +160,18 @@ func (dpq *DBPackageQuery) OnlyIDX(ctx context.Context) int { } // All executes the query and returns a list of DBPackages. -func (dpq *DBPackageQuery) All(ctx context.Context) ([]*DBPackage, error) { - ctx = setContextOp(ctx, dpq.ctx, ent.OpQueryAll) - if err := dpq.prepareQuery(ctx); err != nil { +func (_q *DBPackageQuery) All(ctx context.Context) ([]*DBPackage, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll) + if err := _q.prepareQuery(ctx); err != nil { return nil, err } qr := querierAll[[]*DBPackage, *DBPackageQuery]() - return withInterceptors[[]*DBPackage](ctx, dpq, qr, dpq.inters) + return withInterceptors[[]*DBPackage](ctx, _q, qr, _q.inters) } // AllX is like All, but panics if an error occurs. -func (dpq *DBPackageQuery) AllX(ctx context.Context) []*DBPackage { - nodes, err := dpq.All(ctx) +func (_q *DBPackageQuery) AllX(ctx context.Context) []*DBPackage { + nodes, err := _q.All(ctx) if err != nil { panic(err) } @@ -179,20 +179,20 @@ func (dpq *DBPackageQuery) AllX(ctx context.Context) []*DBPackage { } // IDs executes the query and returns a list of DBPackage IDs. -func (dpq *DBPackageQuery) IDs(ctx context.Context) (ids []int, err error) { - if dpq.ctx.Unique == nil && dpq.path != nil { - dpq.Unique(true) +func (_q *DBPackageQuery) IDs(ctx context.Context) (ids []int, err error) { + if _q.ctx.Unique == nil && _q.path != nil { + _q.Unique(true) } - ctx = setContextOp(ctx, dpq.ctx, ent.OpQueryIDs) - if err = dpq.Select(dbpackage.FieldID).Scan(ctx, &ids); err != nil { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs) + if err = _q.Select(dbpackage.FieldID).Scan(ctx, &ids); err != nil { return nil, err } return ids, nil } // IDsX is like IDs, but panics if an error occurs. -func (dpq *DBPackageQuery) IDsX(ctx context.Context) []int { - ids, err := dpq.IDs(ctx) +func (_q *DBPackageQuery) IDsX(ctx context.Context) []int { + ids, err := _q.IDs(ctx) if err != nil { panic(err) } @@ -200,17 +200,17 @@ func (dpq *DBPackageQuery) IDsX(ctx context.Context) []int { } // Count returns the count of the given query. -func (dpq *DBPackageQuery) Count(ctx context.Context) (int, error) { - ctx = setContextOp(ctx, dpq.ctx, ent.OpQueryCount) - if err := dpq.prepareQuery(ctx); err != nil { +func (_q *DBPackageQuery) Count(ctx context.Context) (int, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount) + if err := _q.prepareQuery(ctx); err != nil { return 0, err } - return withInterceptors[int](ctx, dpq, querierCount[*DBPackageQuery](), dpq.inters) + return withInterceptors[int](ctx, _q, querierCount[*DBPackageQuery](), _q.inters) } // CountX is like Count, but panics if an error occurs. -func (dpq *DBPackageQuery) CountX(ctx context.Context) int { - count, err := dpq.Count(ctx) +func (_q *DBPackageQuery) CountX(ctx context.Context) int { + count, err := _q.Count(ctx) if err != nil { panic(err) } @@ -218,9 +218,9 @@ func (dpq *DBPackageQuery) CountX(ctx context.Context) int { } // Exist returns true if the query has elements in the graph. -func (dpq *DBPackageQuery) Exist(ctx context.Context) (bool, error) { - ctx = setContextOp(ctx, dpq.ctx, ent.OpQueryExist) - switch _, err := dpq.FirstID(ctx); { +func (_q *DBPackageQuery) Exist(ctx context.Context) (bool, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist) + switch _, err := _q.FirstID(ctx); { case IsNotFound(err): return false, nil case err != nil: @@ -231,8 +231,8 @@ func (dpq *DBPackageQuery) Exist(ctx context.Context) (bool, error) { } // ExistX is like Exist, but panics if an error occurs. -func (dpq *DBPackageQuery) ExistX(ctx context.Context) bool { - exist, err := dpq.Exist(ctx) +func (_q *DBPackageQuery) ExistX(ctx context.Context) bool { + exist, err := _q.Exist(ctx) if err != nil { panic(err) } @@ -241,20 +241,20 @@ func (dpq *DBPackageQuery) ExistX(ctx context.Context) bool { // Clone returns a duplicate of the DBPackageQuery builder, including all associated steps. It can be // used to prepare common query builders and use them differently after the clone is made. -func (dpq *DBPackageQuery) Clone() *DBPackageQuery { - if dpq == nil { +func (_q *DBPackageQuery) Clone() *DBPackageQuery { + if _q == nil { return nil } return &DBPackageQuery{ - config: dpq.config, - ctx: dpq.ctx.Clone(), - order: append([]dbpackage.OrderOption{}, dpq.order...), - inters: append([]Interceptor{}, dpq.inters...), - predicates: append([]predicate.DBPackage{}, dpq.predicates...), + config: _q.config, + ctx: _q.ctx.Clone(), + order: append([]dbpackage.OrderOption{}, _q.order...), + inters: append([]Interceptor{}, _q.inters...), + predicates: append([]predicate.DBPackage{}, _q.predicates...), // clone intermediate query. - sql: dpq.sql.Clone(), - path: dpq.path, - modifiers: append([]func(*sql.Selector){}, dpq.modifiers...), + sql: _q.sql.Clone(), + path: _q.path, + modifiers: append([]func(*sql.Selector){}, _q.modifiers...), } } @@ -272,10 +272,10 @@ func (dpq *DBPackageQuery) Clone() *DBPackageQuery { // GroupBy(dbpackage.FieldPkgbase). // Aggregate(ent.Count()). // Scan(ctx, &v) -func (dpq *DBPackageQuery) GroupBy(field string, fields ...string) *DBPackageGroupBy { - dpq.ctx.Fields = append([]string{field}, fields...) - grbuild := &DBPackageGroupBy{build: dpq} - grbuild.flds = &dpq.ctx.Fields +func (_q *DBPackageQuery) GroupBy(field string, fields ...string) *DBPackageGroupBy { + _q.ctx.Fields = append([]string{field}, fields...) + grbuild := &DBPackageGroupBy{build: _q} + grbuild.flds = &_q.ctx.Fields grbuild.label = dbpackage.Label grbuild.scan = grbuild.Scan return grbuild @@ -293,65 +293,65 @@ func (dpq *DBPackageQuery) GroupBy(field string, fields ...string) *DBPackageGro // client.DBPackage.Query(). // Select(dbpackage.FieldPkgbase). // Scan(ctx, &v) -func (dpq *DBPackageQuery) Select(fields ...string) *DBPackageSelect { - dpq.ctx.Fields = append(dpq.ctx.Fields, fields...) - sbuild := &DBPackageSelect{DBPackageQuery: dpq} +func (_q *DBPackageQuery) Select(fields ...string) *DBPackageSelect { + _q.ctx.Fields = append(_q.ctx.Fields, fields...) + sbuild := &DBPackageSelect{DBPackageQuery: _q} sbuild.label = dbpackage.Label - sbuild.flds, sbuild.scan = &dpq.ctx.Fields, sbuild.Scan + sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan return sbuild } // Aggregate returns a DBPackageSelect configured with the given aggregations. -func (dpq *DBPackageQuery) Aggregate(fns ...AggregateFunc) *DBPackageSelect { - return dpq.Select().Aggregate(fns...) +func (_q *DBPackageQuery) Aggregate(fns ...AggregateFunc) *DBPackageSelect { + return _q.Select().Aggregate(fns...) } -func (dpq *DBPackageQuery) prepareQuery(ctx context.Context) error { - for _, inter := range dpq.inters { +func (_q *DBPackageQuery) prepareQuery(ctx context.Context) error { + for _, inter := range _q.inters { if inter == nil { return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)") } if trv, ok := inter.(Traverser); ok { - if err := trv.Traverse(ctx, dpq); err != nil { + if err := trv.Traverse(ctx, _q); err != nil { return err } } } - for _, f := range dpq.ctx.Fields { + for _, f := range _q.ctx.Fields { if !dbpackage.ValidColumn(f) { return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} } } - if dpq.path != nil { - prev, err := dpq.path(ctx) + if _q.path != nil { + prev, err := _q.path(ctx) if err != nil { return err } - dpq.sql = prev + _q.sql = prev } return nil } -func (dpq *DBPackageQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*DBPackage, error) { +func (_q *DBPackageQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*DBPackage, error) { var ( nodes = []*DBPackage{} - _spec = dpq.querySpec() + _spec = _q.querySpec() ) _spec.ScanValues = func(columns []string) ([]any, error) { return (*DBPackage).scanValues(nil, columns) } _spec.Assign = func(columns []string, values []any) error { - node := &DBPackage{config: dpq.config} + node := &DBPackage{config: _q.config} nodes = append(nodes, node) return node.assignValues(columns, values) } - if len(dpq.modifiers) > 0 { - _spec.Modifiers = dpq.modifiers + if len(_q.modifiers) > 0 { + _spec.Modifiers = _q.modifiers } for i := range hooks { hooks[i](ctx, _spec) } - if err := sqlgraph.QueryNodes(ctx, dpq.driver, _spec); err != nil { + if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil { return nil, err } if len(nodes) == 0 { @@ -360,27 +360,27 @@ func (dpq *DBPackageQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*D return nodes, nil } -func (dpq *DBPackageQuery) sqlCount(ctx context.Context) (int, error) { - _spec := dpq.querySpec() - if len(dpq.modifiers) > 0 { - _spec.Modifiers = dpq.modifiers +func (_q *DBPackageQuery) sqlCount(ctx context.Context) (int, error) { + _spec := _q.querySpec() + if len(_q.modifiers) > 0 { + _spec.Modifiers = _q.modifiers } - _spec.Node.Columns = dpq.ctx.Fields - if len(dpq.ctx.Fields) > 0 { - _spec.Unique = dpq.ctx.Unique != nil && *dpq.ctx.Unique + _spec.Node.Columns = _q.ctx.Fields + if len(_q.ctx.Fields) > 0 { + _spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique } - return sqlgraph.CountNodes(ctx, dpq.driver, _spec) + return sqlgraph.CountNodes(ctx, _q.driver, _spec) } -func (dpq *DBPackageQuery) querySpec() *sqlgraph.QuerySpec { +func (_q *DBPackageQuery) querySpec() *sqlgraph.QuerySpec { _spec := sqlgraph.NewQuerySpec(dbpackage.Table, dbpackage.Columns, sqlgraph.NewFieldSpec(dbpackage.FieldID, field.TypeInt)) - _spec.From = dpq.sql - if unique := dpq.ctx.Unique; unique != nil { + _spec.From = _q.sql + if unique := _q.ctx.Unique; unique != nil { _spec.Unique = *unique - } else if dpq.path != nil { + } else if _q.path != nil { _spec.Unique = true } - if fields := dpq.ctx.Fields; len(fields) > 0 { + if fields := _q.ctx.Fields; len(fields) > 0 { _spec.Node.Columns = make([]string, 0, len(fields)) _spec.Node.Columns = append(_spec.Node.Columns, dbpackage.FieldID) for i := range fields { @@ -389,20 +389,20 @@ func (dpq *DBPackageQuery) querySpec() *sqlgraph.QuerySpec { } } } - if ps := dpq.predicates; len(ps) > 0 { + if ps := _q.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { for i := range ps { ps[i](selector) } } } - if limit := dpq.ctx.Limit; limit != nil { + if limit := _q.ctx.Limit; limit != nil { _spec.Limit = *limit } - if offset := dpq.ctx.Offset; offset != nil { + if offset := _q.ctx.Offset; offset != nil { _spec.Offset = *offset } - if ps := dpq.order; len(ps) > 0 { + if ps := _q.order; len(ps) > 0 { _spec.Order = func(selector *sql.Selector) { for i := range ps { ps[i](selector) @@ -412,45 +412,45 @@ func (dpq *DBPackageQuery) querySpec() *sqlgraph.QuerySpec { return _spec } -func (dpq *DBPackageQuery) sqlQuery(ctx context.Context) *sql.Selector { - builder := sql.Dialect(dpq.driver.Dialect()) +func (_q *DBPackageQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(_q.driver.Dialect()) t1 := builder.Table(dbpackage.Table) - columns := dpq.ctx.Fields + columns := _q.ctx.Fields if len(columns) == 0 { columns = dbpackage.Columns } selector := builder.Select(t1.Columns(columns...)...).From(t1) - if dpq.sql != nil { - selector = dpq.sql + if _q.sql != nil { + selector = _q.sql selector.Select(selector.Columns(columns...)...) } - if dpq.ctx.Unique != nil && *dpq.ctx.Unique { + if _q.ctx.Unique != nil && *_q.ctx.Unique { selector.Distinct() } - for _, m := range dpq.modifiers { + for _, m := range _q.modifiers { m(selector) } - for _, p := range dpq.predicates { + for _, p := range _q.predicates { p(selector) } - for _, p := range dpq.order { + for _, p := range _q.order { p(selector) } - if offset := dpq.ctx.Offset; offset != nil { + if offset := _q.ctx.Offset; offset != nil { // limit is mandatory for offset clause. We start // with default value, and override it below if needed. selector.Offset(*offset).Limit(math.MaxInt32) } - if limit := dpq.ctx.Limit; limit != nil { + if limit := _q.ctx.Limit; limit != nil { selector.Limit(*limit) } return selector } // Modify adds a query modifier for attaching custom logic to queries. -func (dpq *DBPackageQuery) Modify(modifiers ...func(s *sql.Selector)) *DBPackageSelect { - dpq.modifiers = append(dpq.modifiers, modifiers...) - return dpq.Select() +func (_q *DBPackageQuery) Modify(modifiers ...func(s *sql.Selector)) *DBPackageSelect { + _q.modifiers = append(_q.modifiers, modifiers...) + return _q.Select() } // DBPackageGroupBy is the group-by builder for DBPackage entities. @@ -460,41 +460,41 @@ type DBPackageGroupBy struct { } // Aggregate adds the given aggregation functions to the group-by query. -func (dpgb *DBPackageGroupBy) Aggregate(fns ...AggregateFunc) *DBPackageGroupBy { - dpgb.fns = append(dpgb.fns, fns...) - return dpgb +func (_g *DBPackageGroupBy) Aggregate(fns ...AggregateFunc) *DBPackageGroupBy { + _g.fns = append(_g.fns, fns...) + return _g } // Scan applies the selector query and scans the result into the given value. -func (dpgb *DBPackageGroupBy) Scan(ctx context.Context, v any) error { - ctx = setContextOp(ctx, dpgb.build.ctx, ent.OpQueryGroupBy) - if err := dpgb.build.prepareQuery(ctx); err != nil { +func (_g *DBPackageGroupBy) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy) + if err := _g.build.prepareQuery(ctx); err != nil { return err } - return scanWithInterceptors[*DBPackageQuery, *DBPackageGroupBy](ctx, dpgb.build, dpgb, dpgb.build.inters, v) + return scanWithInterceptors[*DBPackageQuery, *DBPackageGroupBy](ctx, _g.build, _g, _g.build.inters, v) } -func (dpgb *DBPackageGroupBy) sqlScan(ctx context.Context, root *DBPackageQuery, v any) error { +func (_g *DBPackageGroupBy) sqlScan(ctx context.Context, root *DBPackageQuery, v any) error { selector := root.sqlQuery(ctx).Select() - aggregation := make([]string, 0, len(dpgb.fns)) - for _, fn := range dpgb.fns { + aggregation := make([]string, 0, len(_g.fns)) + for _, fn := range _g.fns { aggregation = append(aggregation, fn(selector)) } if len(selector.SelectedColumns()) == 0 { - columns := make([]string, 0, len(*dpgb.flds)+len(dpgb.fns)) - for _, f := range *dpgb.flds { + columns := make([]string, 0, len(*_g.flds)+len(_g.fns)) + for _, f := range *_g.flds { columns = append(columns, selector.C(f)) } columns = append(columns, aggregation...) selector.Select(columns...) } - selector.GroupBy(selector.Columns(*dpgb.flds...)...) + selector.GroupBy(selector.Columns(*_g.flds...)...) if err := selector.Err(); err != nil { return err } rows := &sql.Rows{} query, args := selector.Query() - if err := dpgb.build.driver.Query(ctx, query, args, rows); err != nil { + if err := _g.build.driver.Query(ctx, query, args, rows); err != nil { return err } defer rows.Close() @@ -508,27 +508,27 @@ type DBPackageSelect struct { } // Aggregate adds the given aggregation functions to the selector query. -func (dps *DBPackageSelect) Aggregate(fns ...AggregateFunc) *DBPackageSelect { - dps.fns = append(dps.fns, fns...) - return dps +func (_s *DBPackageSelect) Aggregate(fns ...AggregateFunc) *DBPackageSelect { + _s.fns = append(_s.fns, fns...) + return _s } // Scan applies the selector query and scans the result into the given value. -func (dps *DBPackageSelect) Scan(ctx context.Context, v any) error { - ctx = setContextOp(ctx, dps.ctx, ent.OpQuerySelect) - if err := dps.prepareQuery(ctx); err != nil { +func (_s *DBPackageSelect) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect) + if err := _s.prepareQuery(ctx); err != nil { return err } - return scanWithInterceptors[*DBPackageQuery, *DBPackageSelect](ctx, dps.DBPackageQuery, dps, dps.inters, v) + return scanWithInterceptors[*DBPackageQuery, *DBPackageSelect](ctx, _s.DBPackageQuery, _s, _s.inters, v) } -func (dps *DBPackageSelect) sqlScan(ctx context.Context, root *DBPackageQuery, v any) error { +func (_s *DBPackageSelect) sqlScan(ctx context.Context, root *DBPackageQuery, v any) error { selector := root.sqlQuery(ctx) - aggregation := make([]string, 0, len(dps.fns)) - for _, fn := range dps.fns { + aggregation := make([]string, 0, len(_s.fns)) + for _, fn := range _s.fns { aggregation = append(aggregation, fn(selector)) } - switch n := len(*dps.selector.flds); { + switch n := len(*_s.selector.flds); { case n == 0 && len(aggregation) > 0: selector.Select(aggregation...) case n != 0 && len(aggregation) > 0: @@ -536,7 +536,7 @@ func (dps *DBPackageSelect) sqlScan(ctx context.Context, root *DBPackageQuery, v } rows := &sql.Rows{} query, args := selector.Query() - if err := dps.driver.Query(ctx, query, args, rows); err != nil { + if err := _s.driver.Query(ctx, query, args, rows); err != nil { return err } defer rows.Close() @@ -544,7 +544,7 @@ func (dps *DBPackageSelect) sqlScan(ctx context.Context, root *DBPackageQuery, v } // Modify adds a query modifier for attaching custom logic to queries. -func (dps *DBPackageSelect) Modify(modifiers ...func(s *sql.Selector)) *DBPackageSelect { - dps.modifiers = append(dps.modifiers, modifiers...) - return dps +func (_s *DBPackageSelect) Modify(modifiers ...func(s *sql.Selector)) *DBPackageSelect { + _s.modifiers = append(_s.modifiers, modifiers...) + return _s } diff --git a/ent/dbpackage_update.go b/ent/dbpackage_update.go index 86ce219..66a6b05 100644 --- a/ent/dbpackage_update.go +++ b/ent/dbpackage_update.go @@ -25,411 +25,411 @@ type DBPackageUpdate struct { } // Where appends a list predicates to the DBPackageUpdate builder. -func (dpu *DBPackageUpdate) Where(ps ...predicate.DBPackage) *DBPackageUpdate { - dpu.mutation.Where(ps...) - return dpu +func (_u *DBPackageUpdate) Where(ps ...predicate.DBPackage) *DBPackageUpdate { + _u.mutation.Where(ps...) + return _u } // SetPackages sets the "packages" field. -func (dpu *DBPackageUpdate) SetPackages(s []string) *DBPackageUpdate { - dpu.mutation.SetPackages(s) - return dpu +func (_u *DBPackageUpdate) SetPackages(v []string) *DBPackageUpdate { + _u.mutation.SetPackages(v) + return _u } -// AppendPackages appends s to the "packages" field. -func (dpu *DBPackageUpdate) AppendPackages(s []string) *DBPackageUpdate { - dpu.mutation.AppendPackages(s) - return dpu +// AppendPackages appends value to the "packages" field. +func (_u *DBPackageUpdate) AppendPackages(v []string) *DBPackageUpdate { + _u.mutation.AppendPackages(v) + return _u } // ClearPackages clears the value of the "packages" field. -func (dpu *DBPackageUpdate) ClearPackages() *DBPackageUpdate { - dpu.mutation.ClearPackages() - return dpu +func (_u *DBPackageUpdate) ClearPackages() *DBPackageUpdate { + _u.mutation.ClearPackages() + return _u } // SetStatus sets the "status" field. -func (dpu *DBPackageUpdate) SetStatus(d dbpackage.Status) *DBPackageUpdate { - dpu.mutation.SetStatus(d) - return dpu +func (_u *DBPackageUpdate) SetStatus(v dbpackage.Status) *DBPackageUpdate { + _u.mutation.SetStatus(v) + return _u } // SetNillableStatus sets the "status" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableStatus(d *dbpackage.Status) *DBPackageUpdate { - if d != nil { - dpu.SetStatus(*d) +func (_u *DBPackageUpdate) SetNillableStatus(v *dbpackage.Status) *DBPackageUpdate { + if v != nil { + _u.SetStatus(*v) } - return dpu + return _u } // ClearStatus clears the value of the "status" field. -func (dpu *DBPackageUpdate) ClearStatus() *DBPackageUpdate { - dpu.mutation.ClearStatus() - return dpu +func (_u *DBPackageUpdate) ClearStatus() *DBPackageUpdate { + _u.mutation.ClearStatus() + return _u } // SetSkipReason sets the "skip_reason" field. -func (dpu *DBPackageUpdate) SetSkipReason(s string) *DBPackageUpdate { - dpu.mutation.SetSkipReason(s) - return dpu +func (_u *DBPackageUpdate) SetSkipReason(v string) *DBPackageUpdate { + _u.mutation.SetSkipReason(v) + return _u } // SetNillableSkipReason sets the "skip_reason" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableSkipReason(s *string) *DBPackageUpdate { - if s != nil { - dpu.SetSkipReason(*s) +func (_u *DBPackageUpdate) SetNillableSkipReason(v *string) *DBPackageUpdate { + if v != nil { + _u.SetSkipReason(*v) } - return dpu + return _u } // ClearSkipReason clears the value of the "skip_reason" field. -func (dpu *DBPackageUpdate) ClearSkipReason() *DBPackageUpdate { - dpu.mutation.ClearSkipReason() - return dpu +func (_u *DBPackageUpdate) ClearSkipReason() *DBPackageUpdate { + _u.mutation.ClearSkipReason() + return _u } // SetRepository sets the "repository" field. -func (dpu *DBPackageUpdate) SetRepository(d dbpackage.Repository) *DBPackageUpdate { - dpu.mutation.SetRepository(d) - return dpu +func (_u *DBPackageUpdate) SetRepository(v dbpackage.Repository) *DBPackageUpdate { + _u.mutation.SetRepository(v) + return _u } // SetNillableRepository sets the "repository" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableRepository(d *dbpackage.Repository) *DBPackageUpdate { - if d != nil { - dpu.SetRepository(*d) +func (_u *DBPackageUpdate) SetNillableRepository(v *dbpackage.Repository) *DBPackageUpdate { + if v != nil { + _u.SetRepository(*v) } - return dpu + return _u } // SetVersion sets the "version" field. -func (dpu *DBPackageUpdate) SetVersion(s string) *DBPackageUpdate { - dpu.mutation.SetVersion(s) - return dpu +func (_u *DBPackageUpdate) SetVersion(v string) *DBPackageUpdate { + _u.mutation.SetVersion(v) + return _u } // SetNillableVersion sets the "version" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableVersion(s *string) *DBPackageUpdate { - if s != nil { - dpu.SetVersion(*s) +func (_u *DBPackageUpdate) SetNillableVersion(v *string) *DBPackageUpdate { + if v != nil { + _u.SetVersion(*v) } - return dpu + return _u } // ClearVersion clears the value of the "version" field. -func (dpu *DBPackageUpdate) ClearVersion() *DBPackageUpdate { - dpu.mutation.ClearVersion() - return dpu +func (_u *DBPackageUpdate) ClearVersion() *DBPackageUpdate { + _u.mutation.ClearVersion() + return _u } // SetRepoVersion sets the "repo_version" field. -func (dpu *DBPackageUpdate) SetRepoVersion(s string) *DBPackageUpdate { - dpu.mutation.SetRepoVersion(s) - return dpu +func (_u *DBPackageUpdate) SetRepoVersion(v string) *DBPackageUpdate { + _u.mutation.SetRepoVersion(v) + return _u } // SetNillableRepoVersion sets the "repo_version" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableRepoVersion(s *string) *DBPackageUpdate { - if s != nil { - dpu.SetRepoVersion(*s) +func (_u *DBPackageUpdate) SetNillableRepoVersion(v *string) *DBPackageUpdate { + if v != nil { + _u.SetRepoVersion(*v) } - return dpu + return _u } // ClearRepoVersion clears the value of the "repo_version" field. -func (dpu *DBPackageUpdate) ClearRepoVersion() *DBPackageUpdate { - dpu.mutation.ClearRepoVersion() - return dpu +func (_u *DBPackageUpdate) ClearRepoVersion() *DBPackageUpdate { + _u.mutation.ClearRepoVersion() + return _u } // SetBuildTimeStart sets the "build_time_start" field. -func (dpu *DBPackageUpdate) SetBuildTimeStart(t time.Time) *DBPackageUpdate { - dpu.mutation.SetBuildTimeStart(t) - return dpu +func (_u *DBPackageUpdate) SetBuildTimeStart(v time.Time) *DBPackageUpdate { + _u.mutation.SetBuildTimeStart(v) + return _u } // SetNillableBuildTimeStart sets the "build_time_start" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableBuildTimeStart(t *time.Time) *DBPackageUpdate { - if t != nil { - dpu.SetBuildTimeStart(*t) +func (_u *DBPackageUpdate) SetNillableBuildTimeStart(v *time.Time) *DBPackageUpdate { + if v != nil { + _u.SetBuildTimeStart(*v) } - return dpu + return _u } // ClearBuildTimeStart clears the value of the "build_time_start" field. -func (dpu *DBPackageUpdate) ClearBuildTimeStart() *DBPackageUpdate { - dpu.mutation.ClearBuildTimeStart() - return dpu +func (_u *DBPackageUpdate) ClearBuildTimeStart() *DBPackageUpdate { + _u.mutation.ClearBuildTimeStart() + return _u } // SetUpdated sets the "updated" field. -func (dpu *DBPackageUpdate) SetUpdated(t time.Time) *DBPackageUpdate { - dpu.mutation.SetUpdated(t) - return dpu +func (_u *DBPackageUpdate) SetUpdated(v time.Time) *DBPackageUpdate { + _u.mutation.SetUpdated(v) + return _u } // SetNillableUpdated sets the "updated" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableUpdated(t *time.Time) *DBPackageUpdate { - if t != nil { - dpu.SetUpdated(*t) +func (_u *DBPackageUpdate) SetNillableUpdated(v *time.Time) *DBPackageUpdate { + if v != nil { + _u.SetUpdated(*v) } - return dpu + return _u } // ClearUpdated clears the value of the "updated" field. -func (dpu *DBPackageUpdate) ClearUpdated() *DBPackageUpdate { - dpu.mutation.ClearUpdated() - return dpu +func (_u *DBPackageUpdate) ClearUpdated() *DBPackageUpdate { + _u.mutation.ClearUpdated() + return _u } // SetLto sets the "lto" field. -func (dpu *DBPackageUpdate) SetLto(d dbpackage.Lto) *DBPackageUpdate { - dpu.mutation.SetLto(d) - return dpu +func (_u *DBPackageUpdate) SetLto(v dbpackage.Lto) *DBPackageUpdate { + _u.mutation.SetLto(v) + return _u } // SetNillableLto sets the "lto" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableLto(d *dbpackage.Lto) *DBPackageUpdate { - if d != nil { - dpu.SetLto(*d) +func (_u *DBPackageUpdate) SetNillableLto(v *dbpackage.Lto) *DBPackageUpdate { + if v != nil { + _u.SetLto(*v) } - return dpu + return _u } // ClearLto clears the value of the "lto" field. -func (dpu *DBPackageUpdate) ClearLto() *DBPackageUpdate { - dpu.mutation.ClearLto() - return dpu +func (_u *DBPackageUpdate) ClearLto() *DBPackageUpdate { + _u.mutation.ClearLto() + return _u } // SetLastVersionBuild sets the "last_version_build" field. -func (dpu *DBPackageUpdate) SetLastVersionBuild(s string) *DBPackageUpdate { - dpu.mutation.SetLastVersionBuild(s) - return dpu +func (_u *DBPackageUpdate) SetLastVersionBuild(v string) *DBPackageUpdate { + _u.mutation.SetLastVersionBuild(v) + return _u } // SetNillableLastVersionBuild sets the "last_version_build" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableLastVersionBuild(s *string) *DBPackageUpdate { - if s != nil { - dpu.SetLastVersionBuild(*s) +func (_u *DBPackageUpdate) SetNillableLastVersionBuild(v *string) *DBPackageUpdate { + if v != nil { + _u.SetLastVersionBuild(*v) } - return dpu + return _u } // ClearLastVersionBuild clears the value of the "last_version_build" field. -func (dpu *DBPackageUpdate) ClearLastVersionBuild() *DBPackageUpdate { - dpu.mutation.ClearLastVersionBuild() - return dpu +func (_u *DBPackageUpdate) ClearLastVersionBuild() *DBPackageUpdate { + _u.mutation.ClearLastVersionBuild() + return _u } // SetLastVerified sets the "last_verified" field. -func (dpu *DBPackageUpdate) SetLastVerified(t time.Time) *DBPackageUpdate { - dpu.mutation.SetLastVerified(t) - return dpu +func (_u *DBPackageUpdate) SetLastVerified(v time.Time) *DBPackageUpdate { + _u.mutation.SetLastVerified(v) + return _u } // SetNillableLastVerified sets the "last_verified" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableLastVerified(t *time.Time) *DBPackageUpdate { - if t != nil { - dpu.SetLastVerified(*t) +func (_u *DBPackageUpdate) SetNillableLastVerified(v *time.Time) *DBPackageUpdate { + if v != nil { + _u.SetLastVerified(*v) } - return dpu + return _u } // ClearLastVerified clears the value of the "last_verified" field. -func (dpu *DBPackageUpdate) ClearLastVerified() *DBPackageUpdate { - dpu.mutation.ClearLastVerified() - return dpu +func (_u *DBPackageUpdate) ClearLastVerified() *DBPackageUpdate { + _u.mutation.ClearLastVerified() + return _u } // SetDebugSymbols sets the "debug_symbols" field. -func (dpu *DBPackageUpdate) SetDebugSymbols(ds dbpackage.DebugSymbols) *DBPackageUpdate { - dpu.mutation.SetDebugSymbols(ds) - return dpu +func (_u *DBPackageUpdate) SetDebugSymbols(v dbpackage.DebugSymbols) *DBPackageUpdate { + _u.mutation.SetDebugSymbols(v) + return _u } // SetNillableDebugSymbols sets the "debug_symbols" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableDebugSymbols(ds *dbpackage.DebugSymbols) *DBPackageUpdate { - if ds != nil { - dpu.SetDebugSymbols(*ds) +func (_u *DBPackageUpdate) SetNillableDebugSymbols(v *dbpackage.DebugSymbols) *DBPackageUpdate { + if v != nil { + _u.SetDebugSymbols(*v) } - return dpu + return _u } // ClearDebugSymbols clears the value of the "debug_symbols" field. -func (dpu *DBPackageUpdate) ClearDebugSymbols() *DBPackageUpdate { - dpu.mutation.ClearDebugSymbols() - return dpu +func (_u *DBPackageUpdate) ClearDebugSymbols() *DBPackageUpdate { + _u.mutation.ClearDebugSymbols() + return _u } // SetMaxRss sets the "max_rss" field. -func (dpu *DBPackageUpdate) SetMaxRss(i int64) *DBPackageUpdate { - dpu.mutation.ResetMaxRss() - dpu.mutation.SetMaxRss(i) - return dpu +func (_u *DBPackageUpdate) SetMaxRss(v int64) *DBPackageUpdate { + _u.mutation.ResetMaxRss() + _u.mutation.SetMaxRss(v) + return _u } // SetNillableMaxRss sets the "max_rss" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableMaxRss(i *int64) *DBPackageUpdate { - if i != nil { - dpu.SetMaxRss(*i) +func (_u *DBPackageUpdate) SetNillableMaxRss(v *int64) *DBPackageUpdate { + if v != nil { + _u.SetMaxRss(*v) } - return dpu + return _u } -// AddMaxRss adds i to the "max_rss" field. -func (dpu *DBPackageUpdate) AddMaxRss(i int64) *DBPackageUpdate { - dpu.mutation.AddMaxRss(i) - return dpu +// AddMaxRss adds value to the "max_rss" field. +func (_u *DBPackageUpdate) AddMaxRss(v int64) *DBPackageUpdate { + _u.mutation.AddMaxRss(v) + return _u } // ClearMaxRss clears the value of the "max_rss" field. -func (dpu *DBPackageUpdate) ClearMaxRss() *DBPackageUpdate { - dpu.mutation.ClearMaxRss() - return dpu +func (_u *DBPackageUpdate) ClearMaxRss() *DBPackageUpdate { + _u.mutation.ClearMaxRss() + return _u } // SetUTime sets the "u_time" field. -func (dpu *DBPackageUpdate) SetUTime(i int64) *DBPackageUpdate { - dpu.mutation.ResetUTime() - dpu.mutation.SetUTime(i) - return dpu +func (_u *DBPackageUpdate) SetUTime(v int64) *DBPackageUpdate { + _u.mutation.ResetUTime() + _u.mutation.SetUTime(v) + return _u } // SetNillableUTime sets the "u_time" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableUTime(i *int64) *DBPackageUpdate { - if i != nil { - dpu.SetUTime(*i) +func (_u *DBPackageUpdate) SetNillableUTime(v *int64) *DBPackageUpdate { + if v != nil { + _u.SetUTime(*v) } - return dpu + return _u } -// AddUTime adds i to the "u_time" field. -func (dpu *DBPackageUpdate) AddUTime(i int64) *DBPackageUpdate { - dpu.mutation.AddUTime(i) - return dpu +// AddUTime adds value to the "u_time" field. +func (_u *DBPackageUpdate) AddUTime(v int64) *DBPackageUpdate { + _u.mutation.AddUTime(v) + return _u } // ClearUTime clears the value of the "u_time" field. -func (dpu *DBPackageUpdate) ClearUTime() *DBPackageUpdate { - dpu.mutation.ClearUTime() - return dpu +func (_u *DBPackageUpdate) ClearUTime() *DBPackageUpdate { + _u.mutation.ClearUTime() + return _u } // SetSTime sets the "s_time" field. -func (dpu *DBPackageUpdate) SetSTime(i int64) *DBPackageUpdate { - dpu.mutation.ResetSTime() - dpu.mutation.SetSTime(i) - return dpu +func (_u *DBPackageUpdate) SetSTime(v int64) *DBPackageUpdate { + _u.mutation.ResetSTime() + _u.mutation.SetSTime(v) + return _u } // SetNillableSTime sets the "s_time" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableSTime(i *int64) *DBPackageUpdate { - if i != nil { - dpu.SetSTime(*i) +func (_u *DBPackageUpdate) SetNillableSTime(v *int64) *DBPackageUpdate { + if v != nil { + _u.SetSTime(*v) } - return dpu + return _u } -// AddSTime adds i to the "s_time" field. -func (dpu *DBPackageUpdate) AddSTime(i int64) *DBPackageUpdate { - dpu.mutation.AddSTime(i) - return dpu +// AddSTime adds value to the "s_time" field. +func (_u *DBPackageUpdate) AddSTime(v int64) *DBPackageUpdate { + _u.mutation.AddSTime(v) + return _u } // ClearSTime clears the value of the "s_time" field. -func (dpu *DBPackageUpdate) ClearSTime() *DBPackageUpdate { - dpu.mutation.ClearSTime() - return dpu +func (_u *DBPackageUpdate) ClearSTime() *DBPackageUpdate { + _u.mutation.ClearSTime() + return _u } // SetIoIn sets the "io_in" field. -func (dpu *DBPackageUpdate) SetIoIn(i int64) *DBPackageUpdate { - dpu.mutation.ResetIoIn() - dpu.mutation.SetIoIn(i) - return dpu +func (_u *DBPackageUpdate) SetIoIn(v int64) *DBPackageUpdate { + _u.mutation.ResetIoIn() + _u.mutation.SetIoIn(v) + return _u } // SetNillableIoIn sets the "io_in" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableIoIn(i *int64) *DBPackageUpdate { - if i != nil { - dpu.SetIoIn(*i) +func (_u *DBPackageUpdate) SetNillableIoIn(v *int64) *DBPackageUpdate { + if v != nil { + _u.SetIoIn(*v) } - return dpu + return _u } -// AddIoIn adds i to the "io_in" field. -func (dpu *DBPackageUpdate) AddIoIn(i int64) *DBPackageUpdate { - dpu.mutation.AddIoIn(i) - return dpu +// AddIoIn adds value to the "io_in" field. +func (_u *DBPackageUpdate) AddIoIn(v int64) *DBPackageUpdate { + _u.mutation.AddIoIn(v) + return _u } // ClearIoIn clears the value of the "io_in" field. -func (dpu *DBPackageUpdate) ClearIoIn() *DBPackageUpdate { - dpu.mutation.ClearIoIn() - return dpu +func (_u *DBPackageUpdate) ClearIoIn() *DBPackageUpdate { + _u.mutation.ClearIoIn() + return _u } // SetIoOut sets the "io_out" field. -func (dpu *DBPackageUpdate) SetIoOut(i int64) *DBPackageUpdate { - dpu.mutation.ResetIoOut() - dpu.mutation.SetIoOut(i) - return dpu +func (_u *DBPackageUpdate) SetIoOut(v int64) *DBPackageUpdate { + _u.mutation.ResetIoOut() + _u.mutation.SetIoOut(v) + return _u } // SetNillableIoOut sets the "io_out" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableIoOut(i *int64) *DBPackageUpdate { - if i != nil { - dpu.SetIoOut(*i) +func (_u *DBPackageUpdate) SetNillableIoOut(v *int64) *DBPackageUpdate { + if v != nil { + _u.SetIoOut(*v) } - return dpu + return _u } -// AddIoOut adds i to the "io_out" field. -func (dpu *DBPackageUpdate) AddIoOut(i int64) *DBPackageUpdate { - dpu.mutation.AddIoOut(i) - return dpu +// AddIoOut adds value to the "io_out" field. +func (_u *DBPackageUpdate) AddIoOut(v int64) *DBPackageUpdate { + _u.mutation.AddIoOut(v) + return _u } // ClearIoOut clears the value of the "io_out" field. -func (dpu *DBPackageUpdate) ClearIoOut() *DBPackageUpdate { - dpu.mutation.ClearIoOut() - return dpu +func (_u *DBPackageUpdate) ClearIoOut() *DBPackageUpdate { + _u.mutation.ClearIoOut() + return _u } // SetTagRev sets the "tag_rev" field. -func (dpu *DBPackageUpdate) SetTagRev(s string) *DBPackageUpdate { - dpu.mutation.SetTagRev(s) - return dpu +func (_u *DBPackageUpdate) SetTagRev(v string) *DBPackageUpdate { + _u.mutation.SetTagRev(v) + return _u } // SetNillableTagRev sets the "tag_rev" field if the given value is not nil. -func (dpu *DBPackageUpdate) SetNillableTagRev(s *string) *DBPackageUpdate { - if s != nil { - dpu.SetTagRev(*s) +func (_u *DBPackageUpdate) SetNillableTagRev(v *string) *DBPackageUpdate { + if v != nil { + _u.SetTagRev(*v) } - return dpu + return _u } // ClearTagRev clears the value of the "tag_rev" field. -func (dpu *DBPackageUpdate) ClearTagRev() *DBPackageUpdate { - dpu.mutation.ClearTagRev() - return dpu +func (_u *DBPackageUpdate) ClearTagRev() *DBPackageUpdate { + _u.mutation.ClearTagRev() + return _u } // Mutation returns the DBPackageMutation object of the builder. -func (dpu *DBPackageUpdate) Mutation() *DBPackageMutation { - return dpu.mutation +func (_u *DBPackageUpdate) Mutation() *DBPackageMutation { + return _u.mutation } // Save executes the query and returns the number of nodes affected by the update operation. -func (dpu *DBPackageUpdate) Save(ctx context.Context) (int, error) { - return withHooks(ctx, dpu.sqlSave, dpu.mutation, dpu.hooks) +func (_u *DBPackageUpdate) Save(ctx context.Context) (int, error) { + return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks) } // SaveX is like Save, but panics if an error occurs. -func (dpu *DBPackageUpdate) SaveX(ctx context.Context) int { - affected, err := dpu.Save(ctx) +func (_u *DBPackageUpdate) SaveX(ctx context.Context) int { + affected, err := _u.Save(ctx) if err != nil { panic(err) } @@ -437,36 +437,36 @@ func (dpu *DBPackageUpdate) SaveX(ctx context.Context) int { } // Exec executes the query. -func (dpu *DBPackageUpdate) Exec(ctx context.Context) error { - _, err := dpu.Save(ctx) +func (_u *DBPackageUpdate) Exec(ctx context.Context) error { + _, err := _u.Save(ctx) return err } // ExecX is like Exec, but panics if an error occurs. -func (dpu *DBPackageUpdate) ExecX(ctx context.Context) { - if err := dpu.Exec(ctx); err != nil { +func (_u *DBPackageUpdate) ExecX(ctx context.Context) { + if err := _u.Exec(ctx); err != nil { panic(err) } } // check runs all checks and user-defined validators on the builder. -func (dpu *DBPackageUpdate) check() error { - if v, ok := dpu.mutation.Status(); ok { +func (_u *DBPackageUpdate) check() error { + if v, ok := _u.mutation.Status(); ok { if err := dbpackage.StatusValidator(v); err != nil { return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "DBPackage.status": %w`, err)} } } - if v, ok := dpu.mutation.Repository(); ok { + if v, ok := _u.mutation.Repository(); ok { if err := dbpackage.RepositoryValidator(v); err != nil { return &ValidationError{Name: "repository", err: fmt.Errorf(`ent: validator failed for field "DBPackage.repository": %w`, err)} } } - if v, ok := dpu.mutation.Lto(); ok { + if v, ok := _u.mutation.Lto(); ok { if err := dbpackage.LtoValidator(v); err != nil { return &ValidationError{Name: "lto", err: fmt.Errorf(`ent: validator failed for field "DBPackage.lto": %w`, err)} } } - if v, ok := dpu.mutation.DebugSymbols(); ok { + if v, ok := _u.mutation.DebugSymbols(); ok { if err := dbpackage.DebugSymbolsValidator(v); err != nil { return &ValidationError{Name: "debug_symbols", err: fmt.Errorf(`ent: validator failed for field "DBPackage.debug_symbols": %w`, err)} } @@ -475,150 +475,150 @@ func (dpu *DBPackageUpdate) check() error { } // Modify adds a statement modifier for attaching custom logic to the UPDATE statement. -func (dpu *DBPackageUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *DBPackageUpdate { - dpu.modifiers = append(dpu.modifiers, modifiers...) - return dpu +func (_u *DBPackageUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *DBPackageUpdate { + _u.modifiers = append(_u.modifiers, modifiers...) + return _u } -func (dpu *DBPackageUpdate) sqlSave(ctx context.Context) (n int, err error) { - if err := dpu.check(); err != nil { - return n, err +func (_u *DBPackageUpdate) sqlSave(ctx context.Context) (_node int, err error) { + if err := _u.check(); err != nil { + return _node, err } _spec := sqlgraph.NewUpdateSpec(dbpackage.Table, dbpackage.Columns, sqlgraph.NewFieldSpec(dbpackage.FieldID, field.TypeInt)) - if ps := dpu.mutation.predicates; len(ps) > 0 { + if ps := _u.mutation.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { for i := range ps { ps[i](selector) } } } - if value, ok := dpu.mutation.Packages(); ok { + if value, ok := _u.mutation.Packages(); ok { _spec.SetField(dbpackage.FieldPackages, field.TypeJSON, value) } - if value, ok := dpu.mutation.AppendedPackages(); ok { + if value, ok := _u.mutation.AppendedPackages(); ok { _spec.AddModifier(func(u *sql.UpdateBuilder) { sqljson.Append(u, dbpackage.FieldPackages, value) }) } - if dpu.mutation.PackagesCleared() { + if _u.mutation.PackagesCleared() { _spec.ClearField(dbpackage.FieldPackages, field.TypeJSON) } - if value, ok := dpu.mutation.Status(); ok { + if value, ok := _u.mutation.Status(); ok { _spec.SetField(dbpackage.FieldStatus, field.TypeEnum, value) } - if dpu.mutation.StatusCleared() { + if _u.mutation.StatusCleared() { _spec.ClearField(dbpackage.FieldStatus, field.TypeEnum) } - if value, ok := dpu.mutation.SkipReason(); ok { + if value, ok := _u.mutation.SkipReason(); ok { _spec.SetField(dbpackage.FieldSkipReason, field.TypeString, value) } - if dpu.mutation.SkipReasonCleared() { + if _u.mutation.SkipReasonCleared() { _spec.ClearField(dbpackage.FieldSkipReason, field.TypeString) } - if value, ok := dpu.mutation.Repository(); ok { + if value, ok := _u.mutation.Repository(); ok { _spec.SetField(dbpackage.FieldRepository, field.TypeEnum, value) } - if value, ok := dpu.mutation.Version(); ok { + if value, ok := _u.mutation.Version(); ok { _spec.SetField(dbpackage.FieldVersion, field.TypeString, value) } - if dpu.mutation.VersionCleared() { + if _u.mutation.VersionCleared() { _spec.ClearField(dbpackage.FieldVersion, field.TypeString) } - if value, ok := dpu.mutation.RepoVersion(); ok { + if value, ok := _u.mutation.RepoVersion(); ok { _spec.SetField(dbpackage.FieldRepoVersion, field.TypeString, value) } - if dpu.mutation.RepoVersionCleared() { + if _u.mutation.RepoVersionCleared() { _spec.ClearField(dbpackage.FieldRepoVersion, field.TypeString) } - if value, ok := dpu.mutation.BuildTimeStart(); ok { + if value, ok := _u.mutation.BuildTimeStart(); ok { _spec.SetField(dbpackage.FieldBuildTimeStart, field.TypeTime, value) } - if dpu.mutation.BuildTimeStartCleared() { + if _u.mutation.BuildTimeStartCleared() { _spec.ClearField(dbpackage.FieldBuildTimeStart, field.TypeTime) } - if value, ok := dpu.mutation.Updated(); ok { + if value, ok := _u.mutation.Updated(); ok { _spec.SetField(dbpackage.FieldUpdated, field.TypeTime, value) } - if dpu.mutation.UpdatedCleared() { + if _u.mutation.UpdatedCleared() { _spec.ClearField(dbpackage.FieldUpdated, field.TypeTime) } - if value, ok := dpu.mutation.Lto(); ok { + if value, ok := _u.mutation.Lto(); ok { _spec.SetField(dbpackage.FieldLto, field.TypeEnum, value) } - if dpu.mutation.LtoCleared() { + if _u.mutation.LtoCleared() { _spec.ClearField(dbpackage.FieldLto, field.TypeEnum) } - if value, ok := dpu.mutation.LastVersionBuild(); ok { + if value, ok := _u.mutation.LastVersionBuild(); ok { _spec.SetField(dbpackage.FieldLastVersionBuild, field.TypeString, value) } - if dpu.mutation.LastVersionBuildCleared() { + if _u.mutation.LastVersionBuildCleared() { _spec.ClearField(dbpackage.FieldLastVersionBuild, field.TypeString) } - if value, ok := dpu.mutation.LastVerified(); ok { + if value, ok := _u.mutation.LastVerified(); ok { _spec.SetField(dbpackage.FieldLastVerified, field.TypeTime, value) } - if dpu.mutation.LastVerifiedCleared() { + if _u.mutation.LastVerifiedCleared() { _spec.ClearField(dbpackage.FieldLastVerified, field.TypeTime) } - if value, ok := dpu.mutation.DebugSymbols(); ok { + if value, ok := _u.mutation.DebugSymbols(); ok { _spec.SetField(dbpackage.FieldDebugSymbols, field.TypeEnum, value) } - if dpu.mutation.DebugSymbolsCleared() { + if _u.mutation.DebugSymbolsCleared() { _spec.ClearField(dbpackage.FieldDebugSymbols, field.TypeEnum) } - if value, ok := dpu.mutation.MaxRss(); ok { + if value, ok := _u.mutation.MaxRss(); ok { _spec.SetField(dbpackage.FieldMaxRss, field.TypeInt64, value) } - if value, ok := dpu.mutation.AddedMaxRss(); ok { + if value, ok := _u.mutation.AddedMaxRss(); ok { _spec.AddField(dbpackage.FieldMaxRss, field.TypeInt64, value) } - if dpu.mutation.MaxRssCleared() { + if _u.mutation.MaxRssCleared() { _spec.ClearField(dbpackage.FieldMaxRss, field.TypeInt64) } - if value, ok := dpu.mutation.UTime(); ok { + if value, ok := _u.mutation.UTime(); ok { _spec.SetField(dbpackage.FieldUTime, field.TypeInt64, value) } - if value, ok := dpu.mutation.AddedUTime(); ok { + if value, ok := _u.mutation.AddedUTime(); ok { _spec.AddField(dbpackage.FieldUTime, field.TypeInt64, value) } - if dpu.mutation.UTimeCleared() { + if _u.mutation.UTimeCleared() { _spec.ClearField(dbpackage.FieldUTime, field.TypeInt64) } - if value, ok := dpu.mutation.STime(); ok { + if value, ok := _u.mutation.STime(); ok { _spec.SetField(dbpackage.FieldSTime, field.TypeInt64, value) } - if value, ok := dpu.mutation.AddedSTime(); ok { + if value, ok := _u.mutation.AddedSTime(); ok { _spec.AddField(dbpackage.FieldSTime, field.TypeInt64, value) } - if dpu.mutation.STimeCleared() { + if _u.mutation.STimeCleared() { _spec.ClearField(dbpackage.FieldSTime, field.TypeInt64) } - if value, ok := dpu.mutation.IoIn(); ok { + if value, ok := _u.mutation.IoIn(); ok { _spec.SetField(dbpackage.FieldIoIn, field.TypeInt64, value) } - if value, ok := dpu.mutation.AddedIoIn(); ok { + if value, ok := _u.mutation.AddedIoIn(); ok { _spec.AddField(dbpackage.FieldIoIn, field.TypeInt64, value) } - if dpu.mutation.IoInCleared() { + if _u.mutation.IoInCleared() { _spec.ClearField(dbpackage.FieldIoIn, field.TypeInt64) } - if value, ok := dpu.mutation.IoOut(); ok { + if value, ok := _u.mutation.IoOut(); ok { _spec.SetField(dbpackage.FieldIoOut, field.TypeInt64, value) } - if value, ok := dpu.mutation.AddedIoOut(); ok { + if value, ok := _u.mutation.AddedIoOut(); ok { _spec.AddField(dbpackage.FieldIoOut, field.TypeInt64, value) } - if dpu.mutation.IoOutCleared() { + if _u.mutation.IoOutCleared() { _spec.ClearField(dbpackage.FieldIoOut, field.TypeInt64) } - if value, ok := dpu.mutation.TagRev(); ok { + if value, ok := _u.mutation.TagRev(); ok { _spec.SetField(dbpackage.FieldTagRev, field.TypeString, value) } - if dpu.mutation.TagRevCleared() { + if _u.mutation.TagRevCleared() { _spec.ClearField(dbpackage.FieldTagRev, field.TypeString) } - _spec.AddModifiers(dpu.modifiers...) - if n, err = sqlgraph.UpdateNodes(ctx, dpu.driver, _spec); err != nil { + _spec.AddModifiers(_u.modifiers...) + if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{dbpackage.Label} } else if sqlgraph.IsConstraintError(err) { @@ -626,8 +626,8 @@ func (dpu *DBPackageUpdate) sqlSave(ctx context.Context) (n int, err error) { } return 0, err } - dpu.mutation.done = true - return n, nil + _u.mutation.done = true + return _node, nil } // DBPackageUpdateOne is the builder for updating a single DBPackage entity. @@ -640,418 +640,418 @@ type DBPackageUpdateOne struct { } // SetPackages sets the "packages" field. -func (dpuo *DBPackageUpdateOne) SetPackages(s []string) *DBPackageUpdateOne { - dpuo.mutation.SetPackages(s) - return dpuo +func (_u *DBPackageUpdateOne) SetPackages(v []string) *DBPackageUpdateOne { + _u.mutation.SetPackages(v) + return _u } -// AppendPackages appends s to the "packages" field. -func (dpuo *DBPackageUpdateOne) AppendPackages(s []string) *DBPackageUpdateOne { - dpuo.mutation.AppendPackages(s) - return dpuo +// AppendPackages appends value to the "packages" field. +func (_u *DBPackageUpdateOne) AppendPackages(v []string) *DBPackageUpdateOne { + _u.mutation.AppendPackages(v) + return _u } // ClearPackages clears the value of the "packages" field. -func (dpuo *DBPackageUpdateOne) ClearPackages() *DBPackageUpdateOne { - dpuo.mutation.ClearPackages() - return dpuo +func (_u *DBPackageUpdateOne) ClearPackages() *DBPackageUpdateOne { + _u.mutation.ClearPackages() + return _u } // SetStatus sets the "status" field. -func (dpuo *DBPackageUpdateOne) SetStatus(d dbpackage.Status) *DBPackageUpdateOne { - dpuo.mutation.SetStatus(d) - return dpuo +func (_u *DBPackageUpdateOne) SetStatus(v dbpackage.Status) *DBPackageUpdateOne { + _u.mutation.SetStatus(v) + return _u } // SetNillableStatus sets the "status" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableStatus(d *dbpackage.Status) *DBPackageUpdateOne { - if d != nil { - dpuo.SetStatus(*d) +func (_u *DBPackageUpdateOne) SetNillableStatus(v *dbpackage.Status) *DBPackageUpdateOne { + if v != nil { + _u.SetStatus(*v) } - return dpuo + return _u } // ClearStatus clears the value of the "status" field. -func (dpuo *DBPackageUpdateOne) ClearStatus() *DBPackageUpdateOne { - dpuo.mutation.ClearStatus() - return dpuo +func (_u *DBPackageUpdateOne) ClearStatus() *DBPackageUpdateOne { + _u.mutation.ClearStatus() + return _u } // SetSkipReason sets the "skip_reason" field. -func (dpuo *DBPackageUpdateOne) SetSkipReason(s string) *DBPackageUpdateOne { - dpuo.mutation.SetSkipReason(s) - return dpuo +func (_u *DBPackageUpdateOne) SetSkipReason(v string) *DBPackageUpdateOne { + _u.mutation.SetSkipReason(v) + return _u } // SetNillableSkipReason sets the "skip_reason" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableSkipReason(s *string) *DBPackageUpdateOne { - if s != nil { - dpuo.SetSkipReason(*s) +func (_u *DBPackageUpdateOne) SetNillableSkipReason(v *string) *DBPackageUpdateOne { + if v != nil { + _u.SetSkipReason(*v) } - return dpuo + return _u } // ClearSkipReason clears the value of the "skip_reason" field. -func (dpuo *DBPackageUpdateOne) ClearSkipReason() *DBPackageUpdateOne { - dpuo.mutation.ClearSkipReason() - return dpuo +func (_u *DBPackageUpdateOne) ClearSkipReason() *DBPackageUpdateOne { + _u.mutation.ClearSkipReason() + return _u } // SetRepository sets the "repository" field. -func (dpuo *DBPackageUpdateOne) SetRepository(d dbpackage.Repository) *DBPackageUpdateOne { - dpuo.mutation.SetRepository(d) - return dpuo +func (_u *DBPackageUpdateOne) SetRepository(v dbpackage.Repository) *DBPackageUpdateOne { + _u.mutation.SetRepository(v) + return _u } // SetNillableRepository sets the "repository" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableRepository(d *dbpackage.Repository) *DBPackageUpdateOne { - if d != nil { - dpuo.SetRepository(*d) +func (_u *DBPackageUpdateOne) SetNillableRepository(v *dbpackage.Repository) *DBPackageUpdateOne { + if v != nil { + _u.SetRepository(*v) } - return dpuo + return _u } // SetVersion sets the "version" field. -func (dpuo *DBPackageUpdateOne) SetVersion(s string) *DBPackageUpdateOne { - dpuo.mutation.SetVersion(s) - return dpuo +func (_u *DBPackageUpdateOne) SetVersion(v string) *DBPackageUpdateOne { + _u.mutation.SetVersion(v) + return _u } // SetNillableVersion sets the "version" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableVersion(s *string) *DBPackageUpdateOne { - if s != nil { - dpuo.SetVersion(*s) +func (_u *DBPackageUpdateOne) SetNillableVersion(v *string) *DBPackageUpdateOne { + if v != nil { + _u.SetVersion(*v) } - return dpuo + return _u } // ClearVersion clears the value of the "version" field. -func (dpuo *DBPackageUpdateOne) ClearVersion() *DBPackageUpdateOne { - dpuo.mutation.ClearVersion() - return dpuo +func (_u *DBPackageUpdateOne) ClearVersion() *DBPackageUpdateOne { + _u.mutation.ClearVersion() + return _u } // SetRepoVersion sets the "repo_version" field. -func (dpuo *DBPackageUpdateOne) SetRepoVersion(s string) *DBPackageUpdateOne { - dpuo.mutation.SetRepoVersion(s) - return dpuo +func (_u *DBPackageUpdateOne) SetRepoVersion(v string) *DBPackageUpdateOne { + _u.mutation.SetRepoVersion(v) + return _u } // SetNillableRepoVersion sets the "repo_version" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableRepoVersion(s *string) *DBPackageUpdateOne { - if s != nil { - dpuo.SetRepoVersion(*s) +func (_u *DBPackageUpdateOne) SetNillableRepoVersion(v *string) *DBPackageUpdateOne { + if v != nil { + _u.SetRepoVersion(*v) } - return dpuo + return _u } // ClearRepoVersion clears the value of the "repo_version" field. -func (dpuo *DBPackageUpdateOne) ClearRepoVersion() *DBPackageUpdateOne { - dpuo.mutation.ClearRepoVersion() - return dpuo +func (_u *DBPackageUpdateOne) ClearRepoVersion() *DBPackageUpdateOne { + _u.mutation.ClearRepoVersion() + return _u } // SetBuildTimeStart sets the "build_time_start" field. -func (dpuo *DBPackageUpdateOne) SetBuildTimeStart(t time.Time) *DBPackageUpdateOne { - dpuo.mutation.SetBuildTimeStart(t) - return dpuo +func (_u *DBPackageUpdateOne) SetBuildTimeStart(v time.Time) *DBPackageUpdateOne { + _u.mutation.SetBuildTimeStart(v) + return _u } // SetNillableBuildTimeStart sets the "build_time_start" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableBuildTimeStart(t *time.Time) *DBPackageUpdateOne { - if t != nil { - dpuo.SetBuildTimeStart(*t) +func (_u *DBPackageUpdateOne) SetNillableBuildTimeStart(v *time.Time) *DBPackageUpdateOne { + if v != nil { + _u.SetBuildTimeStart(*v) } - return dpuo + return _u } // ClearBuildTimeStart clears the value of the "build_time_start" field. -func (dpuo *DBPackageUpdateOne) ClearBuildTimeStart() *DBPackageUpdateOne { - dpuo.mutation.ClearBuildTimeStart() - return dpuo +func (_u *DBPackageUpdateOne) ClearBuildTimeStart() *DBPackageUpdateOne { + _u.mutation.ClearBuildTimeStart() + return _u } // SetUpdated sets the "updated" field. -func (dpuo *DBPackageUpdateOne) SetUpdated(t time.Time) *DBPackageUpdateOne { - dpuo.mutation.SetUpdated(t) - return dpuo +func (_u *DBPackageUpdateOne) SetUpdated(v time.Time) *DBPackageUpdateOne { + _u.mutation.SetUpdated(v) + return _u } // SetNillableUpdated sets the "updated" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableUpdated(t *time.Time) *DBPackageUpdateOne { - if t != nil { - dpuo.SetUpdated(*t) +func (_u *DBPackageUpdateOne) SetNillableUpdated(v *time.Time) *DBPackageUpdateOne { + if v != nil { + _u.SetUpdated(*v) } - return dpuo + return _u } // ClearUpdated clears the value of the "updated" field. -func (dpuo *DBPackageUpdateOne) ClearUpdated() *DBPackageUpdateOne { - dpuo.mutation.ClearUpdated() - return dpuo +func (_u *DBPackageUpdateOne) ClearUpdated() *DBPackageUpdateOne { + _u.mutation.ClearUpdated() + return _u } // SetLto sets the "lto" field. -func (dpuo *DBPackageUpdateOne) SetLto(d dbpackage.Lto) *DBPackageUpdateOne { - dpuo.mutation.SetLto(d) - return dpuo +func (_u *DBPackageUpdateOne) SetLto(v dbpackage.Lto) *DBPackageUpdateOne { + _u.mutation.SetLto(v) + return _u } // SetNillableLto sets the "lto" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableLto(d *dbpackage.Lto) *DBPackageUpdateOne { - if d != nil { - dpuo.SetLto(*d) +func (_u *DBPackageUpdateOne) SetNillableLto(v *dbpackage.Lto) *DBPackageUpdateOne { + if v != nil { + _u.SetLto(*v) } - return dpuo + return _u } // ClearLto clears the value of the "lto" field. -func (dpuo *DBPackageUpdateOne) ClearLto() *DBPackageUpdateOne { - dpuo.mutation.ClearLto() - return dpuo +func (_u *DBPackageUpdateOne) ClearLto() *DBPackageUpdateOne { + _u.mutation.ClearLto() + return _u } // SetLastVersionBuild sets the "last_version_build" field. -func (dpuo *DBPackageUpdateOne) SetLastVersionBuild(s string) *DBPackageUpdateOne { - dpuo.mutation.SetLastVersionBuild(s) - return dpuo +func (_u *DBPackageUpdateOne) SetLastVersionBuild(v string) *DBPackageUpdateOne { + _u.mutation.SetLastVersionBuild(v) + return _u } // SetNillableLastVersionBuild sets the "last_version_build" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableLastVersionBuild(s *string) *DBPackageUpdateOne { - if s != nil { - dpuo.SetLastVersionBuild(*s) +func (_u *DBPackageUpdateOne) SetNillableLastVersionBuild(v *string) *DBPackageUpdateOne { + if v != nil { + _u.SetLastVersionBuild(*v) } - return dpuo + return _u } // ClearLastVersionBuild clears the value of the "last_version_build" field. -func (dpuo *DBPackageUpdateOne) ClearLastVersionBuild() *DBPackageUpdateOne { - dpuo.mutation.ClearLastVersionBuild() - return dpuo +func (_u *DBPackageUpdateOne) ClearLastVersionBuild() *DBPackageUpdateOne { + _u.mutation.ClearLastVersionBuild() + return _u } // SetLastVerified sets the "last_verified" field. -func (dpuo *DBPackageUpdateOne) SetLastVerified(t time.Time) *DBPackageUpdateOne { - dpuo.mutation.SetLastVerified(t) - return dpuo +func (_u *DBPackageUpdateOne) SetLastVerified(v time.Time) *DBPackageUpdateOne { + _u.mutation.SetLastVerified(v) + return _u } // SetNillableLastVerified sets the "last_verified" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableLastVerified(t *time.Time) *DBPackageUpdateOne { - if t != nil { - dpuo.SetLastVerified(*t) +func (_u *DBPackageUpdateOne) SetNillableLastVerified(v *time.Time) *DBPackageUpdateOne { + if v != nil { + _u.SetLastVerified(*v) } - return dpuo + return _u } // ClearLastVerified clears the value of the "last_verified" field. -func (dpuo *DBPackageUpdateOne) ClearLastVerified() *DBPackageUpdateOne { - dpuo.mutation.ClearLastVerified() - return dpuo +func (_u *DBPackageUpdateOne) ClearLastVerified() *DBPackageUpdateOne { + _u.mutation.ClearLastVerified() + return _u } // SetDebugSymbols sets the "debug_symbols" field. -func (dpuo *DBPackageUpdateOne) SetDebugSymbols(ds dbpackage.DebugSymbols) *DBPackageUpdateOne { - dpuo.mutation.SetDebugSymbols(ds) - return dpuo +func (_u *DBPackageUpdateOne) SetDebugSymbols(v dbpackage.DebugSymbols) *DBPackageUpdateOne { + _u.mutation.SetDebugSymbols(v) + return _u } // SetNillableDebugSymbols sets the "debug_symbols" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableDebugSymbols(ds *dbpackage.DebugSymbols) *DBPackageUpdateOne { - if ds != nil { - dpuo.SetDebugSymbols(*ds) +func (_u *DBPackageUpdateOne) SetNillableDebugSymbols(v *dbpackage.DebugSymbols) *DBPackageUpdateOne { + if v != nil { + _u.SetDebugSymbols(*v) } - return dpuo + return _u } // ClearDebugSymbols clears the value of the "debug_symbols" field. -func (dpuo *DBPackageUpdateOne) ClearDebugSymbols() *DBPackageUpdateOne { - dpuo.mutation.ClearDebugSymbols() - return dpuo +func (_u *DBPackageUpdateOne) ClearDebugSymbols() *DBPackageUpdateOne { + _u.mutation.ClearDebugSymbols() + return _u } // SetMaxRss sets the "max_rss" field. -func (dpuo *DBPackageUpdateOne) SetMaxRss(i int64) *DBPackageUpdateOne { - dpuo.mutation.ResetMaxRss() - dpuo.mutation.SetMaxRss(i) - return dpuo +func (_u *DBPackageUpdateOne) SetMaxRss(v int64) *DBPackageUpdateOne { + _u.mutation.ResetMaxRss() + _u.mutation.SetMaxRss(v) + return _u } // SetNillableMaxRss sets the "max_rss" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableMaxRss(i *int64) *DBPackageUpdateOne { - if i != nil { - dpuo.SetMaxRss(*i) +func (_u *DBPackageUpdateOne) SetNillableMaxRss(v *int64) *DBPackageUpdateOne { + if v != nil { + _u.SetMaxRss(*v) } - return dpuo + return _u } -// AddMaxRss adds i to the "max_rss" field. -func (dpuo *DBPackageUpdateOne) AddMaxRss(i int64) *DBPackageUpdateOne { - dpuo.mutation.AddMaxRss(i) - return dpuo +// AddMaxRss adds value to the "max_rss" field. +func (_u *DBPackageUpdateOne) AddMaxRss(v int64) *DBPackageUpdateOne { + _u.mutation.AddMaxRss(v) + return _u } // ClearMaxRss clears the value of the "max_rss" field. -func (dpuo *DBPackageUpdateOne) ClearMaxRss() *DBPackageUpdateOne { - dpuo.mutation.ClearMaxRss() - return dpuo +func (_u *DBPackageUpdateOne) ClearMaxRss() *DBPackageUpdateOne { + _u.mutation.ClearMaxRss() + return _u } // SetUTime sets the "u_time" field. -func (dpuo *DBPackageUpdateOne) SetUTime(i int64) *DBPackageUpdateOne { - dpuo.mutation.ResetUTime() - dpuo.mutation.SetUTime(i) - return dpuo +func (_u *DBPackageUpdateOne) SetUTime(v int64) *DBPackageUpdateOne { + _u.mutation.ResetUTime() + _u.mutation.SetUTime(v) + return _u } // SetNillableUTime sets the "u_time" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableUTime(i *int64) *DBPackageUpdateOne { - if i != nil { - dpuo.SetUTime(*i) +func (_u *DBPackageUpdateOne) SetNillableUTime(v *int64) *DBPackageUpdateOne { + if v != nil { + _u.SetUTime(*v) } - return dpuo + return _u } -// AddUTime adds i to the "u_time" field. -func (dpuo *DBPackageUpdateOne) AddUTime(i int64) *DBPackageUpdateOne { - dpuo.mutation.AddUTime(i) - return dpuo +// AddUTime adds value to the "u_time" field. +func (_u *DBPackageUpdateOne) AddUTime(v int64) *DBPackageUpdateOne { + _u.mutation.AddUTime(v) + return _u } // ClearUTime clears the value of the "u_time" field. -func (dpuo *DBPackageUpdateOne) ClearUTime() *DBPackageUpdateOne { - dpuo.mutation.ClearUTime() - return dpuo +func (_u *DBPackageUpdateOne) ClearUTime() *DBPackageUpdateOne { + _u.mutation.ClearUTime() + return _u } // SetSTime sets the "s_time" field. -func (dpuo *DBPackageUpdateOne) SetSTime(i int64) *DBPackageUpdateOne { - dpuo.mutation.ResetSTime() - dpuo.mutation.SetSTime(i) - return dpuo +func (_u *DBPackageUpdateOne) SetSTime(v int64) *DBPackageUpdateOne { + _u.mutation.ResetSTime() + _u.mutation.SetSTime(v) + return _u } // SetNillableSTime sets the "s_time" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableSTime(i *int64) *DBPackageUpdateOne { - if i != nil { - dpuo.SetSTime(*i) +func (_u *DBPackageUpdateOne) SetNillableSTime(v *int64) *DBPackageUpdateOne { + if v != nil { + _u.SetSTime(*v) } - return dpuo + return _u } -// AddSTime adds i to the "s_time" field. -func (dpuo *DBPackageUpdateOne) AddSTime(i int64) *DBPackageUpdateOne { - dpuo.mutation.AddSTime(i) - return dpuo +// AddSTime adds value to the "s_time" field. +func (_u *DBPackageUpdateOne) AddSTime(v int64) *DBPackageUpdateOne { + _u.mutation.AddSTime(v) + return _u } // ClearSTime clears the value of the "s_time" field. -func (dpuo *DBPackageUpdateOne) ClearSTime() *DBPackageUpdateOne { - dpuo.mutation.ClearSTime() - return dpuo +func (_u *DBPackageUpdateOne) ClearSTime() *DBPackageUpdateOne { + _u.mutation.ClearSTime() + return _u } // SetIoIn sets the "io_in" field. -func (dpuo *DBPackageUpdateOne) SetIoIn(i int64) *DBPackageUpdateOne { - dpuo.mutation.ResetIoIn() - dpuo.mutation.SetIoIn(i) - return dpuo +func (_u *DBPackageUpdateOne) SetIoIn(v int64) *DBPackageUpdateOne { + _u.mutation.ResetIoIn() + _u.mutation.SetIoIn(v) + return _u } // SetNillableIoIn sets the "io_in" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableIoIn(i *int64) *DBPackageUpdateOne { - if i != nil { - dpuo.SetIoIn(*i) +func (_u *DBPackageUpdateOne) SetNillableIoIn(v *int64) *DBPackageUpdateOne { + if v != nil { + _u.SetIoIn(*v) } - return dpuo + return _u } -// AddIoIn adds i to the "io_in" field. -func (dpuo *DBPackageUpdateOne) AddIoIn(i int64) *DBPackageUpdateOne { - dpuo.mutation.AddIoIn(i) - return dpuo +// AddIoIn adds value to the "io_in" field. +func (_u *DBPackageUpdateOne) AddIoIn(v int64) *DBPackageUpdateOne { + _u.mutation.AddIoIn(v) + return _u } // ClearIoIn clears the value of the "io_in" field. -func (dpuo *DBPackageUpdateOne) ClearIoIn() *DBPackageUpdateOne { - dpuo.mutation.ClearIoIn() - return dpuo +func (_u *DBPackageUpdateOne) ClearIoIn() *DBPackageUpdateOne { + _u.mutation.ClearIoIn() + return _u } // SetIoOut sets the "io_out" field. -func (dpuo *DBPackageUpdateOne) SetIoOut(i int64) *DBPackageUpdateOne { - dpuo.mutation.ResetIoOut() - dpuo.mutation.SetIoOut(i) - return dpuo +func (_u *DBPackageUpdateOne) SetIoOut(v int64) *DBPackageUpdateOne { + _u.mutation.ResetIoOut() + _u.mutation.SetIoOut(v) + return _u } // SetNillableIoOut sets the "io_out" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableIoOut(i *int64) *DBPackageUpdateOne { - if i != nil { - dpuo.SetIoOut(*i) +func (_u *DBPackageUpdateOne) SetNillableIoOut(v *int64) *DBPackageUpdateOne { + if v != nil { + _u.SetIoOut(*v) } - return dpuo + return _u } -// AddIoOut adds i to the "io_out" field. -func (dpuo *DBPackageUpdateOne) AddIoOut(i int64) *DBPackageUpdateOne { - dpuo.mutation.AddIoOut(i) - return dpuo +// AddIoOut adds value to the "io_out" field. +func (_u *DBPackageUpdateOne) AddIoOut(v int64) *DBPackageUpdateOne { + _u.mutation.AddIoOut(v) + return _u } // ClearIoOut clears the value of the "io_out" field. -func (dpuo *DBPackageUpdateOne) ClearIoOut() *DBPackageUpdateOne { - dpuo.mutation.ClearIoOut() - return dpuo +func (_u *DBPackageUpdateOne) ClearIoOut() *DBPackageUpdateOne { + _u.mutation.ClearIoOut() + return _u } // SetTagRev sets the "tag_rev" field. -func (dpuo *DBPackageUpdateOne) SetTagRev(s string) *DBPackageUpdateOne { - dpuo.mutation.SetTagRev(s) - return dpuo +func (_u *DBPackageUpdateOne) SetTagRev(v string) *DBPackageUpdateOne { + _u.mutation.SetTagRev(v) + return _u } // SetNillableTagRev sets the "tag_rev" field if the given value is not nil. -func (dpuo *DBPackageUpdateOne) SetNillableTagRev(s *string) *DBPackageUpdateOne { - if s != nil { - dpuo.SetTagRev(*s) +func (_u *DBPackageUpdateOne) SetNillableTagRev(v *string) *DBPackageUpdateOne { + if v != nil { + _u.SetTagRev(*v) } - return dpuo + return _u } // ClearTagRev clears the value of the "tag_rev" field. -func (dpuo *DBPackageUpdateOne) ClearTagRev() *DBPackageUpdateOne { - dpuo.mutation.ClearTagRev() - return dpuo +func (_u *DBPackageUpdateOne) ClearTagRev() *DBPackageUpdateOne { + _u.mutation.ClearTagRev() + return _u } // Mutation returns the DBPackageMutation object of the builder. -func (dpuo *DBPackageUpdateOne) Mutation() *DBPackageMutation { - return dpuo.mutation +func (_u *DBPackageUpdateOne) Mutation() *DBPackageMutation { + return _u.mutation } // Where appends a list predicates to the DBPackageUpdate builder. -func (dpuo *DBPackageUpdateOne) Where(ps ...predicate.DBPackage) *DBPackageUpdateOne { - dpuo.mutation.Where(ps...) - return dpuo +func (_u *DBPackageUpdateOne) Where(ps ...predicate.DBPackage) *DBPackageUpdateOne { + _u.mutation.Where(ps...) + return _u } // Select allows selecting one or more fields (columns) of the returned entity. // The default is selecting all fields defined in the entity schema. -func (dpuo *DBPackageUpdateOne) Select(field string, fields ...string) *DBPackageUpdateOne { - dpuo.fields = append([]string{field}, fields...) - return dpuo +func (_u *DBPackageUpdateOne) Select(field string, fields ...string) *DBPackageUpdateOne { + _u.fields = append([]string{field}, fields...) + return _u } // Save executes the query and returns the updated DBPackage entity. -func (dpuo *DBPackageUpdateOne) Save(ctx context.Context) (*DBPackage, error) { - return withHooks(ctx, dpuo.sqlSave, dpuo.mutation, dpuo.hooks) +func (_u *DBPackageUpdateOne) Save(ctx context.Context) (*DBPackage, error) { + return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks) } // SaveX is like Save, but panics if an error occurs. -func (dpuo *DBPackageUpdateOne) SaveX(ctx context.Context) *DBPackage { - node, err := dpuo.Save(ctx) +func (_u *DBPackageUpdateOne) SaveX(ctx context.Context) *DBPackage { + node, err := _u.Save(ctx) if err != nil { panic(err) } @@ -1059,36 +1059,36 @@ func (dpuo *DBPackageUpdateOne) SaveX(ctx context.Context) *DBPackage { } // Exec executes the query on the entity. -func (dpuo *DBPackageUpdateOne) Exec(ctx context.Context) error { - _, err := dpuo.Save(ctx) +func (_u *DBPackageUpdateOne) Exec(ctx context.Context) error { + _, err := _u.Save(ctx) return err } // ExecX is like Exec, but panics if an error occurs. -func (dpuo *DBPackageUpdateOne) ExecX(ctx context.Context) { - if err := dpuo.Exec(ctx); err != nil { +func (_u *DBPackageUpdateOne) ExecX(ctx context.Context) { + if err := _u.Exec(ctx); err != nil { panic(err) } } // check runs all checks and user-defined validators on the builder. -func (dpuo *DBPackageUpdateOne) check() error { - if v, ok := dpuo.mutation.Status(); ok { +func (_u *DBPackageUpdateOne) check() error { + if v, ok := _u.mutation.Status(); ok { if err := dbpackage.StatusValidator(v); err != nil { return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "DBPackage.status": %w`, err)} } } - if v, ok := dpuo.mutation.Repository(); ok { + if v, ok := _u.mutation.Repository(); ok { if err := dbpackage.RepositoryValidator(v); err != nil { return &ValidationError{Name: "repository", err: fmt.Errorf(`ent: validator failed for field "DBPackage.repository": %w`, err)} } } - if v, ok := dpuo.mutation.Lto(); ok { + if v, ok := _u.mutation.Lto(); ok { if err := dbpackage.LtoValidator(v); err != nil { return &ValidationError{Name: "lto", err: fmt.Errorf(`ent: validator failed for field "DBPackage.lto": %w`, err)} } } - if v, ok := dpuo.mutation.DebugSymbols(); ok { + if v, ok := _u.mutation.DebugSymbols(); ok { if err := dbpackage.DebugSymbolsValidator(v); err != nil { return &ValidationError{Name: "debug_symbols", err: fmt.Errorf(`ent: validator failed for field "DBPackage.debug_symbols": %w`, err)} } @@ -1097,22 +1097,22 @@ func (dpuo *DBPackageUpdateOne) check() error { } // Modify adds a statement modifier for attaching custom logic to the UPDATE statement. -func (dpuo *DBPackageUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *DBPackageUpdateOne { - dpuo.modifiers = append(dpuo.modifiers, modifiers...) - return dpuo +func (_u *DBPackageUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *DBPackageUpdateOne { + _u.modifiers = append(_u.modifiers, modifiers...) + return _u } -func (dpuo *DBPackageUpdateOne) sqlSave(ctx context.Context) (_node *DBPackage, err error) { - if err := dpuo.check(); err != nil { +func (_u *DBPackageUpdateOne) sqlSave(ctx context.Context) (_node *DBPackage, err error) { + if err := _u.check(); err != nil { return _node, err } _spec := sqlgraph.NewUpdateSpec(dbpackage.Table, dbpackage.Columns, sqlgraph.NewFieldSpec(dbpackage.FieldID, field.TypeInt)) - id, ok := dpuo.mutation.ID() + id, ok := _u.mutation.ID() if !ok { return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "DBPackage.id" for update`)} } _spec.Node.ID.Value = id - if fields := dpuo.fields; len(fields) > 0 { + if fields := _u.fields; len(fields) > 0 { _spec.Node.Columns = make([]string, 0, len(fields)) _spec.Node.Columns = append(_spec.Node.Columns, dbpackage.FieldID) for _, f := range fields { @@ -1124,143 +1124,143 @@ func (dpuo *DBPackageUpdateOne) sqlSave(ctx context.Context) (_node *DBPackage, } } } - if ps := dpuo.mutation.predicates; len(ps) > 0 { + if ps := _u.mutation.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { for i := range ps { ps[i](selector) } } } - if value, ok := dpuo.mutation.Packages(); ok { + if value, ok := _u.mutation.Packages(); ok { _spec.SetField(dbpackage.FieldPackages, field.TypeJSON, value) } - if value, ok := dpuo.mutation.AppendedPackages(); ok { + if value, ok := _u.mutation.AppendedPackages(); ok { _spec.AddModifier(func(u *sql.UpdateBuilder) { sqljson.Append(u, dbpackage.FieldPackages, value) }) } - if dpuo.mutation.PackagesCleared() { + if _u.mutation.PackagesCleared() { _spec.ClearField(dbpackage.FieldPackages, field.TypeJSON) } - if value, ok := dpuo.mutation.Status(); ok { + if value, ok := _u.mutation.Status(); ok { _spec.SetField(dbpackage.FieldStatus, field.TypeEnum, value) } - if dpuo.mutation.StatusCleared() { + if _u.mutation.StatusCleared() { _spec.ClearField(dbpackage.FieldStatus, field.TypeEnum) } - if value, ok := dpuo.mutation.SkipReason(); ok { + if value, ok := _u.mutation.SkipReason(); ok { _spec.SetField(dbpackage.FieldSkipReason, field.TypeString, value) } - if dpuo.mutation.SkipReasonCleared() { + if _u.mutation.SkipReasonCleared() { _spec.ClearField(dbpackage.FieldSkipReason, field.TypeString) } - if value, ok := dpuo.mutation.Repository(); ok { + if value, ok := _u.mutation.Repository(); ok { _spec.SetField(dbpackage.FieldRepository, field.TypeEnum, value) } - if value, ok := dpuo.mutation.Version(); ok { + if value, ok := _u.mutation.Version(); ok { _spec.SetField(dbpackage.FieldVersion, field.TypeString, value) } - if dpuo.mutation.VersionCleared() { + if _u.mutation.VersionCleared() { _spec.ClearField(dbpackage.FieldVersion, field.TypeString) } - if value, ok := dpuo.mutation.RepoVersion(); ok { + if value, ok := _u.mutation.RepoVersion(); ok { _spec.SetField(dbpackage.FieldRepoVersion, field.TypeString, value) } - if dpuo.mutation.RepoVersionCleared() { + if _u.mutation.RepoVersionCleared() { _spec.ClearField(dbpackage.FieldRepoVersion, field.TypeString) } - if value, ok := dpuo.mutation.BuildTimeStart(); ok { + if value, ok := _u.mutation.BuildTimeStart(); ok { _spec.SetField(dbpackage.FieldBuildTimeStart, field.TypeTime, value) } - if dpuo.mutation.BuildTimeStartCleared() { + if _u.mutation.BuildTimeStartCleared() { _spec.ClearField(dbpackage.FieldBuildTimeStart, field.TypeTime) } - if value, ok := dpuo.mutation.Updated(); ok { + if value, ok := _u.mutation.Updated(); ok { _spec.SetField(dbpackage.FieldUpdated, field.TypeTime, value) } - if dpuo.mutation.UpdatedCleared() { + if _u.mutation.UpdatedCleared() { _spec.ClearField(dbpackage.FieldUpdated, field.TypeTime) } - if value, ok := dpuo.mutation.Lto(); ok { + if value, ok := _u.mutation.Lto(); ok { _spec.SetField(dbpackage.FieldLto, field.TypeEnum, value) } - if dpuo.mutation.LtoCleared() { + if _u.mutation.LtoCleared() { _spec.ClearField(dbpackage.FieldLto, field.TypeEnum) } - if value, ok := dpuo.mutation.LastVersionBuild(); ok { + if value, ok := _u.mutation.LastVersionBuild(); ok { _spec.SetField(dbpackage.FieldLastVersionBuild, field.TypeString, value) } - if dpuo.mutation.LastVersionBuildCleared() { + if _u.mutation.LastVersionBuildCleared() { _spec.ClearField(dbpackage.FieldLastVersionBuild, field.TypeString) } - if value, ok := dpuo.mutation.LastVerified(); ok { + if value, ok := _u.mutation.LastVerified(); ok { _spec.SetField(dbpackage.FieldLastVerified, field.TypeTime, value) } - if dpuo.mutation.LastVerifiedCleared() { + if _u.mutation.LastVerifiedCleared() { _spec.ClearField(dbpackage.FieldLastVerified, field.TypeTime) } - if value, ok := dpuo.mutation.DebugSymbols(); ok { + if value, ok := _u.mutation.DebugSymbols(); ok { _spec.SetField(dbpackage.FieldDebugSymbols, field.TypeEnum, value) } - if dpuo.mutation.DebugSymbolsCleared() { + if _u.mutation.DebugSymbolsCleared() { _spec.ClearField(dbpackage.FieldDebugSymbols, field.TypeEnum) } - if value, ok := dpuo.mutation.MaxRss(); ok { + if value, ok := _u.mutation.MaxRss(); ok { _spec.SetField(dbpackage.FieldMaxRss, field.TypeInt64, value) } - if value, ok := dpuo.mutation.AddedMaxRss(); ok { + if value, ok := _u.mutation.AddedMaxRss(); ok { _spec.AddField(dbpackage.FieldMaxRss, field.TypeInt64, value) } - if dpuo.mutation.MaxRssCleared() { + if _u.mutation.MaxRssCleared() { _spec.ClearField(dbpackage.FieldMaxRss, field.TypeInt64) } - if value, ok := dpuo.mutation.UTime(); ok { + if value, ok := _u.mutation.UTime(); ok { _spec.SetField(dbpackage.FieldUTime, field.TypeInt64, value) } - if value, ok := dpuo.mutation.AddedUTime(); ok { + if value, ok := _u.mutation.AddedUTime(); ok { _spec.AddField(dbpackage.FieldUTime, field.TypeInt64, value) } - if dpuo.mutation.UTimeCleared() { + if _u.mutation.UTimeCleared() { _spec.ClearField(dbpackage.FieldUTime, field.TypeInt64) } - if value, ok := dpuo.mutation.STime(); ok { + if value, ok := _u.mutation.STime(); ok { _spec.SetField(dbpackage.FieldSTime, field.TypeInt64, value) } - if value, ok := dpuo.mutation.AddedSTime(); ok { + if value, ok := _u.mutation.AddedSTime(); ok { _spec.AddField(dbpackage.FieldSTime, field.TypeInt64, value) } - if dpuo.mutation.STimeCleared() { + if _u.mutation.STimeCleared() { _spec.ClearField(dbpackage.FieldSTime, field.TypeInt64) } - if value, ok := dpuo.mutation.IoIn(); ok { + if value, ok := _u.mutation.IoIn(); ok { _spec.SetField(dbpackage.FieldIoIn, field.TypeInt64, value) } - if value, ok := dpuo.mutation.AddedIoIn(); ok { + if value, ok := _u.mutation.AddedIoIn(); ok { _spec.AddField(dbpackage.FieldIoIn, field.TypeInt64, value) } - if dpuo.mutation.IoInCleared() { + if _u.mutation.IoInCleared() { _spec.ClearField(dbpackage.FieldIoIn, field.TypeInt64) } - if value, ok := dpuo.mutation.IoOut(); ok { + if value, ok := _u.mutation.IoOut(); ok { _spec.SetField(dbpackage.FieldIoOut, field.TypeInt64, value) } - if value, ok := dpuo.mutation.AddedIoOut(); ok { + if value, ok := _u.mutation.AddedIoOut(); ok { _spec.AddField(dbpackage.FieldIoOut, field.TypeInt64, value) } - if dpuo.mutation.IoOutCleared() { + if _u.mutation.IoOutCleared() { _spec.ClearField(dbpackage.FieldIoOut, field.TypeInt64) } - if value, ok := dpuo.mutation.TagRev(); ok { + if value, ok := _u.mutation.TagRev(); ok { _spec.SetField(dbpackage.FieldTagRev, field.TypeString, value) } - if dpuo.mutation.TagRevCleared() { + if _u.mutation.TagRevCleared() { _spec.ClearField(dbpackage.FieldTagRev, field.TypeString) } - _spec.AddModifiers(dpuo.modifiers...) - _node = &DBPackage{config: dpuo.config} + _spec.AddModifiers(_u.modifiers...) + _node = &DBPackage{config: _u.config} _spec.Assign = _node.assignValues _spec.ScanValues = _node.scanValues - if err = sqlgraph.UpdateNode(ctx, dpuo.driver, _spec); err != nil { + if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{dbpackage.Label} } else if sqlgraph.IsConstraintError(err) { @@ -1268,6 +1268,6 @@ func (dpuo *DBPackageUpdateOne) sqlSave(ctx context.Context) (_node *DBPackage, } return nil, err } - dpuo.mutation.done = true + _u.mutation.done = true return _node, nil } diff --git a/ent/ent.go b/ent/ent.go index b9ab6c3..48e3b72 100644 --- a/ent/ent.go +++ b/ent/ent.go @@ -70,13 +70,13 @@ var ( ) // checkColumn checks if the column exists in the given table. -func checkColumn(table, column string) error { +func checkColumn(t, c string) error { initCheck.Do(func() { columnCheck = sql.NewColumnCheck(map[string]func(string) bool{ dbpackage.Table: dbpackage.ValidColumn, }) }) - return columnCheck(table, column) + return columnCheck(t, c) } // Asc applies the given fields in ASC order. diff --git a/ent/runtime/runtime.go b/ent/runtime/runtime.go index 1f850a2..19d6641 100644 --- a/ent/runtime/runtime.go +++ b/ent/runtime/runtime.go @@ -5,6 +5,6 @@ package runtime // The schema-stitching logic is generated in somegit.dev/ALHP/ALHP.GO/ent/runtime.go const ( - Version = "v0.14.2" // Version of ent codegen. - Sum = "h1:ywld/j2Rx4EmnIKs8eZ29cbFA1zpB+DA9TLL5l3rlq0=" // Sum of ent codegen. + Version = "v0.14.5" // Version of ent codegen. + Sum = "h1:Rj2WOYJtCkWyFo6a+5wB3EfBRP0rnx1fMk6gGA0UUe4=" // Sum of ent codegen. ) diff --git a/go.mod b/go.mod index fd5e4c9..1b5197f 100644 --- a/go.mod +++ b/go.mod @@ -1,11 +1,9 @@ module somegit.dev/ALHP/ALHP.GO -go 1.23.0 - -toolchain go1.23.1 +go 1.24.6 require ( - entgo.io/ent v0.14.3 + entgo.io/ent v0.14.5 github.com/Jguer/go-alpm/v2 v2.2.2 github.com/Morganamilo/go-pacmanconf v0.0.0-20210502114700-cff030e927a5 github.com/Morganamilo/go-srcinfo v1.0.0 @@ -14,7 +12,7 @@ require ( github.com/google/uuid v1.6.0 github.com/jackc/pgx/v4 v4.18.3 github.com/otiai10/copy v1.14.1 - github.com/prometheus/client_golang v1.21.1 + github.com/prometheus/client_golang v1.23.2 github.com/sethvargo/go-retry v0.3.0 github.com/sirupsen/logrus v1.9.3 github.com/wercker/journalhook v0.0.0-20230927020745-64542ffa4117 @@ -22,16 +20,16 @@ require ( ) require ( - ariga.io/atlas v0.32.0 // indirect + ariga.io/atlas v0.37.0 // indirect github.com/agext/levenshtein v1.2.3 // indirect github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/bmatcuk/doublestar v1.3.4 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/coreos/go-systemd v0.0.0-20191104093116-d3cd4ed1dbcf // indirect - github.com/go-openapi/inflect v0.21.1 // indirect + github.com/go-openapi/inflect v0.21.3 // indirect github.com/google/go-cmp v0.7.0 // indirect - github.com/hashicorp/hcl/v2 v2.23.0 // indirect + github.com/hashicorp/hcl/v2 v2.24.0 // indirect github.com/jackc/chunkreader/v2 v2.0.1 // indirect github.com/jackc/pgconn v1.14.3 // indirect github.com/jackc/pgio v1.0.0 // indirect @@ -39,20 +37,21 @@ require ( github.com/jackc/pgproto3/v2 v2.3.3 // indirect github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect github.com/jackc/pgtype v1.14.4 // indirect - github.com/klauspost/compress v1.18.0 // indirect github.com/mitchellh/go-wordwrap v1.0.1 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/otiai10/mint v1.6.3 // indirect - github.com/prometheus/client_model v0.6.1 // indirect - github.com/prometheus/common v0.63.0 // indirect - github.com/prometheus/procfs v0.15.1 // indirect - github.com/zclconf/go-cty v1.16.2 // indirect + github.com/prometheus/client_model v0.6.2 // indirect + github.com/prometheus/common v0.67.1 // indirect + github.com/prometheus/procfs v0.17.0 // indirect + github.com/zclconf/go-cty v1.17.0 // indirect github.com/zclconf/go-cty-yaml v1.1.0 // indirect - golang.org/x/crypto v0.36.0 // indirect - golang.org/x/mod v0.24.0 // indirect - golang.org/x/sync v0.12.0 // indirect - golang.org/x/sys v0.31.0 // indirect - golang.org/x/text v0.23.0 // indirect - golang.org/x/tools v0.31.0 // indirect - google.golang.org/protobuf v1.36.5 // indirect + go.yaml.in/yaml/v2 v2.4.3 // indirect + golang.org/x/crypto v0.43.0 // indirect + golang.org/x/mod v0.29.0 // indirect + golang.org/x/sync v0.17.0 // indirect + golang.org/x/sys v0.37.0 // indirect + golang.org/x/text v0.30.0 // indirect + golang.org/x/tools v0.38.0 // indirect + google.golang.org/protobuf v1.36.10 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index d2687a5..3b1a808 100644 --- a/go.sum +++ b/go.sum @@ -1,11 +1,7 @@ -ariga.io/atlas v0.31.1-0.20250212144724-069be8033e83 h1:nX4HXncwIdvQ8/8sIUIf1nyCkK8qdBaHQ7EtzPpuiGE= -ariga.io/atlas v0.31.1-0.20250212144724-069be8033e83/go.mod h1:Oe1xWPuu5q9LzyrWfbZmEZxFYeu4BHTyzfjeW2aZp/w= -ariga.io/atlas v0.32.0 h1:y+77nueMrExLiKlz1CcPKh/nU7VSlWfBbwCShsJyvCw= -ariga.io/atlas v0.32.0/go.mod h1:Oe1xWPuu5q9LzyrWfbZmEZxFYeu4BHTyzfjeW2aZp/w= -entgo.io/ent v0.14.2 h1:ywld/j2Rx4EmnIKs8eZ29cbFA1zpB+DA9TLL5l3rlq0= -entgo.io/ent v0.14.2/go.mod h1:aDPE/OziPEu8+OWbzy4UlvWmD2/kbRuWfK2A40hcxJM= -entgo.io/ent v0.14.3 h1:wokAV/kIlH9TeklJWGGS7AYJdVckr0DloWjIcO9iIIQ= -entgo.io/ent v0.14.3/go.mod h1:aDPE/OziPEu8+OWbzy4UlvWmD2/kbRuWfK2A40hcxJM= +ariga.io/atlas v0.37.0 h1:MvbQ25CAHFslttEKEySwYNFrFUdLAPhtU1izOzjXV+o= +ariga.io/atlas v0.37.0/go.mod h1:mHE83ptCxEkd3rO3c7Rvkk6Djf6mVhEiSVhoiNu96CI= +entgo.io/ent v0.14.5 h1:Rj2WOYJtCkWyFo6a+5wB3EfBRP0rnx1fMk6gGA0UUe4= +entgo.io/ent v0.14.5/go.mod h1:zTzLmWtPvGpmSwtkaayM2cm5m819NdM7z7tYPq3vN0U= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60= github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM= @@ -41,10 +37,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY= github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= -github.com/go-openapi/inflect v0.21.0 h1:FoBjBTQEcbg2cJUWX6uwL9OyIW8eqc9k4KhN4lfbeYk= -github.com/go-openapi/inflect v0.21.0/go.mod h1:INezMuUu7SJQc2AyR3WO0DqqYUJSj8Kb4hBd7WtjlAw= -github.com/go-openapi/inflect v0.21.1 h1:swwdJV4YPbuQaz68rHiBeQj+MWeBjDDNyEAi78Fhu4g= -github.com/go-openapi/inflect v0.21.1/go.mod h1:INezMuUu7SJQc2AyR3WO0DqqYUJSj8Kb4hBd7WtjlAw= +github.com/go-openapi/inflect v0.21.3 h1:TmQvw+9eLrsNp4X0BBQacEZZtAnzk2z1FaLdQQJsDiU= +github.com/go-openapi/inflect v0.21.3/go.mod h1:INezMuUu7SJQc2AyR3WO0DqqYUJSj8Kb4hBd7WtjlAw= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68= github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA= @@ -57,9 +51,8 @@ github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/hashicorp/hcl/v2 v2.23.0 h1:Fphj1/gCylPxHutVSEOf2fBOh1VE4AuLV7+kbJf3qos= -github.com/hashicorp/hcl/v2 v2.23.0/go.mod h1:62ZYHrXgPoX8xBnzl8QzbWq4dyDsDtfCRgIq1rbJEvA= -github.com/jackc/chunkreader v1.0.0 h1:4s39bBR8ByfqH+DKm8rQA3E1LHZWB9XWcrz8fqaZbe0= +github.com/hashicorp/hcl/v2 v2.24.0 h1:2QJdZ454DSsYGoaE6QheQZjtKZSUs9Nh2izTWiwQxvE= +github.com/hashicorp/hcl/v2 v2.24.0/go.mod h1:oGoO1FIQYfn/AgyOhlg9qLC6/nOJPX3qGbkZpYAcqfM= github.com/jackc/chunkreader v1.0.0/go.mod h1:RT6O25fNZIuasFJRyZ4R/Y2BbhasbmZXF9QQ7T3kePo= github.com/jackc/chunkreader/v2 v2.0.0/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk= github.com/jackc/chunkreader/v2 v2.0.1 h1:i+RDz65UE+mmpjTfyz0MoVTnzeYxroil2G82ki7MGG8= @@ -80,7 +73,6 @@ github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65 h1:DadwsjnMwFjfWc9y5W github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65/go.mod h1:5R2h2EEX+qri8jOWMbJCtaPWkrrNc7OHwsp2TCqp7ak= github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= -github.com/jackc/pgproto3 v1.1.0 h1:FYYE4yRw+AgI8wXIinMlNjBbp/UitDJwfj5LqqewP1A= github.com/jackc/pgproto3 v1.1.0/go.mod h1:eR5FA3leWg7p9aeAqi37XOTgTIbkABlvcPB3E5rlc78= github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190420180111-c116219b62db/go.mod h1:bhq50y+xrl9n5mRYyCBFKkpRVTLYJVWeCc+mEAI3yXA= github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190609003834-432c2951c711/go.mod h1:uH0AWtUmuShn0bcesswc4aBTWGvw0cAxIJp+6OB//Wg= @@ -112,11 +104,7 @@ github.com/jackc/puddle v0.0.0-20190413234325-e4ced69a3a2b/go.mod h1:m4B5Dj62Y0f github.com/jackc/puddle v0.0.0-20190608224051-11cab39313c9/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= github.com/jackc/puddle v1.1.3/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= github.com/jackc/puddle v1.3.0/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= -github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= -github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc= -github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0= github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= @@ -141,12 +129,16 @@ github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= -github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y= -github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= +github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0= +github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= +github.com/mattn/go-sqlite3 v1.14.28 h1:ThEiQrnbtumT+QMknw63Befp/ce/nUPgBPMlRFEum7A= +github.com/mattn/go-sqlite3 v1.14.28/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y= github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0= github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= +github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= github.com/otiai10/copy v1.14.1 h1:5/7E6qsUMBaH5AnQ0sSLzzTg1oTECmcCmT6lvF45Na8= github.com/otiai10/copy v1.14.1/go.mod h1:oQwrEDDOci3IM8dJF0d8+jnbfPDllW6vUjNc3DoZm9I= github.com/otiai10/mint v1.6.3 h1:87qsV/aw1F5as1eH1zS/yqHY85ANKVMgkDrf9rcxbQs= @@ -155,18 +147,14 @@ github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.21.0 h1:DIsaGmiaBkSangBgMtWdNfxbMNdku5IK6iNhrEqWvdA= -github.com/prometheus/client_golang v1.21.0/go.mod h1:U9NM32ykUErtVBxdvD3zfi+EuFkkaBvMb09mIfe0Zgg= -github.com/prometheus/client_golang v1.21.1 h1:DOvXXTqVzvkIewV/CDPFdejpMCGeMcbGCQ8YOmu+Ibk= -github.com/prometheus/client_golang v1.21.1/go.mod h1:U9NM32ykUErtVBxdvD3zfi+EuFkkaBvMb09mIfe0Zgg= -github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E= -github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY= -github.com/prometheus/common v0.62.0 h1:xasJaQlnWAeyHdUBeGjXmutelfJHWMRr+Fg4QszZ2Io= -github.com/prometheus/common v0.62.0/go.mod h1:vyBcEuLSvWos9B1+CyL7JZ2up+uFzXhkqml0W5zIY1I= -github.com/prometheus/common v0.63.0 h1:YR/EIY1o3mEFP/kZCD7iDMnLPlGyuU2Gb3HIcXnA98k= -github.com/prometheus/common v0.63.0/go.mod h1:VVFF/fBIoToEnWRVkYoXEkq3R3paCoxG9PXP74SnV18= -github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= -github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= +github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= +github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= +github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= +github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= +github.com/prometheus/common v0.67.1 h1:OTSON1P4DNxzTg4hmKCc37o4ZAZDv0cfXLkOt0oEowI= +github.com/prometheus/common v0.67.1/go.mod h1:RpmT9v35q2Y+lsieQsdOh5sXZ6ajUGC8NjZAmr8vb0Q= +github.com/prometheus/procfs v0.17.0 h1:FuLQ+05u4ZI+SS/w9+BWEM2TXiHKsUQ9TADiRH7DuK0= +github.com/prometheus/procfs v0.17.0/go.mod h1:oPQLaDAMRbA+u8H5Pbfq+dl3VDAvHxMUOVhe0wYB2zw= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= @@ -183,6 +171,10 @@ github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMB github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I= +github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= @@ -196,13 +188,13 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= -github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= github.com/wercker/journalhook v0.0.0-20230927020745-64542ffa4117 h1:67A5tweHp3C7osHjrYsy6pQZ00bYkTTttZ7kiOwwHeA= github.com/wercker/journalhook v0.0.0-20230927020745-64542ffa4117/go.mod h1:XCsSkdKK4gwBMNrOCZWww0pX6AOt+2gYc5Z6jBRrNVg= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= -github.com/zclconf/go-cty v1.16.2 h1:LAJSwc3v81IRBZyUVQDUdZ7hs3SYs9jv0eZJDWHD/70= -github.com/zclconf/go-cty v1.16.2/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgrPIxfnZE= +github.com/zclconf/go-cty v1.17.0 h1:seZvECve6XX4tmnvRzWtJNHdscMtYEx5R7bnnVyd/d0= +github.com/zclconf/go-cty v1.17.0/go.mod h1:wqFzcImaLTI6A5HfsRwB0nj5n0MRZFwmey8YoFPPs3U= github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940 h1:4r45xpDWB6ZMSMNJFMOjqrGHynW3DIBuR2H9j0ug+Mo= github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940/go.mod h1:CmBdvvj3nqzfzJ6nTCIwDTPZ56aVGvDrmztiO5g3qrM= github.com/zclconf/go-cty-yaml v1.1.0 h1:nP+jp0qPHv2IhUVqmQSzjvqAWcObN0KBkUl2rWBdig0= @@ -212,6 +204,8 @@ go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU= @@ -219,6 +213,8 @@ go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9E go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM= +go.yaml.in/yaml/v2 v2.4.3 h1:6gvOSjQoTB3vt1l+CU+tSyi/HOjfOjRLJ4YwYZGwRO0= +go.yaml.in/yaml/v2 v2.4.3/go.mod h1:zSxWcmIDjOzPXpjlTTbAsKokqkDNAVtZO0WOMiT90s8= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190411191339-88737f569e3a/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= @@ -231,19 +227,15 @@ golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5y golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= golang.org/x/crypto v0.20.0/go.mod h1:Xwo95rrVNIoSMx9wa1JroENMToLWn3RNVrTBpLHgZPQ= -golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus= -golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M= -golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34= -golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc= +golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04= +golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0= golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/mod v0.23.0 h1:Zb7khfcRGKk+kqfxFaP5tZqCnDZMjC5VtUBs87Hr6QM= -golang.org/x/mod v0.23.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= -golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU= -golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww= +golang.org/x/mod v0.29.0 h1:HV8lRxZC4l2cr3Zq1LvtOsi/ThTgWnUk/y64QSs8GwA= +golang.org/x/mod v0.29.0/go.mod h1:NyhrlYXJ2H4eJiRy/WDBO6HMqZQ6q9nk4JzS3NuCK+w= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= @@ -256,10 +248,8 @@ golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w= -golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= -golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw= -golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug= +golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -278,10 +268,8 @@ golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc= -golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik= -golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ= +golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= @@ -297,10 +285,8 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM= -golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY= -golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY= -golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4= +golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k= +golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190425163242-31fd60d6bfdc/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= @@ -312,19 +298,15 @@ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= -golang.org/x/tools v0.30.0 h1:BgcpHewrV5AUp2G9MebG4XPFI1E2W41zU1SaqVA9vJY= -golang.org/x/tools v0.30.0/go.mod h1:c347cR/OJfw5TI+GfX7RUPNMdDRRbjvYTS0jPyvsVtY= -golang.org/x/tools v0.31.0 h1:0EedkvKDbh+qistFTd0Bcwe/YLh4vHwWEkiI0toFIBU= -golang.org/x/tools v0.31.0/go.mod h1:naFTU+Cev749tSJRXJlna0T3WxKvb1kWEx15xA4SdmQ= +golang.org/x/tools v0.38.0 h1:Hx2Xv8hISq8Lm16jvBZ2VQf+RLmbd7wVUsALibYI/IQ= +golang.org/x/tools v0.38.0/go.mod h1:yEsQ/d/YK8cjh0L6rZlY8tgtlKiBNTL14pGDJPJpYQs= golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -google.golang.org/protobuf v1.36.1 h1:yBPeRvTftaleIgM3PZ/WBIZ7XM/eEYAaEyCwvyjq/gk= -google.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= -google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM= -google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= +google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE= +google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=