diff --git a/ent/client.go b/ent/client.go
index a143744..f65ef4d 100644
--- a/ent/client.go
+++ b/ent/client.go
@@ -27,7 +27,7 @@ type Client struct {
 
 // NewClient creates a new client configured with the given options.
 func NewClient(opts ...Option) *Client {
-	cfg := config{log: log.Println, hooks: &hooks{}}
+	cfg := config{log: log.Println, hooks: &hooks{}, inters: &inters{}}
 	cfg.options(opts...)
 	client := &Client{config: cfg}
 	client.init()
@@ -122,6 +122,22 @@ func (c *Client) Use(hooks ...Hook) {
 	c.DbPackage.Use(hooks...)
 }
 
+// Intercept adds the query interceptors to all the entity clients.
+// In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
+func (c *Client) Intercept(interceptors ...Interceptor) {
+	c.DbPackage.Intercept(interceptors...)
+}
+
+// Mutate implements the ent.Mutator interface.
+func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
+	switch m := m.(type) {
+	case *DbPackageMutation:
+		return c.DbPackage.mutate(ctx, m)
+	default:
+		return nil, fmt.Errorf("ent: unknown mutation type %T", m)
+	}
+}
+
 // DbPackageClient is a client for the DbPackage schema.
 type DbPackageClient struct {
 	config
@@ -138,6 +154,12 @@ func (c *DbPackageClient) Use(hooks ...Hook) {
 	c.hooks.DbPackage = append(c.hooks.DbPackage, hooks...)
 }
 
+// Use adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `dbpackage.Intercept(f(g(h())))`.
+func (c *DbPackageClient) Intercept(interceptors ...Interceptor) {
+	c.inters.DbPackage = append(c.inters.DbPackage, interceptors...)
+}
+
 // Create returns a builder for creating a DbPackage entity.
 func (c *DbPackageClient) Create() *DbPackageCreate {
 	mutation := newDbPackageMutation(c.config, OpCreate)
@@ -190,6 +212,7 @@ func (c *DbPackageClient) DeleteOneID(id int) *DbPackageDeleteOne {
 func (c *DbPackageClient) Query() *DbPackageQuery {
 	return &DbPackageQuery{
 		config: c.config,
+		inters: c.Interceptors(),
 	}
 }
 
@@ -211,3 +234,23 @@ func (c *DbPackageClient) GetX(ctx context.Context, id int) *DbPackage {
 func (c *DbPackageClient) Hooks() []Hook {
 	return c.hooks.DbPackage
 }
+
+// Interceptors returns the client interceptors.
+func (c *DbPackageClient) Interceptors() []Interceptor {
+	return c.inters.DbPackage
+}
+
+func (c *DbPackageClient) mutate(ctx context.Context, m *DbPackageMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&DbPackageCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&DbPackageUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&DbPackageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&DbPackageDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("ent: unknown DbPackage mutation op: %q", m.Op())
+	}
+}
diff --git a/ent/config.go b/ent/config.go
index 0db46d5..1f79dde 100644
--- a/ent/config.go
+++ b/ent/config.go
@@ -20,12 +20,19 @@ type config struct {
 	log func(...any)
 	// hooks to execute on mutations.
 	hooks *hooks
+	// interceptors to execute on queries.
+	inters *inters
 }
 
-// hooks per client, for fast access.
-type hooks struct {
-	DbPackage []ent.Hook
-}
+// hooks and interceptors per client, for fast access.
+type (
+	hooks struct {
+		DbPackage []ent.Hook
+	}
+	inters struct {
+		DbPackage []ent.Interceptor
+	}
+)
 
 // Options applies the options on the config object.
 func (c *config) options(opts ...Option) {
diff --git a/ent/dbpackage/where.go b/ent/dbpackage/where.go
index e0f9077..f01c736 100644
--- a/ent/dbpackage/where.go
+++ b/ent/dbpackage/where.go
@@ -11,2125 +11,1387 @@ import (
 
 // ID filters vertices based on their ID field.
 func ID(id int) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldID, id))
 }
 
 // IDEQ applies the EQ predicate on the ID field.
 func IDEQ(id int) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldID, id))
 }
 
 // IDNEQ applies the NEQ predicate on the ID field.
 func IDNEQ(id int) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldID), id))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldID, id))
 }
 
 // IDIn applies the In predicate on the ID field.
 func IDIn(ids ...int) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		v := make([]any, len(ids))
-		for i := range v {
-			v[i] = ids[i]
-		}
-		s.Where(sql.In(s.C(FieldID), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldID, ids...))
 }
 
 // IDNotIn applies the NotIn predicate on the ID field.
 func IDNotIn(ids ...int) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		v := make([]any, len(ids))
-		for i := range v {
-			v[i] = ids[i]
-		}
-		s.Where(sql.NotIn(s.C(FieldID), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldID, ids...))
 }
 
 // IDGT applies the GT predicate on the ID field.
 func IDGT(id int) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldID), id))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldID, id))
 }
 
 // IDGTE applies the GTE predicate on the ID field.
 func IDGTE(id int) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldID), id))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldID, id))
 }
 
 // IDLT applies the LT predicate on the ID field.
 func IDLT(id int) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldID), id))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldID, id))
 }
 
 // IDLTE applies the LTE predicate on the ID field.
 func IDLTE(id int) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldID), id))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldID, id))
 }
 
 // Pkgbase applies equality check predicate on the "pkgbase" field. It's identical to PkgbaseEQ.
 func Pkgbase(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldPkgbase), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldPkgbase, v))
 }
 
 // SkipReason applies equality check predicate on the "skip_reason" field. It's identical to SkipReasonEQ.
 func SkipReason(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldSkipReason), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldSkipReason, v))
 }
 
 // March applies equality check predicate on the "march" field. It's identical to MarchEQ.
 func March(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldMarch), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldMarch, v))
 }
 
 // Version applies equality check predicate on the "version" field. It's identical to VersionEQ.
 func Version(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldVersion, v))
 }
 
 // RepoVersion applies equality check predicate on the "repo_version" field. It's identical to RepoVersionEQ.
 func RepoVersion(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldRepoVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldRepoVersion, v))
 }
 
 // BuildTimeStart applies equality check predicate on the "build_time_start" field. It's identical to BuildTimeStartEQ.
 func BuildTimeStart(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldBuildTimeStart), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldBuildTimeStart, v))
 }
 
 // Updated applies equality check predicate on the "updated" field. It's identical to UpdatedEQ.
 func Updated(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldUpdated), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldUpdated, v))
 }
 
 // Hash applies equality check predicate on the "hash" field. It's identical to HashEQ.
 func Hash(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldHash), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldHash, v))
 }
 
 // LastVersionBuild applies equality check predicate on the "last_version_build" field. It's identical to LastVersionBuildEQ.
 func LastVersionBuild(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldLastVersionBuild), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldLastVersionBuild, v))
 }
 
 // LastVerified applies equality check predicate on the "last_verified" field. It's identical to LastVerifiedEQ.
 func LastVerified(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldLastVerified), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldLastVerified, v))
 }
 
 // MaxRss applies equality check predicate on the "max_rss" field. It's identical to MaxRssEQ.
 func MaxRss(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldMaxRss), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldMaxRss, v))
 }
 
 // UTime applies equality check predicate on the "u_time" field. It's identical to UTimeEQ.
 func UTime(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldUTime), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldUTime, v))
 }
 
 // STime applies equality check predicate on the "s_time" field. It's identical to STimeEQ.
 func STime(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldSTime), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldSTime, v))
 }
 
 // IoIn applies equality check predicate on the "io_in" field. It's identical to IoInEQ.
 func IoIn(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldIoIn), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldIoIn, v))
 }
 
 // IoOut applies equality check predicate on the "io_out" field. It's identical to IoOutEQ.
 func IoOut(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldIoOut), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldIoOut, v))
 }
 
 // Srcinfo applies equality check predicate on the "srcinfo" field. It's identical to SrcinfoEQ.
 func Srcinfo(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldSrcinfo), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldSrcinfo, v))
 }
 
 // SrcinfoHash applies equality check predicate on the "srcinfo_hash" field. It's identical to SrcinfoHashEQ.
 func SrcinfoHash(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldSrcinfoHash), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldSrcinfoHash, v))
 }
 
 // Pkgbuild applies equality check predicate on the "pkgbuild" field. It's identical to PkgbuildEQ.
 func Pkgbuild(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldPkgbuild), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldPkgbuild, v))
 }
 
 // PkgbaseEQ applies the EQ predicate on the "pkgbase" field.
 func PkgbaseEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldPkgbase), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldPkgbase, v))
 }
 
 // PkgbaseNEQ applies the NEQ predicate on the "pkgbase" field.
 func PkgbaseNEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldPkgbase), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldPkgbase, v))
 }
 
 // PkgbaseIn applies the In predicate on the "pkgbase" field.
 func PkgbaseIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldPkgbase), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldPkgbase, vs...))
 }
 
 // PkgbaseNotIn applies the NotIn predicate on the "pkgbase" field.
 func PkgbaseNotIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldPkgbase), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldPkgbase, vs...))
 }
 
 // PkgbaseGT applies the GT predicate on the "pkgbase" field.
 func PkgbaseGT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldPkgbase), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldPkgbase, v))
 }
 
 // PkgbaseGTE applies the GTE predicate on the "pkgbase" field.
 func PkgbaseGTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldPkgbase), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldPkgbase, v))
 }
 
 // PkgbaseLT applies the LT predicate on the "pkgbase" field.
 func PkgbaseLT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldPkgbase), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldPkgbase, v))
 }
 
 // PkgbaseLTE applies the LTE predicate on the "pkgbase" field.
 func PkgbaseLTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldPkgbase), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldPkgbase, v))
 }
 
 // PkgbaseContains applies the Contains predicate on the "pkgbase" field.
 func PkgbaseContains(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.Contains(s.C(FieldPkgbase), v))
-	})
+	return predicate.DbPackage(sql.FieldContains(FieldPkgbase, v))
 }
 
 // PkgbaseHasPrefix applies the HasPrefix predicate on the "pkgbase" field.
 func PkgbaseHasPrefix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasPrefix(s.C(FieldPkgbase), v))
-	})
+	return predicate.DbPackage(sql.FieldHasPrefix(FieldPkgbase, v))
 }
 
 // PkgbaseHasSuffix applies the HasSuffix predicate on the "pkgbase" field.
 func PkgbaseHasSuffix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasSuffix(s.C(FieldPkgbase), v))
-	})
+	return predicate.DbPackage(sql.FieldHasSuffix(FieldPkgbase, v))
 }
 
 // PkgbaseEqualFold applies the EqualFold predicate on the "pkgbase" field.
 func PkgbaseEqualFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EqualFold(s.C(FieldPkgbase), v))
-	})
+	return predicate.DbPackage(sql.FieldEqualFold(FieldPkgbase, v))
 }
 
 // PkgbaseContainsFold applies the ContainsFold predicate on the "pkgbase" field.
 func PkgbaseContainsFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.ContainsFold(s.C(FieldPkgbase), v))
-	})
+	return predicate.DbPackage(sql.FieldContainsFold(FieldPkgbase, v))
 }
 
 // PackagesIsNil applies the IsNil predicate on the "packages" field.
 func PackagesIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldPackages)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldPackages))
 }
 
 // PackagesNotNil applies the NotNil predicate on the "packages" field.
 func PackagesNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldPackages)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldPackages))
 }
 
 // StatusEQ applies the EQ predicate on the "status" field.
 func StatusEQ(v Status) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldStatus), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldStatus, v))
 }
 
 // StatusNEQ applies the NEQ predicate on the "status" field.
 func StatusNEQ(v Status) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldStatus), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldStatus, v))
 }
 
 // StatusIn applies the In predicate on the "status" field.
 func StatusIn(vs ...Status) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldStatus), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldStatus, vs...))
 }
 
 // StatusNotIn applies the NotIn predicate on the "status" field.
 func StatusNotIn(vs ...Status) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldStatus), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldStatus, vs...))
 }
 
 // StatusIsNil applies the IsNil predicate on the "status" field.
 func StatusIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldStatus)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldStatus))
 }
 
 // StatusNotNil applies the NotNil predicate on the "status" field.
 func StatusNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldStatus)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldStatus))
 }
 
 // SkipReasonEQ applies the EQ predicate on the "skip_reason" field.
 func SkipReasonEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldSkipReason), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldSkipReason, v))
 }
 
 // SkipReasonNEQ applies the NEQ predicate on the "skip_reason" field.
 func SkipReasonNEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldSkipReason), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldSkipReason, v))
 }
 
 // SkipReasonIn applies the In predicate on the "skip_reason" field.
 func SkipReasonIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldSkipReason), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldSkipReason, vs...))
 }
 
 // SkipReasonNotIn applies the NotIn predicate on the "skip_reason" field.
 func SkipReasonNotIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldSkipReason), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldSkipReason, vs...))
 }
 
 // SkipReasonGT applies the GT predicate on the "skip_reason" field.
 func SkipReasonGT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldSkipReason), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldSkipReason, v))
 }
 
 // SkipReasonGTE applies the GTE predicate on the "skip_reason" field.
 func SkipReasonGTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldSkipReason), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldSkipReason, v))
 }
 
 // SkipReasonLT applies the LT predicate on the "skip_reason" field.
 func SkipReasonLT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldSkipReason), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldSkipReason, v))
 }
 
 // SkipReasonLTE applies the LTE predicate on the "skip_reason" field.
 func SkipReasonLTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldSkipReason), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldSkipReason, v))
 }
 
 // SkipReasonContains applies the Contains predicate on the "skip_reason" field.
 func SkipReasonContains(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.Contains(s.C(FieldSkipReason), v))
-	})
+	return predicate.DbPackage(sql.FieldContains(FieldSkipReason, v))
 }
 
 // SkipReasonHasPrefix applies the HasPrefix predicate on the "skip_reason" field.
 func SkipReasonHasPrefix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasPrefix(s.C(FieldSkipReason), v))
-	})
+	return predicate.DbPackage(sql.FieldHasPrefix(FieldSkipReason, v))
 }
 
 // SkipReasonHasSuffix applies the HasSuffix predicate on the "skip_reason" field.
 func SkipReasonHasSuffix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasSuffix(s.C(FieldSkipReason), v))
-	})
+	return predicate.DbPackage(sql.FieldHasSuffix(FieldSkipReason, v))
 }
 
 // SkipReasonIsNil applies the IsNil predicate on the "skip_reason" field.
 func SkipReasonIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldSkipReason)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldSkipReason))
 }
 
 // SkipReasonNotNil applies the NotNil predicate on the "skip_reason" field.
 func SkipReasonNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldSkipReason)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldSkipReason))
 }
 
 // SkipReasonEqualFold applies the EqualFold predicate on the "skip_reason" field.
 func SkipReasonEqualFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EqualFold(s.C(FieldSkipReason), v))
-	})
+	return predicate.DbPackage(sql.FieldEqualFold(FieldSkipReason, v))
 }
 
 // SkipReasonContainsFold applies the ContainsFold predicate on the "skip_reason" field.
 func SkipReasonContainsFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.ContainsFold(s.C(FieldSkipReason), v))
-	})
+	return predicate.DbPackage(sql.FieldContainsFold(FieldSkipReason, v))
 }
 
 // RepositoryEQ applies the EQ predicate on the "repository" field.
 func RepositoryEQ(v Repository) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldRepository), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldRepository, v))
 }
 
 // RepositoryNEQ applies the NEQ predicate on the "repository" field.
 func RepositoryNEQ(v Repository) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldRepository), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldRepository, v))
 }
 
 // RepositoryIn applies the In predicate on the "repository" field.
 func RepositoryIn(vs ...Repository) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldRepository), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldRepository, vs...))
 }
 
 // RepositoryNotIn applies the NotIn predicate on the "repository" field.
 func RepositoryNotIn(vs ...Repository) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldRepository), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldRepository, vs...))
 }
 
 // MarchEQ applies the EQ predicate on the "march" field.
 func MarchEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldMarch), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldMarch, v))
 }
 
 // MarchNEQ applies the NEQ predicate on the "march" field.
 func MarchNEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldMarch), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldMarch, v))
 }
 
 // MarchIn applies the In predicate on the "march" field.
 func MarchIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldMarch), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldMarch, vs...))
 }
 
 // MarchNotIn applies the NotIn predicate on the "march" field.
 func MarchNotIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldMarch), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldMarch, vs...))
 }
 
 // MarchGT applies the GT predicate on the "march" field.
 func MarchGT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldMarch), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldMarch, v))
 }
 
 // MarchGTE applies the GTE predicate on the "march" field.
 func MarchGTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldMarch), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldMarch, v))
 }
 
 // MarchLT applies the LT predicate on the "march" field.
 func MarchLT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldMarch), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldMarch, v))
 }
 
 // MarchLTE applies the LTE predicate on the "march" field.
 func MarchLTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldMarch), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldMarch, v))
 }
 
 // MarchContains applies the Contains predicate on the "march" field.
 func MarchContains(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.Contains(s.C(FieldMarch), v))
-	})
+	return predicate.DbPackage(sql.FieldContains(FieldMarch, v))
 }
 
 // MarchHasPrefix applies the HasPrefix predicate on the "march" field.
 func MarchHasPrefix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasPrefix(s.C(FieldMarch), v))
-	})
+	return predicate.DbPackage(sql.FieldHasPrefix(FieldMarch, v))
 }
 
 // MarchHasSuffix applies the HasSuffix predicate on the "march" field.
 func MarchHasSuffix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasSuffix(s.C(FieldMarch), v))
-	})
+	return predicate.DbPackage(sql.FieldHasSuffix(FieldMarch, v))
 }
 
 // MarchEqualFold applies the EqualFold predicate on the "march" field.
 func MarchEqualFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EqualFold(s.C(FieldMarch), v))
-	})
+	return predicate.DbPackage(sql.FieldEqualFold(FieldMarch, v))
 }
 
 // MarchContainsFold applies the ContainsFold predicate on the "march" field.
 func MarchContainsFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.ContainsFold(s.C(FieldMarch), v))
-	})
+	return predicate.DbPackage(sql.FieldContainsFold(FieldMarch, v))
 }
 
 // VersionEQ applies the EQ predicate on the "version" field.
 func VersionEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldVersion, v))
 }
 
 // VersionNEQ applies the NEQ predicate on the "version" field.
 func VersionNEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldVersion, v))
 }
 
 // VersionIn applies the In predicate on the "version" field.
 func VersionIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldVersion), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldVersion, vs...))
 }
 
 // VersionNotIn applies the NotIn predicate on the "version" field.
 func VersionNotIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldVersion), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldVersion, vs...))
 }
 
 // VersionGT applies the GT predicate on the "version" field.
 func VersionGT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldVersion, v))
 }
 
 // VersionGTE applies the GTE predicate on the "version" field.
 func VersionGTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldVersion, v))
 }
 
 // VersionLT applies the LT predicate on the "version" field.
 func VersionLT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldVersion, v))
 }
 
 // VersionLTE applies the LTE predicate on the "version" field.
 func VersionLTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldVersion, v))
 }
 
 // VersionContains applies the Contains predicate on the "version" field.
 func VersionContains(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.Contains(s.C(FieldVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldContains(FieldVersion, v))
 }
 
 // VersionHasPrefix applies the HasPrefix predicate on the "version" field.
 func VersionHasPrefix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasPrefix(s.C(FieldVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldHasPrefix(FieldVersion, v))
 }
 
 // VersionHasSuffix applies the HasSuffix predicate on the "version" field.
 func VersionHasSuffix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasSuffix(s.C(FieldVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldHasSuffix(FieldVersion, v))
 }
 
 // VersionIsNil applies the IsNil predicate on the "version" field.
 func VersionIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldVersion)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldVersion))
 }
 
 // VersionNotNil applies the NotNil predicate on the "version" field.
 func VersionNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldVersion)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldVersion))
 }
 
 // VersionEqualFold applies the EqualFold predicate on the "version" field.
 func VersionEqualFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EqualFold(s.C(FieldVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldEqualFold(FieldVersion, v))
 }
 
 // VersionContainsFold applies the ContainsFold predicate on the "version" field.
 func VersionContainsFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.ContainsFold(s.C(FieldVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldContainsFold(FieldVersion, v))
 }
 
 // RepoVersionEQ applies the EQ predicate on the "repo_version" field.
 func RepoVersionEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldRepoVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldRepoVersion, v))
 }
 
 // RepoVersionNEQ applies the NEQ predicate on the "repo_version" field.
 func RepoVersionNEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldRepoVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldRepoVersion, v))
 }
 
 // RepoVersionIn applies the In predicate on the "repo_version" field.
 func RepoVersionIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldRepoVersion), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldRepoVersion, vs...))
 }
 
 // RepoVersionNotIn applies the NotIn predicate on the "repo_version" field.
 func RepoVersionNotIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldRepoVersion), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldRepoVersion, vs...))
 }
 
 // RepoVersionGT applies the GT predicate on the "repo_version" field.
 func RepoVersionGT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldRepoVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldRepoVersion, v))
 }
 
 // RepoVersionGTE applies the GTE predicate on the "repo_version" field.
 func RepoVersionGTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldRepoVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldRepoVersion, v))
 }
 
 // RepoVersionLT applies the LT predicate on the "repo_version" field.
 func RepoVersionLT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldRepoVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldRepoVersion, v))
 }
 
 // RepoVersionLTE applies the LTE predicate on the "repo_version" field.
 func RepoVersionLTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldRepoVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldRepoVersion, v))
 }
 
 // RepoVersionContains applies the Contains predicate on the "repo_version" field.
 func RepoVersionContains(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.Contains(s.C(FieldRepoVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldContains(FieldRepoVersion, v))
 }
 
 // RepoVersionHasPrefix applies the HasPrefix predicate on the "repo_version" field.
 func RepoVersionHasPrefix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasPrefix(s.C(FieldRepoVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldHasPrefix(FieldRepoVersion, v))
 }
 
 // RepoVersionHasSuffix applies the HasSuffix predicate on the "repo_version" field.
 func RepoVersionHasSuffix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasSuffix(s.C(FieldRepoVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldHasSuffix(FieldRepoVersion, v))
 }
 
 // RepoVersionIsNil applies the IsNil predicate on the "repo_version" field.
 func RepoVersionIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldRepoVersion)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldRepoVersion))
 }
 
 // RepoVersionNotNil applies the NotNil predicate on the "repo_version" field.
 func RepoVersionNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldRepoVersion)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldRepoVersion))
 }
 
 // RepoVersionEqualFold applies the EqualFold predicate on the "repo_version" field.
 func RepoVersionEqualFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EqualFold(s.C(FieldRepoVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldEqualFold(FieldRepoVersion, v))
 }
 
 // RepoVersionContainsFold applies the ContainsFold predicate on the "repo_version" field.
 func RepoVersionContainsFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.ContainsFold(s.C(FieldRepoVersion), v))
-	})
+	return predicate.DbPackage(sql.FieldContainsFold(FieldRepoVersion, v))
 }
 
 // BuildTimeStartEQ applies the EQ predicate on the "build_time_start" field.
 func BuildTimeStartEQ(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldBuildTimeStart), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldBuildTimeStart, v))
 }
 
 // BuildTimeStartNEQ applies the NEQ predicate on the "build_time_start" field.
 func BuildTimeStartNEQ(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldBuildTimeStart), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldBuildTimeStart, v))
 }
 
 // BuildTimeStartIn applies the In predicate on the "build_time_start" field.
 func BuildTimeStartIn(vs ...time.Time) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldBuildTimeStart), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldBuildTimeStart, vs...))
 }
 
 // BuildTimeStartNotIn applies the NotIn predicate on the "build_time_start" field.
 func BuildTimeStartNotIn(vs ...time.Time) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldBuildTimeStart), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldBuildTimeStart, vs...))
 }
 
 // BuildTimeStartGT applies the GT predicate on the "build_time_start" field.
 func BuildTimeStartGT(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldBuildTimeStart), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldBuildTimeStart, v))
 }
 
 // BuildTimeStartGTE applies the GTE predicate on the "build_time_start" field.
 func BuildTimeStartGTE(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldBuildTimeStart), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldBuildTimeStart, v))
 }
 
 // BuildTimeStartLT applies the LT predicate on the "build_time_start" field.
 func BuildTimeStartLT(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldBuildTimeStart), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldBuildTimeStart, v))
 }
 
 // BuildTimeStartLTE applies the LTE predicate on the "build_time_start" field.
 func BuildTimeStartLTE(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldBuildTimeStart), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldBuildTimeStart, v))
 }
 
 // BuildTimeStartIsNil applies the IsNil predicate on the "build_time_start" field.
 func BuildTimeStartIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldBuildTimeStart)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldBuildTimeStart))
 }
 
 // BuildTimeStartNotNil applies the NotNil predicate on the "build_time_start" field.
 func BuildTimeStartNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldBuildTimeStart)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldBuildTimeStart))
 }
 
 // UpdatedEQ applies the EQ predicate on the "updated" field.
 func UpdatedEQ(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldUpdated), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldUpdated, v))
 }
 
 // UpdatedNEQ applies the NEQ predicate on the "updated" field.
 func UpdatedNEQ(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldUpdated), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldUpdated, v))
 }
 
 // UpdatedIn applies the In predicate on the "updated" field.
 func UpdatedIn(vs ...time.Time) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldUpdated), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldUpdated, vs...))
 }
 
 // UpdatedNotIn applies the NotIn predicate on the "updated" field.
 func UpdatedNotIn(vs ...time.Time) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldUpdated), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldUpdated, vs...))
 }
 
 // UpdatedGT applies the GT predicate on the "updated" field.
 func UpdatedGT(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldUpdated), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldUpdated, v))
 }
 
 // UpdatedGTE applies the GTE predicate on the "updated" field.
 func UpdatedGTE(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldUpdated), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldUpdated, v))
 }
 
 // UpdatedLT applies the LT predicate on the "updated" field.
 func UpdatedLT(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldUpdated), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldUpdated, v))
 }
 
 // UpdatedLTE applies the LTE predicate on the "updated" field.
 func UpdatedLTE(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldUpdated), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldUpdated, v))
 }
 
 // UpdatedIsNil applies the IsNil predicate on the "updated" field.
 func UpdatedIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldUpdated)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldUpdated))
 }
 
 // UpdatedNotNil applies the NotNil predicate on the "updated" field.
 func UpdatedNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldUpdated)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldUpdated))
 }
 
 // HashEQ applies the EQ predicate on the "hash" field.
 func HashEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldHash), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldHash, v))
 }
 
 // HashNEQ applies the NEQ predicate on the "hash" field.
 func HashNEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldHash), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldHash, v))
 }
 
 // HashIn applies the In predicate on the "hash" field.
 func HashIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldHash), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldHash, vs...))
 }
 
 // HashNotIn applies the NotIn predicate on the "hash" field.
 func HashNotIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldHash), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldHash, vs...))
 }
 
 // HashGT applies the GT predicate on the "hash" field.
 func HashGT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldHash), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldHash, v))
 }
 
 // HashGTE applies the GTE predicate on the "hash" field.
 func HashGTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldHash), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldHash, v))
 }
 
 // HashLT applies the LT predicate on the "hash" field.
 func HashLT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldHash), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldHash, v))
 }
 
 // HashLTE applies the LTE predicate on the "hash" field.
 func HashLTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldHash), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldHash, v))
 }
 
 // HashContains applies the Contains predicate on the "hash" field.
 func HashContains(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.Contains(s.C(FieldHash), v))
-	})
+	return predicate.DbPackage(sql.FieldContains(FieldHash, v))
 }
 
 // HashHasPrefix applies the HasPrefix predicate on the "hash" field.
 func HashHasPrefix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasPrefix(s.C(FieldHash), v))
-	})
+	return predicate.DbPackage(sql.FieldHasPrefix(FieldHash, v))
 }
 
 // HashHasSuffix applies the HasSuffix predicate on the "hash" field.
 func HashHasSuffix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasSuffix(s.C(FieldHash), v))
-	})
+	return predicate.DbPackage(sql.FieldHasSuffix(FieldHash, v))
 }
 
 // HashIsNil applies the IsNil predicate on the "hash" field.
 func HashIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldHash)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldHash))
 }
 
 // HashNotNil applies the NotNil predicate on the "hash" field.
 func HashNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldHash)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldHash))
 }
 
 // HashEqualFold applies the EqualFold predicate on the "hash" field.
 func HashEqualFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EqualFold(s.C(FieldHash), v))
-	})
+	return predicate.DbPackage(sql.FieldEqualFold(FieldHash, v))
 }
 
 // HashContainsFold applies the ContainsFold predicate on the "hash" field.
 func HashContainsFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.ContainsFold(s.C(FieldHash), v))
-	})
+	return predicate.DbPackage(sql.FieldContainsFold(FieldHash, v))
 }
 
 // LtoEQ applies the EQ predicate on the "lto" field.
 func LtoEQ(v Lto) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldLto), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldLto, v))
 }
 
 // LtoNEQ applies the NEQ predicate on the "lto" field.
 func LtoNEQ(v Lto) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldLto), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldLto, v))
 }
 
 // LtoIn applies the In predicate on the "lto" field.
 func LtoIn(vs ...Lto) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldLto), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldLto, vs...))
 }
 
 // LtoNotIn applies the NotIn predicate on the "lto" field.
 func LtoNotIn(vs ...Lto) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldLto), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldLto, vs...))
 }
 
 // LtoIsNil applies the IsNil predicate on the "lto" field.
 func LtoIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldLto)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldLto))
 }
 
 // LtoNotNil applies the NotNil predicate on the "lto" field.
 func LtoNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldLto)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldLto))
 }
 
 // LastVersionBuildEQ applies the EQ predicate on the "last_version_build" field.
 func LastVersionBuildEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldLastVersionBuild), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldLastVersionBuild, v))
 }
 
 // LastVersionBuildNEQ applies the NEQ predicate on the "last_version_build" field.
 func LastVersionBuildNEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldLastVersionBuild), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldLastVersionBuild, v))
 }
 
 // LastVersionBuildIn applies the In predicate on the "last_version_build" field.
 func LastVersionBuildIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldLastVersionBuild), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldLastVersionBuild, vs...))
 }
 
 // LastVersionBuildNotIn applies the NotIn predicate on the "last_version_build" field.
 func LastVersionBuildNotIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldLastVersionBuild), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldLastVersionBuild, vs...))
 }
 
 // LastVersionBuildGT applies the GT predicate on the "last_version_build" field.
 func LastVersionBuildGT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldLastVersionBuild), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldLastVersionBuild, v))
 }
 
 // LastVersionBuildGTE applies the GTE predicate on the "last_version_build" field.
 func LastVersionBuildGTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldLastVersionBuild), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldLastVersionBuild, v))
 }
 
 // LastVersionBuildLT applies the LT predicate on the "last_version_build" field.
 func LastVersionBuildLT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldLastVersionBuild), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldLastVersionBuild, v))
 }
 
 // LastVersionBuildLTE applies the LTE predicate on the "last_version_build" field.
 func LastVersionBuildLTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldLastVersionBuild), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldLastVersionBuild, v))
 }
 
 // LastVersionBuildContains applies the Contains predicate on the "last_version_build" field.
 func LastVersionBuildContains(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.Contains(s.C(FieldLastVersionBuild), v))
-	})
+	return predicate.DbPackage(sql.FieldContains(FieldLastVersionBuild, v))
 }
 
 // LastVersionBuildHasPrefix applies the HasPrefix predicate on the "last_version_build" field.
 func LastVersionBuildHasPrefix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasPrefix(s.C(FieldLastVersionBuild), v))
-	})
+	return predicate.DbPackage(sql.FieldHasPrefix(FieldLastVersionBuild, v))
 }
 
 // LastVersionBuildHasSuffix applies the HasSuffix predicate on the "last_version_build" field.
 func LastVersionBuildHasSuffix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasSuffix(s.C(FieldLastVersionBuild), v))
-	})
+	return predicate.DbPackage(sql.FieldHasSuffix(FieldLastVersionBuild, v))
 }
 
 // LastVersionBuildIsNil applies the IsNil predicate on the "last_version_build" field.
 func LastVersionBuildIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldLastVersionBuild)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldLastVersionBuild))
 }
 
 // LastVersionBuildNotNil applies the NotNil predicate on the "last_version_build" field.
 func LastVersionBuildNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldLastVersionBuild)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldLastVersionBuild))
 }
 
 // LastVersionBuildEqualFold applies the EqualFold predicate on the "last_version_build" field.
 func LastVersionBuildEqualFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EqualFold(s.C(FieldLastVersionBuild), v))
-	})
+	return predicate.DbPackage(sql.FieldEqualFold(FieldLastVersionBuild, v))
 }
 
 // LastVersionBuildContainsFold applies the ContainsFold predicate on the "last_version_build" field.
 func LastVersionBuildContainsFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.ContainsFold(s.C(FieldLastVersionBuild), v))
-	})
+	return predicate.DbPackage(sql.FieldContainsFold(FieldLastVersionBuild, v))
 }
 
 // LastVerifiedEQ applies the EQ predicate on the "last_verified" field.
 func LastVerifiedEQ(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldLastVerified), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldLastVerified, v))
 }
 
 // LastVerifiedNEQ applies the NEQ predicate on the "last_verified" field.
 func LastVerifiedNEQ(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldLastVerified), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldLastVerified, v))
 }
 
 // LastVerifiedIn applies the In predicate on the "last_verified" field.
 func LastVerifiedIn(vs ...time.Time) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldLastVerified), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldLastVerified, vs...))
 }
 
 // LastVerifiedNotIn applies the NotIn predicate on the "last_verified" field.
 func LastVerifiedNotIn(vs ...time.Time) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldLastVerified), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldLastVerified, vs...))
 }
 
 // LastVerifiedGT applies the GT predicate on the "last_verified" field.
 func LastVerifiedGT(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldLastVerified), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldLastVerified, v))
 }
 
 // LastVerifiedGTE applies the GTE predicate on the "last_verified" field.
 func LastVerifiedGTE(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldLastVerified), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldLastVerified, v))
 }
 
 // LastVerifiedLT applies the LT predicate on the "last_verified" field.
 func LastVerifiedLT(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldLastVerified), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldLastVerified, v))
 }
 
 // LastVerifiedLTE applies the LTE predicate on the "last_verified" field.
 func LastVerifiedLTE(v time.Time) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldLastVerified), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldLastVerified, v))
 }
 
 // LastVerifiedIsNil applies the IsNil predicate on the "last_verified" field.
 func LastVerifiedIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldLastVerified)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldLastVerified))
 }
 
 // LastVerifiedNotNil applies the NotNil predicate on the "last_verified" field.
 func LastVerifiedNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldLastVerified)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldLastVerified))
 }
 
 // DebugSymbolsEQ applies the EQ predicate on the "debug_symbols" field.
 func DebugSymbolsEQ(v DebugSymbols) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldDebugSymbols), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldDebugSymbols, v))
 }
 
 // DebugSymbolsNEQ applies the NEQ predicate on the "debug_symbols" field.
 func DebugSymbolsNEQ(v DebugSymbols) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldDebugSymbols), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldDebugSymbols, v))
 }
 
 // DebugSymbolsIn applies the In predicate on the "debug_symbols" field.
 func DebugSymbolsIn(vs ...DebugSymbols) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldDebugSymbols), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldDebugSymbols, vs...))
 }
 
 // DebugSymbolsNotIn applies the NotIn predicate on the "debug_symbols" field.
 func DebugSymbolsNotIn(vs ...DebugSymbols) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldDebugSymbols), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldDebugSymbols, vs...))
 }
 
 // DebugSymbolsIsNil applies the IsNil predicate on the "debug_symbols" field.
 func DebugSymbolsIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldDebugSymbols)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldDebugSymbols))
 }
 
 // DebugSymbolsNotNil applies the NotNil predicate on the "debug_symbols" field.
 func DebugSymbolsNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldDebugSymbols)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldDebugSymbols))
 }
 
 // MaxRssEQ applies the EQ predicate on the "max_rss" field.
 func MaxRssEQ(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldMaxRss), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldMaxRss, v))
 }
 
 // MaxRssNEQ applies the NEQ predicate on the "max_rss" field.
 func MaxRssNEQ(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldMaxRss), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldMaxRss, v))
 }
 
 // MaxRssIn applies the In predicate on the "max_rss" field.
 func MaxRssIn(vs ...int64) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldMaxRss), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldMaxRss, vs...))
 }
 
 // MaxRssNotIn applies the NotIn predicate on the "max_rss" field.
 func MaxRssNotIn(vs ...int64) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldMaxRss), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldMaxRss, vs...))
 }
 
 // MaxRssGT applies the GT predicate on the "max_rss" field.
 func MaxRssGT(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldMaxRss), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldMaxRss, v))
 }
 
 // MaxRssGTE applies the GTE predicate on the "max_rss" field.
 func MaxRssGTE(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldMaxRss), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldMaxRss, v))
 }
 
 // MaxRssLT applies the LT predicate on the "max_rss" field.
 func MaxRssLT(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldMaxRss), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldMaxRss, v))
 }
 
 // MaxRssLTE applies the LTE predicate on the "max_rss" field.
 func MaxRssLTE(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldMaxRss), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldMaxRss, v))
 }
 
 // MaxRssIsNil applies the IsNil predicate on the "max_rss" field.
 func MaxRssIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldMaxRss)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldMaxRss))
 }
 
 // MaxRssNotNil applies the NotNil predicate on the "max_rss" field.
 func MaxRssNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldMaxRss)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldMaxRss))
 }
 
 // UTimeEQ applies the EQ predicate on the "u_time" field.
 func UTimeEQ(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldUTime), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldUTime, v))
 }
 
 // UTimeNEQ applies the NEQ predicate on the "u_time" field.
 func UTimeNEQ(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldUTime), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldUTime, v))
 }
 
 // UTimeIn applies the In predicate on the "u_time" field.
 func UTimeIn(vs ...int64) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldUTime), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldUTime, vs...))
 }
 
 // UTimeNotIn applies the NotIn predicate on the "u_time" field.
 func UTimeNotIn(vs ...int64) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldUTime), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldUTime, vs...))
 }
 
 // UTimeGT applies the GT predicate on the "u_time" field.
 func UTimeGT(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldUTime), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldUTime, v))
 }
 
 // UTimeGTE applies the GTE predicate on the "u_time" field.
 func UTimeGTE(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldUTime), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldUTime, v))
 }
 
 // UTimeLT applies the LT predicate on the "u_time" field.
 func UTimeLT(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldUTime), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldUTime, v))
 }
 
 // UTimeLTE applies the LTE predicate on the "u_time" field.
 func UTimeLTE(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldUTime), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldUTime, v))
 }
 
 // UTimeIsNil applies the IsNil predicate on the "u_time" field.
 func UTimeIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldUTime)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldUTime))
 }
 
 // UTimeNotNil applies the NotNil predicate on the "u_time" field.
 func UTimeNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldUTime)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldUTime))
 }
 
 // STimeEQ applies the EQ predicate on the "s_time" field.
 func STimeEQ(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldSTime), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldSTime, v))
 }
 
 // STimeNEQ applies the NEQ predicate on the "s_time" field.
 func STimeNEQ(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldSTime), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldSTime, v))
 }
 
 // STimeIn applies the In predicate on the "s_time" field.
 func STimeIn(vs ...int64) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldSTime), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldSTime, vs...))
 }
 
 // STimeNotIn applies the NotIn predicate on the "s_time" field.
 func STimeNotIn(vs ...int64) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldSTime), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldSTime, vs...))
 }
 
 // STimeGT applies the GT predicate on the "s_time" field.
 func STimeGT(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldSTime), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldSTime, v))
 }
 
 // STimeGTE applies the GTE predicate on the "s_time" field.
 func STimeGTE(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldSTime), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldSTime, v))
 }
 
 // STimeLT applies the LT predicate on the "s_time" field.
 func STimeLT(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldSTime), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldSTime, v))
 }
 
 // STimeLTE applies the LTE predicate on the "s_time" field.
 func STimeLTE(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldSTime), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldSTime, v))
 }
 
 // STimeIsNil applies the IsNil predicate on the "s_time" field.
 func STimeIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldSTime)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldSTime))
 }
 
 // STimeNotNil applies the NotNil predicate on the "s_time" field.
 func STimeNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldSTime)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldSTime))
 }
 
 // IoInEQ applies the EQ predicate on the "io_in" field.
 func IoInEQ(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldIoIn), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldIoIn, v))
 }
 
 // IoInNEQ applies the NEQ predicate on the "io_in" field.
 func IoInNEQ(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldIoIn), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldIoIn, v))
 }
 
 // IoInIn applies the In predicate on the "io_in" field.
 func IoInIn(vs ...int64) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldIoIn), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldIoIn, vs...))
 }
 
 // IoInNotIn applies the NotIn predicate on the "io_in" field.
 func IoInNotIn(vs ...int64) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldIoIn), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldIoIn, vs...))
 }
 
 // IoInGT applies the GT predicate on the "io_in" field.
 func IoInGT(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldIoIn), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldIoIn, v))
 }
 
 // IoInGTE applies the GTE predicate on the "io_in" field.
 func IoInGTE(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldIoIn), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldIoIn, v))
 }
 
 // IoInLT applies the LT predicate on the "io_in" field.
 func IoInLT(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldIoIn), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldIoIn, v))
 }
 
 // IoInLTE applies the LTE predicate on the "io_in" field.
 func IoInLTE(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldIoIn), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldIoIn, v))
 }
 
 // IoInIsNil applies the IsNil predicate on the "io_in" field.
 func IoInIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldIoIn)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldIoIn))
 }
 
 // IoInNotNil applies the NotNil predicate on the "io_in" field.
 func IoInNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldIoIn)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldIoIn))
 }
 
 // IoOutEQ applies the EQ predicate on the "io_out" field.
 func IoOutEQ(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldIoOut), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldIoOut, v))
 }
 
 // IoOutNEQ applies the NEQ predicate on the "io_out" field.
 func IoOutNEQ(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldIoOut), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldIoOut, v))
 }
 
 // IoOutIn applies the In predicate on the "io_out" field.
 func IoOutIn(vs ...int64) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldIoOut), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldIoOut, vs...))
 }
 
 // IoOutNotIn applies the NotIn predicate on the "io_out" field.
 func IoOutNotIn(vs ...int64) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldIoOut), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldIoOut, vs...))
 }
 
 // IoOutGT applies the GT predicate on the "io_out" field.
 func IoOutGT(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldIoOut), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldIoOut, v))
 }
 
 // IoOutGTE applies the GTE predicate on the "io_out" field.
 func IoOutGTE(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldIoOut), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldIoOut, v))
 }
 
 // IoOutLT applies the LT predicate on the "io_out" field.
 func IoOutLT(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldIoOut), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldIoOut, v))
 }
 
 // IoOutLTE applies the LTE predicate on the "io_out" field.
 func IoOutLTE(v int64) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldIoOut), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldIoOut, v))
 }
 
 // IoOutIsNil applies the IsNil predicate on the "io_out" field.
 func IoOutIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldIoOut)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldIoOut))
 }
 
 // IoOutNotNil applies the NotNil predicate on the "io_out" field.
 func IoOutNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldIoOut)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldIoOut))
 }
 
 // SrcinfoEQ applies the EQ predicate on the "srcinfo" field.
 func SrcinfoEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldSrcinfo), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldSrcinfo, v))
 }
 
 // SrcinfoNEQ applies the NEQ predicate on the "srcinfo" field.
 func SrcinfoNEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldSrcinfo), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldSrcinfo, v))
 }
 
 // SrcinfoIn applies the In predicate on the "srcinfo" field.
 func SrcinfoIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldSrcinfo), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldSrcinfo, vs...))
 }
 
 // SrcinfoNotIn applies the NotIn predicate on the "srcinfo" field.
 func SrcinfoNotIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldSrcinfo), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldSrcinfo, vs...))
 }
 
 // SrcinfoGT applies the GT predicate on the "srcinfo" field.
 func SrcinfoGT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldSrcinfo), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldSrcinfo, v))
 }
 
 // SrcinfoGTE applies the GTE predicate on the "srcinfo" field.
 func SrcinfoGTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldSrcinfo), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldSrcinfo, v))
 }
 
 // SrcinfoLT applies the LT predicate on the "srcinfo" field.
 func SrcinfoLT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldSrcinfo), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldSrcinfo, v))
 }
 
 // SrcinfoLTE applies the LTE predicate on the "srcinfo" field.
 func SrcinfoLTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldSrcinfo), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldSrcinfo, v))
 }
 
 // SrcinfoContains applies the Contains predicate on the "srcinfo" field.
 func SrcinfoContains(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.Contains(s.C(FieldSrcinfo), v))
-	})
+	return predicate.DbPackage(sql.FieldContains(FieldSrcinfo, v))
 }
 
 // SrcinfoHasPrefix applies the HasPrefix predicate on the "srcinfo" field.
 func SrcinfoHasPrefix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasPrefix(s.C(FieldSrcinfo), v))
-	})
+	return predicate.DbPackage(sql.FieldHasPrefix(FieldSrcinfo, v))
 }
 
 // SrcinfoHasSuffix applies the HasSuffix predicate on the "srcinfo" field.
 func SrcinfoHasSuffix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasSuffix(s.C(FieldSrcinfo), v))
-	})
+	return predicate.DbPackage(sql.FieldHasSuffix(FieldSrcinfo, v))
 }
 
 // SrcinfoIsNil applies the IsNil predicate on the "srcinfo" field.
 func SrcinfoIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldSrcinfo)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldSrcinfo))
 }
 
 // SrcinfoNotNil applies the NotNil predicate on the "srcinfo" field.
 func SrcinfoNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldSrcinfo)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldSrcinfo))
 }
 
 // SrcinfoEqualFold applies the EqualFold predicate on the "srcinfo" field.
 func SrcinfoEqualFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EqualFold(s.C(FieldSrcinfo), v))
-	})
+	return predicate.DbPackage(sql.FieldEqualFold(FieldSrcinfo, v))
 }
 
 // SrcinfoContainsFold applies the ContainsFold predicate on the "srcinfo" field.
 func SrcinfoContainsFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.ContainsFold(s.C(FieldSrcinfo), v))
-	})
+	return predicate.DbPackage(sql.FieldContainsFold(FieldSrcinfo, v))
 }
 
 // SrcinfoHashEQ applies the EQ predicate on the "srcinfo_hash" field.
 func SrcinfoHashEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldSrcinfoHash), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldSrcinfoHash, v))
 }
 
 // SrcinfoHashNEQ applies the NEQ predicate on the "srcinfo_hash" field.
 func SrcinfoHashNEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldSrcinfoHash), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldSrcinfoHash, v))
 }
 
 // SrcinfoHashIn applies the In predicate on the "srcinfo_hash" field.
 func SrcinfoHashIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldSrcinfoHash), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldSrcinfoHash, vs...))
 }
 
 // SrcinfoHashNotIn applies the NotIn predicate on the "srcinfo_hash" field.
 func SrcinfoHashNotIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldSrcinfoHash), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldSrcinfoHash, vs...))
 }
 
 // SrcinfoHashGT applies the GT predicate on the "srcinfo_hash" field.
 func SrcinfoHashGT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldSrcinfoHash), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldSrcinfoHash, v))
 }
 
 // SrcinfoHashGTE applies the GTE predicate on the "srcinfo_hash" field.
 func SrcinfoHashGTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldSrcinfoHash), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldSrcinfoHash, v))
 }
 
 // SrcinfoHashLT applies the LT predicate on the "srcinfo_hash" field.
 func SrcinfoHashLT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldSrcinfoHash), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldSrcinfoHash, v))
 }
 
 // SrcinfoHashLTE applies the LTE predicate on the "srcinfo_hash" field.
 func SrcinfoHashLTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldSrcinfoHash), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldSrcinfoHash, v))
 }
 
 // SrcinfoHashContains applies the Contains predicate on the "srcinfo_hash" field.
 func SrcinfoHashContains(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.Contains(s.C(FieldSrcinfoHash), v))
-	})
+	return predicate.DbPackage(sql.FieldContains(FieldSrcinfoHash, v))
 }
 
 // SrcinfoHashHasPrefix applies the HasPrefix predicate on the "srcinfo_hash" field.
 func SrcinfoHashHasPrefix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasPrefix(s.C(FieldSrcinfoHash), v))
-	})
+	return predicate.DbPackage(sql.FieldHasPrefix(FieldSrcinfoHash, v))
 }
 
 // SrcinfoHashHasSuffix applies the HasSuffix predicate on the "srcinfo_hash" field.
 func SrcinfoHashHasSuffix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasSuffix(s.C(FieldSrcinfoHash), v))
-	})
+	return predicate.DbPackage(sql.FieldHasSuffix(FieldSrcinfoHash, v))
 }
 
 // SrcinfoHashIsNil applies the IsNil predicate on the "srcinfo_hash" field.
 func SrcinfoHashIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldSrcinfoHash)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldSrcinfoHash))
 }
 
 // SrcinfoHashNotNil applies the NotNil predicate on the "srcinfo_hash" field.
 func SrcinfoHashNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldSrcinfoHash)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldSrcinfoHash))
 }
 
 // SrcinfoHashEqualFold applies the EqualFold predicate on the "srcinfo_hash" field.
 func SrcinfoHashEqualFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EqualFold(s.C(FieldSrcinfoHash), v))
-	})
+	return predicate.DbPackage(sql.FieldEqualFold(FieldSrcinfoHash, v))
 }
 
 // SrcinfoHashContainsFold applies the ContainsFold predicate on the "srcinfo_hash" field.
 func SrcinfoHashContainsFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.ContainsFold(s.C(FieldSrcinfoHash), v))
-	})
+	return predicate.DbPackage(sql.FieldContainsFold(FieldSrcinfoHash, v))
 }
 
 // PkgbuildEQ applies the EQ predicate on the "pkgbuild" field.
 func PkgbuildEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldPkgbuild), v))
-	})
+	return predicate.DbPackage(sql.FieldEQ(FieldPkgbuild, v))
 }
 
 // PkgbuildNEQ applies the NEQ predicate on the "pkgbuild" field.
 func PkgbuildNEQ(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldPkgbuild), v))
-	})
+	return predicate.DbPackage(sql.FieldNEQ(FieldPkgbuild, v))
 }
 
 // PkgbuildIn applies the In predicate on the "pkgbuild" field.
 func PkgbuildIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldPkgbuild), v...))
-	})
+	return predicate.DbPackage(sql.FieldIn(FieldPkgbuild, vs...))
 }
 
 // PkgbuildNotIn applies the NotIn predicate on the "pkgbuild" field.
 func PkgbuildNotIn(vs ...string) predicate.DbPackage {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldPkgbuild), v...))
-	})
+	return predicate.DbPackage(sql.FieldNotIn(FieldPkgbuild, vs...))
 }
 
 // PkgbuildGT applies the GT predicate on the "pkgbuild" field.
 func PkgbuildGT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldPkgbuild), v))
-	})
+	return predicate.DbPackage(sql.FieldGT(FieldPkgbuild, v))
 }
 
 // PkgbuildGTE applies the GTE predicate on the "pkgbuild" field.
 func PkgbuildGTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldPkgbuild), v))
-	})
+	return predicate.DbPackage(sql.FieldGTE(FieldPkgbuild, v))
 }
 
 // PkgbuildLT applies the LT predicate on the "pkgbuild" field.
 func PkgbuildLT(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldPkgbuild), v))
-	})
+	return predicate.DbPackage(sql.FieldLT(FieldPkgbuild, v))
 }
 
 // PkgbuildLTE applies the LTE predicate on the "pkgbuild" field.
 func PkgbuildLTE(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldPkgbuild), v))
-	})
+	return predicate.DbPackage(sql.FieldLTE(FieldPkgbuild, v))
 }
 
 // PkgbuildContains applies the Contains predicate on the "pkgbuild" field.
 func PkgbuildContains(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.Contains(s.C(FieldPkgbuild), v))
-	})
+	return predicate.DbPackage(sql.FieldContains(FieldPkgbuild, v))
 }
 
 // PkgbuildHasPrefix applies the HasPrefix predicate on the "pkgbuild" field.
 func PkgbuildHasPrefix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasPrefix(s.C(FieldPkgbuild), v))
-	})
+	return predicate.DbPackage(sql.FieldHasPrefix(FieldPkgbuild, v))
 }
 
 // PkgbuildHasSuffix applies the HasSuffix predicate on the "pkgbuild" field.
 func PkgbuildHasSuffix(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.HasSuffix(s.C(FieldPkgbuild), v))
-	})
+	return predicate.DbPackage(sql.FieldHasSuffix(FieldPkgbuild, v))
 }
 
 // PkgbuildIsNil applies the IsNil predicate on the "pkgbuild" field.
 func PkgbuildIsNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.IsNull(s.C(FieldPkgbuild)))
-	})
+	return predicate.DbPackage(sql.FieldIsNull(FieldPkgbuild))
 }
 
 // PkgbuildNotNil applies the NotNil predicate on the "pkgbuild" field.
 func PkgbuildNotNil() predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.NotNull(s.C(FieldPkgbuild)))
-	})
+	return predicate.DbPackage(sql.FieldNotNull(FieldPkgbuild))
 }
 
 // PkgbuildEqualFold applies the EqualFold predicate on the "pkgbuild" field.
 func PkgbuildEqualFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.EqualFold(s.C(FieldPkgbuild), v))
-	})
+	return predicate.DbPackage(sql.FieldEqualFold(FieldPkgbuild, v))
 }
 
 // PkgbuildContainsFold applies the ContainsFold predicate on the "pkgbuild" field.
 func PkgbuildContainsFold(v string) predicate.DbPackage {
-	return predicate.DbPackage(func(s *sql.Selector) {
-		s.Where(sql.ContainsFold(s.C(FieldPkgbuild), v))
-	})
+	return predicate.DbPackage(sql.FieldContainsFold(FieldPkgbuild, v))
 }
 
 // And groups predicates with the AND operator between them.
diff --git a/ent/dbpackage_create.go b/ent/dbpackage_create.go
index b168bb5..27ecf4f 100644
--- a/ent/dbpackage_create.go
+++ b/ent/dbpackage_create.go
@@ -317,50 +317,8 @@ func (dpc *DbPackageCreate) Mutation() *DbPackageMutation {
 
 // Save creates the DbPackage in the database.
 func (dpc *DbPackageCreate) Save(ctx context.Context) (*DbPackage, error) {
-	var (
-		err  error
-		node *DbPackage
-	)
 	dpc.defaults()
-	if len(dpc.hooks) == 0 {
-		if err = dpc.check(); err != nil {
-			return nil, err
-		}
-		node, err = dpc.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*DbPackageMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = dpc.check(); err != nil {
-				return nil, err
-			}
-			dpc.mutation = mutation
-			if node, err = dpc.sqlSave(ctx); err != nil {
-				return nil, err
-			}
-			mutation.id = &node.ID
-			mutation.done = true
-			return node, err
-		})
-		for i := len(dpc.hooks) - 1; i >= 0; i-- {
-			if dpc.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = dpc.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, dpc.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*DbPackage)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from DbPackageMutation", v)
-		}
-		node = nv
-	}
-	return node, err
+	return withHooks[*DbPackage, DbPackageMutation](ctx, dpc.sqlSave, dpc.mutation, dpc.hooks)
 }
 
 // SaveX calls Save and panics if Save returns an error.
@@ -446,6 +404,9 @@ func (dpc *DbPackageCreate) check() error {
 }
 
 func (dpc *DbPackageCreate) sqlSave(ctx context.Context) (*DbPackage, error) {
+	if err := dpc.check(); err != nil {
+		return nil, err
+	}
 	_node, _spec := dpc.createSpec()
 	if err := sqlgraph.CreateNode(ctx, dpc.driver, _spec); err != nil {
 		if sqlgraph.IsConstraintError(err) {
@@ -455,6 +416,8 @@ 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
 	return _node, nil
 }
 
diff --git a/ent/dbpackage_delete.go b/ent/dbpackage_delete.go
index f501fe6..2f7b4c2 100644
--- a/ent/dbpackage_delete.go
+++ b/ent/dbpackage_delete.go
@@ -4,7 +4,6 @@ package ent
 
 import (
 	"context"
-	"fmt"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -28,34 +27,7 @@ func (dpd *DbPackageDelete) Where(ps ...predicate.DbPackage) *DbPackageDelete {
 
 // Exec executes the deletion query and returns how many vertices were deleted.
 func (dpd *DbPackageDelete) Exec(ctx context.Context) (int, error) {
-	var (
-		err      error
-		affected int
-	)
-	if len(dpd.hooks) == 0 {
-		affected, err = dpd.sqlExec(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*DbPackageMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			dpd.mutation = mutation
-			affected, err = dpd.sqlExec(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(dpd.hooks) - 1; i >= 0; i-- {
-			if dpd.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = dpd.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, dpd.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
+	return withHooks[int, DbPackageMutation](ctx, dpd.sqlExec, dpd.mutation, dpd.hooks)
 }
 
 // ExecX is like Exec, but panics if an error occurs.
@@ -88,6 +60,7 @@ func (dpd *DbPackageDelete) sqlExec(ctx context.Context) (int, error) {
 	if err != nil && sqlgraph.IsConstraintError(err) {
 		err = &ConstraintError{msg: err.Error(), wrap: err}
 	}
+	dpd.mutation.done = true
 	return affected, err
 }
 
diff --git a/ent/dbpackage_query.go b/ent/dbpackage_query.go
index 409792b..55e2eb4 100644
--- a/ent/dbpackage_query.go
+++ b/ent/dbpackage_query.go
@@ -22,6 +22,7 @@ type DbPackageQuery struct {
 	unique     *bool
 	order      []OrderFunc
 	fields     []string
+	inters     []Interceptor
 	predicates []predicate.DbPackage
 	modifiers  []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
@@ -35,13 +36,13 @@ func (dpq *DbPackageQuery) Where(ps ...predicate.DbPackage) *DbPackageQuery {
 	return dpq
 }
 
-// Limit adds a limit step to the query.
+// Limit the number of records to be returned by this query.
 func (dpq *DbPackageQuery) Limit(limit int) *DbPackageQuery {
 	dpq.limit = &limit
 	return dpq
 }
 
-// Offset adds an offset step to the query.
+// Offset to start from.
 func (dpq *DbPackageQuery) Offset(offset int) *DbPackageQuery {
 	dpq.offset = &offset
 	return dpq
@@ -54,7 +55,7 @@ func (dpq *DbPackageQuery) Unique(unique bool) *DbPackageQuery {
 	return dpq
 }
 
-// Order adds an order step to the query.
+// Order specifies how the records should be ordered.
 func (dpq *DbPackageQuery) Order(o ...OrderFunc) *DbPackageQuery {
 	dpq.order = append(dpq.order, o...)
 	return dpq
@@ -63,7 +64,7 @@ func (dpq *DbPackageQuery) Order(o ...OrderFunc) *DbPackageQuery {
 // 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(ctx)
+	nodes, err := dpq.Limit(1).All(newQueryContext(ctx, TypeDbPackage, "First"))
 	if err != nil {
 		return nil, err
 	}
@@ -86,7 +87,7 @@ func (dpq *DbPackageQuery) FirstX(ctx context.Context) *DbPackage {
 // Returns a *NotFoundError when no DbPackage ID was found.
 func (dpq *DbPackageQuery) FirstID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = dpq.Limit(1).IDs(ctx); err != nil {
+	if ids, err = dpq.Limit(1).IDs(newQueryContext(ctx, TypeDbPackage, "FirstID")); err != nil {
 		return
 	}
 	if len(ids) == 0 {
@@ -109,7 +110,7 @@ func (dpq *DbPackageQuery) FirstIDX(ctx context.Context) int {
 // 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(ctx)
+	nodes, err := dpq.Limit(2).All(newQueryContext(ctx, TypeDbPackage, "Only"))
 	if err != nil {
 		return nil, err
 	}
@@ -137,7 +138,7 @@ func (dpq *DbPackageQuery) OnlyX(ctx context.Context) *DbPackage {
 // Returns a *NotFoundError when no entities are found.
 func (dpq *DbPackageQuery) OnlyID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = dpq.Limit(2).IDs(ctx); err != nil {
+	if ids, err = dpq.Limit(2).IDs(newQueryContext(ctx, TypeDbPackage, "OnlyID")); err != nil {
 		return
 	}
 	switch len(ids) {
@@ -162,10 +163,12 @@ 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 = newQueryContext(ctx, TypeDbPackage, "All")
 	if err := dpq.prepareQuery(ctx); err != nil {
 		return nil, err
 	}
-	return dpq.sqlAll(ctx)
+	qr := querierAll[[]*DbPackage, *DbPackageQuery]()
+	return withInterceptors[[]*DbPackage](ctx, dpq, qr, dpq.inters)
 }
 
 // AllX is like All, but panics if an error occurs.
@@ -180,6 +183,7 @@ 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) ([]int, error) {
 	var ids []int
+	ctx = newQueryContext(ctx, TypeDbPackage, "IDs")
 	if err := dpq.Select(dbpackage.FieldID).Scan(ctx, &ids); err != nil {
 		return nil, err
 	}
@@ -197,10 +201,11 @@ 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 = newQueryContext(ctx, TypeDbPackage, "Count")
 	if err := dpq.prepareQuery(ctx); err != nil {
 		return 0, err
 	}
-	return dpq.sqlCount(ctx)
+	return withInterceptors[int](ctx, dpq, querierCount[*DbPackageQuery](), dpq.inters)
 }
 
 // CountX is like Count, but panics if an error occurs.
@@ -214,10 +219,15 @@ 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) {
-	if err := dpq.prepareQuery(ctx); err != nil {
-		return false, err
+	ctx = newQueryContext(ctx, TypeDbPackage, "Exist")
+	switch _, err := dpq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("ent: check existence: %w", err)
+	default:
+		return true, nil
 	}
-	return dpq.sqlExist(ctx)
 }
 
 // ExistX is like Exist, but panics if an error occurs.
@@ -240,6 +250,7 @@ func (dpq *DbPackageQuery) Clone() *DbPackageQuery {
 		limit:      dpq.limit,
 		offset:     dpq.offset,
 		order:      append([]OrderFunc{}, dpq.order...),
+		inters:     append([]Interceptor{}, dpq.inters...),
 		predicates: append([]predicate.DbPackage{}, dpq.predicates...),
 		// clone intermediate query.
 		sql:    dpq.sql.Clone(),
@@ -263,16 +274,11 @@ func (dpq *DbPackageQuery) Clone() *DbPackageQuery {
 //		Aggregate(ent.Count()).
 //		Scan(ctx, &v)
 func (dpq *DbPackageQuery) GroupBy(field string, fields ...string) *DbPackageGroupBy {
-	grbuild := &DbPackageGroupBy{config: dpq.config}
-	grbuild.fields = append([]string{field}, fields...)
-	grbuild.path = func(ctx context.Context) (prev *sql.Selector, err error) {
-		if err := dpq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		return dpq.sqlQuery(ctx), nil
-	}
+	dpq.fields = append([]string{field}, fields...)
+	grbuild := &DbPackageGroupBy{build: dpq}
+	grbuild.flds = &dpq.fields
 	grbuild.label = dbpackage.Label
-	grbuild.flds, grbuild.scan = &grbuild.fields, grbuild.Scan
+	grbuild.scan = grbuild.Scan
 	return grbuild
 }
 
@@ -290,10 +296,10 @@ func (dpq *DbPackageQuery) GroupBy(field string, fields ...string) *DbPackageGro
 //		Scan(ctx, &v)
 func (dpq *DbPackageQuery) Select(fields ...string) *DbPackageSelect {
 	dpq.fields = append(dpq.fields, fields...)
-	selbuild := &DbPackageSelect{DbPackageQuery: dpq}
-	selbuild.label = dbpackage.Label
-	selbuild.flds, selbuild.scan = &dpq.fields, selbuild.Scan
-	return selbuild
+	sbuild := &DbPackageSelect{DbPackageQuery: dpq}
+	sbuild.label = dbpackage.Label
+	sbuild.flds, sbuild.scan = &dpq.fields, sbuild.Scan
+	return sbuild
 }
 
 // Aggregate returns a DbPackageSelect configured with the given aggregations.
@@ -302,6 +308,16 @@ func (dpq *DbPackageQuery) Aggregate(fns ...AggregateFunc) *DbPackageSelect {
 }
 
 func (dpq *DbPackageQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range dpq.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 {
+				return err
+			}
+		}
+	}
 	for _, f := range dpq.fields {
 		if !dbpackage.ValidColumn(f) {
 			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
@@ -357,17 +373,6 @@ func (dpq *DbPackageQuery) sqlCount(ctx context.Context) (int, error) {
 	return sqlgraph.CountNodes(ctx, dpq.driver, _spec)
 }
 
-func (dpq *DbPackageQuery) sqlExist(ctx context.Context) (bool, error) {
-	switch _, err := dpq.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
 func (dpq *DbPackageQuery) querySpec() *sqlgraph.QuerySpec {
 	_spec := &sqlgraph.QuerySpec{
 		Node: &sqlgraph.NodeSpec{
@@ -459,13 +464,8 @@ func (dpq *DbPackageQuery) Modify(modifiers ...func(s *sql.Selector)) *DbPackage
 
 // DbPackageGroupBy is the group-by builder for DbPackage entities.
 type DbPackageGroupBy struct {
-	config
 	selector
-	fields []string
-	fns    []AggregateFunc
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
+	build *DbPackageQuery
 }
 
 // Aggregate adds the given aggregation functions to the group-by query.
@@ -474,58 +474,46 @@ func (dpgb *DbPackageGroupBy) Aggregate(fns ...AggregateFunc) *DbPackageGroupBy
 	return dpgb
 }
 
-// Scan applies the group-by query and scans the result into the given value.
+// Scan applies the selector query and scans the result into the given value.
 func (dpgb *DbPackageGroupBy) Scan(ctx context.Context, v any) error {
-	query, err := dpgb.path(ctx)
-	if err != nil {
+	ctx = newQueryContext(ctx, TypeDbPackage, "GroupBy")
+	if err := dpgb.build.prepareQuery(ctx); err != nil {
 		return err
 	}
-	dpgb.sql = query
-	return dpgb.sqlScan(ctx, v)
+	return scanWithInterceptors[*DbPackageQuery, *DbPackageGroupBy](ctx, dpgb.build, dpgb, dpgb.build.inters, v)
 }
 
-func (dpgb *DbPackageGroupBy) sqlScan(ctx context.Context, v any) error {
-	for _, f := range dpgb.fields {
-		if !dbpackage.ValidColumn(f) {
-			return &ValidationError{Name: f, err: fmt.Errorf("invalid field %q for group-by", f)}
-		}
+func (dpgb *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 = append(aggregation, fn(selector))
 	}
-	selector := dpgb.sqlQuery()
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*dpgb.flds)+len(dpgb.fns))
+		for _, f := range *dpgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*dpgb.flds...)...)
 	if err := selector.Err(); err != nil {
 		return err
 	}
 	rows := &sql.Rows{}
 	query, args := selector.Query()
-	if err := dpgb.driver.Query(ctx, query, args, rows); err != nil {
+	if err := dpgb.build.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
 
-func (dpgb *DbPackageGroupBy) sqlQuery() *sql.Selector {
-	selector := dpgb.sql.Select()
-	aggregation := make([]string, 0, len(dpgb.fns))
-	for _, fn := range dpgb.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(dpgb.fields)+len(dpgb.fns))
-		for _, f := range dpgb.fields {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	return selector.GroupBy(selector.Columns(dpgb.fields...)...)
-}
-
 // DbPackageSelect is the builder for selecting fields of DbPackage entities.
 type DbPackageSelect struct {
 	*DbPackageQuery
 	selector
-	// intermediate query (i.e. traversal path).
-	sql *sql.Selector
 }
 
 // Aggregate adds the given aggregation functions to the selector query.
@@ -536,26 +524,27 @@ func (dps *DbPackageSelect) Aggregate(fns ...AggregateFunc) *DbPackageSelect {
 
 // Scan applies the selector query and scans the result into the given value.
 func (dps *DbPackageSelect) Scan(ctx context.Context, v any) error {
+	ctx = newQueryContext(ctx, TypeDbPackage, "Select")
 	if err := dps.prepareQuery(ctx); err != nil {
 		return err
 	}
-	dps.sql = dps.DbPackageQuery.sqlQuery(ctx)
-	return dps.sqlScan(ctx, v)
+	return scanWithInterceptors[*DbPackageQuery, *DbPackageSelect](ctx, dps.DbPackageQuery, dps, dps.inters, v)
 }
 
-func (dps *DbPackageSelect) sqlScan(ctx context.Context, v any) error {
+func (dps *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 = append(aggregation, fn(dps.sql))
+		aggregation = append(aggregation, fn(selector))
 	}
 	switch n := len(*dps.selector.flds); {
 	case n == 0 && len(aggregation) > 0:
-		dps.sql.Select(aggregation...)
+		selector.Select(aggregation...)
 	case n != 0 && len(aggregation) > 0:
-		dps.sql.AppendSelect(aggregation...)
+		selector.AppendSelect(aggregation...)
 	}
 	rows := &sql.Rows{}
-	query, args := dps.sql.Query()
+	query, args := selector.Query()
 	if err := dps.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}
diff --git a/ent/dbpackage_update.go b/ent/dbpackage_update.go
index 9a83d2f..f6b2c1f 100644
--- a/ent/dbpackage_update.go
+++ b/ent/dbpackage_update.go
@@ -476,40 +476,7 @@ func (dpu *DbPackageUpdate) Mutation() *DbPackageMutation {
 
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (dpu *DbPackageUpdate) Save(ctx context.Context) (int, error) {
-	var (
-		err      error
-		affected int
-	)
-	if len(dpu.hooks) == 0 {
-		if err = dpu.check(); err != nil {
-			return 0, err
-		}
-		affected, err = dpu.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*DbPackageMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = dpu.check(); err != nil {
-				return 0, err
-			}
-			dpu.mutation = mutation
-			affected, err = dpu.sqlSave(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(dpu.hooks) - 1; i >= 0; i-- {
-			if dpu.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = dpu.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, dpu.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
+	return withHooks[int, DbPackageMutation](ctx, dpu.sqlSave, dpu.mutation, dpu.hooks)
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -566,6 +533,9 @@ func (dpu *DbPackageUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *DbP
 }
 
 func (dpu *DbPackageUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := dpu.check(); err != nil {
+		return n, err
+	}
 	_spec := &sqlgraph.UpdateSpec{
 		Node: &sqlgraph.NodeSpec{
 			Table:   dbpackage.Table,
@@ -735,6 +705,7 @@ func (dpu *DbPackageUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		return 0, err
 	}
+	dpu.mutation.done = true
 	return n, nil
 }
 
@@ -1200,46 +1171,7 @@ func (dpuo *DbPackageUpdateOne) Select(field string, fields ...string) *DbPackag
 
 // Save executes the query and returns the updated DbPackage entity.
 func (dpuo *DbPackageUpdateOne) Save(ctx context.Context) (*DbPackage, error) {
-	var (
-		err  error
-		node *DbPackage
-	)
-	if len(dpuo.hooks) == 0 {
-		if err = dpuo.check(); err != nil {
-			return nil, err
-		}
-		node, err = dpuo.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*DbPackageMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = dpuo.check(); err != nil {
-				return nil, err
-			}
-			dpuo.mutation = mutation
-			node, err = dpuo.sqlSave(ctx)
-			mutation.done = true
-			return node, err
-		})
-		for i := len(dpuo.hooks) - 1; i >= 0; i-- {
-			if dpuo.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = dpuo.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, dpuo.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*DbPackage)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from DbPackageMutation", v)
-		}
-		node = nv
-	}
-	return node, err
+	return withHooks[*DbPackage, DbPackageMutation](ctx, dpuo.sqlSave, dpuo.mutation, dpuo.hooks)
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -1296,6 +1228,9 @@ func (dpuo *DbPackageUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder))
 }
 
 func (dpuo *DbPackageUpdateOne) sqlSave(ctx context.Context) (_node *DbPackage, err error) {
+	if err := dpuo.check(); err != nil {
+		return _node, err
+	}
 	_spec := &sqlgraph.UpdateSpec{
 		Node: &sqlgraph.NodeSpec{
 			Table:   dbpackage.Table,
@@ -1485,5 +1420,6 @@ func (dpuo *DbPackageUpdateOne) sqlSave(ctx context.Context) (_node *DbPackage,
 		}
 		return nil, err
 	}
+	dpuo.mutation.done = true
 	return _node, nil
 }
diff --git a/ent/ent.go b/ent/ent.go
index b8e26bc..8e19191 100644
--- a/ent/ent.go
+++ b/ent/ent.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"reflect"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -15,14 +16,20 @@ import (
 
 // ent aliases to avoid import conflicts in user's code.
 type (
-	Op         = ent.Op
-	Hook       = ent.Hook
-	Value      = ent.Value
-	Query      = ent.Query
-	Policy     = ent.Policy
-	Mutator    = ent.Mutator
-	Mutation   = ent.Mutation
-	MutateFunc = ent.MutateFunc
+	Op            = ent.Op
+	Hook          = ent.Hook
+	Value         = ent.Value
+	Query         = ent.Query
+	Querier       = ent.Querier
+	QuerierFunc   = ent.QuerierFunc
+	Interceptor   = ent.Interceptor
+	InterceptFunc = ent.InterceptFunc
+	Traverser     = ent.Traverser
+	TraverseFunc  = ent.TraverseFunc
+	Policy        = ent.Policy
+	Mutator       = ent.Mutator
+	Mutation      = ent.Mutation
+	MutateFunc    = ent.MutateFunc
 )
 
 // OrderFunc applies an ordering on the sql selector.
@@ -462,5 +469,120 @@ func (s *selector) BoolX(ctx context.Context) bool {
 	return v
 }
 
+// withHooks invokes the builder operation with the given hooks, if any.
+func withHooks[V Value, M any, PM interface {
+	*M
+	Mutation
+}](ctx context.Context, exec func(context.Context) (V, error), mutation PM, hooks []Hook) (value V, err error) {
+	if len(hooks) == 0 {
+		return exec(ctx)
+	}
+	var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+		mutationT, ok := m.(PM)
+		if !ok {
+			return nil, fmt.Errorf("unexpected mutation type %T", m)
+		}
+		// Set the mutation to the builder.
+		*mutation = *mutationT
+		return exec(ctx)
+	})
+	for i := len(hooks) - 1; i >= 0; i-- {
+		if hooks[i] == nil {
+			return value, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
+		}
+		mut = hooks[i](mut)
+	}
+	v, err := mut.Mutate(ctx, mutation)
+	if err != nil {
+		return value, err
+	}
+	nv, ok := v.(V)
+	if !ok {
+		return value, fmt.Errorf("unexpected node type %T returned from %T", v, mutation)
+	}
+	return nv, nil
+}
+
+// newQueryContext returns a new context with the given QueryContext attached in case it does not exist.
+func newQueryContext(ctx context.Context, typ, op string) context.Context {
+	if ent.QueryFromContext(ctx) == nil {
+		ctx = ent.NewQueryContext(ctx, &ent.QueryContext{Type: typ, Op: op})
+	}
+	return ctx
+}
+
+func querierAll[V Value, Q interface {
+	sqlAll(context.Context, ...queryHook) (V, error)
+}]() Querier {
+	return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		return query.sqlAll(ctx)
+	})
+}
+
+func querierCount[Q interface {
+	sqlCount(context.Context) (int, error)
+}]() Querier {
+	return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		return query.sqlCount(ctx)
+	})
+}
+
+func withInterceptors[V Value](ctx context.Context, q Query, qr Querier, inters []Interceptor) (v V, err error) {
+	for i := len(inters) - 1; i >= 0; i-- {
+		qr = inters[i].Intercept(qr)
+	}
+	rv, err := qr.Query(ctx, q)
+	if err != nil {
+		return v, err
+	}
+	vt, ok := rv.(V)
+	if !ok {
+		return v, fmt.Errorf("unexpected type %T returned from %T. expected type: %T", vt, q, v)
+	}
+	return vt, nil
+}
+
+func scanWithInterceptors[Q1 ent.Query, Q2 interface {
+	sqlScan(context.Context, Q1, any) error
+}](ctx context.Context, rootQuery Q1, selectOrGroup Q2, inters []Interceptor, v any) error {
+	rv := reflect.ValueOf(v)
+	var qr Querier = QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q1)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		if err := selectOrGroup.sqlScan(ctx, query, v); err != nil {
+			return nil, err
+		}
+		if k := rv.Kind(); k == reflect.Pointer && rv.Elem().CanInterface() {
+			return rv.Elem().Interface(), nil
+		}
+		return v, nil
+	})
+	for i := len(inters) - 1; i >= 0; i-- {
+		qr = inters[i].Intercept(qr)
+	}
+	vv, err := qr.Query(ctx, rootQuery)
+	if err != nil {
+		return err
+	}
+	switch rv2 := reflect.ValueOf(vv); {
+	case rv.IsNil(), rv2.IsNil(), rv.Kind() != reflect.Pointer:
+	case rv.Type() == rv2.Type():
+		rv.Elem().Set(rv2.Elem())
+	case rv.Elem().Type() == rv2.Type():
+		rv.Elem().Set(rv2)
+	}
+	return nil
+}
+
 // queryHook describes an internal hook for the different sqlAll methods.
 type queryHook func(context.Context, *sqlgraph.QuerySpec)
diff --git a/ent/hook/hook.go b/ent/hook/hook.go
index d01205d..682ff0f 100644
--- a/ent/hook/hook.go
+++ b/ent/hook/hook.go
@@ -15,11 +15,10 @@ type DbPackageFunc func(context.Context, *ent.DbPackageMutation) (ent.Value, err
 
 // Mutate calls f(ctx, m).
 func (f DbPackageFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	mv, ok := m.(*ent.DbPackageMutation)
-	if !ok {
-		return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.DbPackageMutation", m)
+	if mv, ok := m.(*ent.DbPackageMutation); ok {
+		return f(ctx, mv)
 	}
-	return f(ctx, mv)
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.DbPackageMutation", m)
 }
 
 // Condition is a hook condition function.
diff --git a/ent/mutation.go b/ent/mutation.go
index f9d0148..8ed0a3f 100644
--- a/ent/mutation.go
+++ b/ent/mutation.go
@@ -13,6 +13,7 @@ import (
 	"git.harting.dev/ALHP/ALHP.GO/ent/predicate"
 
 	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
 )
 
 const (
@@ -1380,11 +1381,26 @@ func (m *DbPackageMutation) Where(ps ...predicate.DbPackage) {
 	m.predicates = append(m.predicates, ps...)
 }
 
+// WhereP appends storage-level predicates to the DbPackageMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *DbPackageMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.DbPackage, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
 // Op returns the operation name.
 func (m *DbPackageMutation) Op() Op {
 	return m.op
 }
 
+// SetOp allows setting the mutation operation.
+func (m *DbPackageMutation) SetOp(op Op) {
+	m.op = op
+}
+
 // Type returns the node type of this mutation (DbPackage).
 func (m *DbPackageMutation) Type() string {
 	return m.typ
diff --git a/ent/runtime/runtime.go b/ent/runtime/runtime.go
index 54c1e5c..59ce4ed 100644
--- a/ent/runtime/runtime.go
+++ b/ent/runtime/runtime.go
@@ -5,6 +5,6 @@ package runtime
 // The schema-stitching logic is generated in git.harting.dev/ALHP/ALHP.GO/ent/runtime.go
 
 const (
-	Version = "v0.11.4"                                         // Version of ent codegen.
-	Sum     = "h1:grwVY0fp31BZ6oEo3YrXenAuv8VJmEw7F/Bi6WqeH3Q=" // Sum of ent codegen.
+	Version = "v0.11.5"                                         // Version of ent codegen.
+	Sum     = "h1:V2qhG91C4PMQTa82Q4StoESMQ4dzkMNeStCzszxi0jQ=" // Sum of ent codegen.
 )
diff --git a/go.sum b/go.sum
index 2778bde..55aa00a 100644
--- a/go.sum
+++ b/go.sum
@@ -113,9 +113,11 @@ 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-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
 github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
 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/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
 github.com/otiai10/copy v1.9.0 h1:7KFNiCgZ91Ru4qW4CWPf/7jqtxLagGRmIxWldPP9VY4=
 github.com/otiai10/copy v1.9.0/go.mod h1:hsfX19wcn0UWIHUQ3/4fHuehhk2UyArQ9dVFAn3FczI=
 github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95/go.mod h1:9qAhocn7zKJG+0mI8eUu6xqkFDYS2kb2saOteoSB3cE=
@@ -142,6 +144,8 @@ 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.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=
 github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/spf13/cobra v1.6.1 h1:o94oiPyS4KD1mPy2fmcYYHHfCxLqYjJOhGsCHFZtEzA=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 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=
@@ -231,6 +235,7 @@ golang.org/x/tools v0.0.0-20190823170909-c4a336ef6a2f/go.mod h1:b+2E5dAYhXwXZwtn
 golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.3.1-0.20221202221704-aa9f4b2f3d57 h1:/X0t/E4VxbZE7MLS7auvE7YICHeVvbIa9vkOVvYW/24=
 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=