From 5ea43c896fec22b375154699075c81c436bc8bf1 Mon Sep 17 00:00:00 2001 From: Giovanni Harting <539@idlegandalf.com> Date: Sun, 14 Aug 2022 17:20:34 +0200 Subject: [PATCH] added pkgbuild path to db --- ent/dbpackage.go | 13 +++- ent/dbpackage/dbpackage.go | 3 + ent/dbpackage/where.go | 120 +++++++++++++++++++++++++++++++++++++ ent/dbpackage_create.go | 22 +++++++ ent/dbpackage_update.go | 66 ++++++++++++++++++++ ent/migrate/schema.go | 1 + ent/mutation.go | 75 ++++++++++++++++++++++- ent/schema/dbpackage.go | 1 + utils.go | 3 + 9 files changed, 302 insertions(+), 2 deletions(-) diff --git a/ent/dbpackage.go b/ent/dbpackage.go index f5123dc..4d21293 100644 --- a/ent/dbpackage.go +++ b/ent/dbpackage.go @@ -61,6 +61,8 @@ type DbPackage struct { Srcinfo *string `json:"srcinfo,omitempty"` // SrcinfoHash holds the value of the "srcinfo_hash" field. SrcinfoHash string `json:"srcinfo_hash,omitempty"` + // Pkgbuild holds the value of the "pkgbuild" field. + Pkgbuild string `json:"pkgbuild,omitempty"` } // scanValues returns the types for scanning values from sql.Rows. @@ -72,7 +74,7 @@ func (*DbPackage) scanValues(columns []string) ([]interface{}, error) { values[i] = new([]byte) case dbpackage.FieldID, dbpackage.FieldMaxRss, dbpackage.FieldUTime, dbpackage.FieldSTime, dbpackage.FieldIoIn, dbpackage.FieldIoOut: values[i] = new(sql.NullInt64) - case dbpackage.FieldPkgbase, dbpackage.FieldStatus, dbpackage.FieldSkipReason, dbpackage.FieldRepository, dbpackage.FieldMarch, dbpackage.FieldVersion, dbpackage.FieldRepoVersion, dbpackage.FieldHash, dbpackage.FieldLto, dbpackage.FieldLastVersionBuild, dbpackage.FieldDebugSymbols, dbpackage.FieldSrcinfo, dbpackage.FieldSrcinfoHash: + case dbpackage.FieldPkgbase, dbpackage.FieldStatus, dbpackage.FieldSkipReason, dbpackage.FieldRepository, dbpackage.FieldMarch, dbpackage.FieldVersion, dbpackage.FieldRepoVersion, dbpackage.FieldHash, dbpackage.FieldLto, dbpackage.FieldLastVersionBuild, dbpackage.FieldDebugSymbols, dbpackage.FieldSrcinfo, dbpackage.FieldSrcinfoHash, dbpackage.FieldPkgbuild: values[i] = new(sql.NullString) case dbpackage.FieldBuildTimeStart, dbpackage.FieldUpdated, dbpackage.FieldLastVerified: values[i] = new(sql.NullTime) @@ -237,6 +239,12 @@ func (dp *DbPackage) assignValues(columns []string, values []interface{}) error } else if value.Valid { dp.SrcinfoHash = value.String } + case dbpackage.FieldPkgbuild: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field pkgbuild", values[i]) + } else if value.Valid { + dp.Pkgbuild = value.String + } } } return nil @@ -342,6 +350,9 @@ func (dp *DbPackage) String() string { builder.WriteString(", ") builder.WriteString("srcinfo_hash=") builder.WriteString(dp.SrcinfoHash) + builder.WriteString(", ") + builder.WriteString("pkgbuild=") + builder.WriteString(dp.Pkgbuild) builder.WriteByte(')') return builder.String() } diff --git a/ent/dbpackage/dbpackage.go b/ent/dbpackage/dbpackage.go index d10abd2..717de70 100644 --- a/ent/dbpackage/dbpackage.go +++ b/ent/dbpackage/dbpackage.go @@ -55,6 +55,8 @@ const ( FieldSrcinfo = "srcinfo" // FieldSrcinfoHash holds the string denoting the srcinfo_hash field in the database. FieldSrcinfoHash = "srcinfo_hash" + // FieldPkgbuild holds the string denoting the pkgbuild field in the database. + FieldPkgbuild = "pkgbuild" // Table holds the table name of the dbpackage in the database. Table = "db_packages" ) @@ -84,6 +86,7 @@ var Columns = []string{ FieldIoOut, FieldSrcinfo, FieldSrcinfoHash, + FieldPkgbuild, } // ValidColumn reports if the column name is valid (part of the table columns). diff --git a/ent/dbpackage/where.go b/ent/dbpackage/where.go index 1efd706..946efb7 100644 --- a/ent/dbpackage/where.go +++ b/ent/dbpackage/where.go @@ -199,6 +199,13 @@ func SrcinfoHash(v string) predicate.DbPackage { }) } +// 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)) + }) +} + // PkgbaseEQ applies the EQ predicate on the "pkgbase" field. func PkgbaseEQ(v string) predicate.DbPackage { return predicate.DbPackage(func(s *sql.Selector) { @@ -2012,6 +2019,119 @@ func SrcinfoHashContainsFold(v string) predicate.DbPackage { }) } +// 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)) + }) +} + +// 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)) + }) +} + +// PkgbuildIn applies the In predicate on the "pkgbuild" field. +func PkgbuildIn(vs ...string) predicate.DbPackage { + v := make([]interface{}, 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...)) + }) +} + +// PkgbuildNotIn applies the NotIn predicate on the "pkgbuild" field. +func PkgbuildNotIn(vs ...string) predicate.DbPackage { + v := make([]interface{}, 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...)) + }) +} + +// 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)) + }) +} + +// 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)) + }) +} + +// 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)) + }) +} + +// 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)) + }) +} + +// 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)) + }) +} + +// 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)) + }) +} + +// 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)) + }) +} + +// 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))) + }) +} + +// 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))) + }) +} + +// 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)) + }) +} + +// 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)) + }) +} + // And groups predicates with the AND operator between them. func And(predicates ...predicate.DbPackage) predicate.DbPackage { return predicate.DbPackage(func(s *sql.Selector) { diff --git a/ent/dbpackage_create.go b/ent/dbpackage_create.go index e650cb6..375ccc8 100644 --- a/ent/dbpackage_create.go +++ b/ent/dbpackage_create.go @@ -296,6 +296,20 @@ func (dpc *DbPackageCreate) SetNillableSrcinfoHash(s *string) *DbPackageCreate { return dpc } +// SetPkgbuild sets the "pkgbuild" field. +func (dpc *DbPackageCreate) SetPkgbuild(s string) *DbPackageCreate { + dpc.mutation.SetPkgbuild(s) + return dpc +} + +// SetNillablePkgbuild sets the "pkgbuild" field if the given value is not nil. +func (dpc *DbPackageCreate) SetNillablePkgbuild(s *string) *DbPackageCreate { + if s != nil { + dpc.SetPkgbuild(*s) + } + return dpc +} + // Mutation returns the DbPackageMutation object of the builder. func (dpc *DbPackageCreate) Mutation() *DbPackageMutation { return dpc.mutation @@ -631,6 +645,14 @@ func (dpc *DbPackageCreate) createSpec() (*DbPackage, *sqlgraph.CreateSpec) { }) _node.SrcinfoHash = value } + if value, ok := dpc.mutation.Pkgbuild(); ok { + _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ + Type: field.TypeString, + Value: value, + Column: dbpackage.FieldPkgbuild, + }) + _node.Pkgbuild = value + } return _node, _spec } diff --git a/ent/dbpackage_update.go b/ent/dbpackage_update.go index ff0d49c..63eeb56 100644 --- a/ent/dbpackage_update.go +++ b/ent/dbpackage_update.go @@ -442,6 +442,26 @@ func (dpu *DbPackageUpdate) ClearSrcinfoHash() *DbPackageUpdate { return dpu } +// SetPkgbuild sets the "pkgbuild" field. +func (dpu *DbPackageUpdate) SetPkgbuild(s string) *DbPackageUpdate { + dpu.mutation.SetPkgbuild(s) + return dpu +} + +// SetNillablePkgbuild sets the "pkgbuild" field if the given value is not nil. +func (dpu *DbPackageUpdate) SetNillablePkgbuild(s *string) *DbPackageUpdate { + if s != nil { + dpu.SetPkgbuild(*s) + } + return dpu +} + +// ClearPkgbuild clears the value of the "pkgbuild" field. +func (dpu *DbPackageUpdate) ClearPkgbuild() *DbPackageUpdate { + dpu.mutation.ClearPkgbuild() + return dpu +} + // Mutation returns the DbPackageMutation object of the builder. func (dpu *DbPackageUpdate) Mutation() *DbPackageMutation { return dpu.mutation @@ -845,6 +865,19 @@ func (dpu *DbPackageUpdate) sqlSave(ctx context.Context) (n int, err error) { Column: dbpackage.FieldSrcinfoHash, }) } + if value, ok := dpu.mutation.Pkgbuild(); ok { + _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ + Type: field.TypeString, + Value: value, + Column: dbpackage.FieldPkgbuild, + }) + } + if dpu.mutation.PkgbuildCleared() { + _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ + Type: field.TypeString, + Column: dbpackage.FieldPkgbuild, + }) + } _spec.Modifiers = dpu.modifiers if n, err = sqlgraph.UpdateNodes(ctx, dpu.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { @@ -1279,6 +1312,26 @@ func (dpuo *DbPackageUpdateOne) ClearSrcinfoHash() *DbPackageUpdateOne { return dpuo } +// SetPkgbuild sets the "pkgbuild" field. +func (dpuo *DbPackageUpdateOne) SetPkgbuild(s string) *DbPackageUpdateOne { + dpuo.mutation.SetPkgbuild(s) + return dpuo +} + +// SetNillablePkgbuild sets the "pkgbuild" field if the given value is not nil. +func (dpuo *DbPackageUpdateOne) SetNillablePkgbuild(s *string) *DbPackageUpdateOne { + if s != nil { + dpuo.SetPkgbuild(*s) + } + return dpuo +} + +// ClearPkgbuild clears the value of the "pkgbuild" field. +func (dpuo *DbPackageUpdateOne) ClearPkgbuild() *DbPackageUpdateOne { + dpuo.mutation.ClearPkgbuild() + return dpuo +} + // Mutation returns the DbPackageMutation object of the builder. func (dpuo *DbPackageUpdateOne) Mutation() *DbPackageMutation { return dpuo.mutation @@ -1712,6 +1765,19 @@ func (dpuo *DbPackageUpdateOne) sqlSave(ctx context.Context) (_node *DbPackage, Column: dbpackage.FieldSrcinfoHash, }) } + if value, ok := dpuo.mutation.Pkgbuild(); ok { + _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ + Type: field.TypeString, + Value: value, + Column: dbpackage.FieldPkgbuild, + }) + } + if dpuo.mutation.PkgbuildCleared() { + _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ + Type: field.TypeString, + Column: dbpackage.FieldPkgbuild, + }) + } _spec.Modifiers = dpuo.modifiers _node = &DbPackage{config: dpuo.config} _spec.Assign = _node.assignValues diff --git a/ent/migrate/schema.go b/ent/migrate/schema.go index 6c6f603..ad875e9 100644 --- a/ent/migrate/schema.go +++ b/ent/migrate/schema.go @@ -33,6 +33,7 @@ var ( {Name: "io_out", Type: field.TypeInt64, Nullable: true}, {Name: "srcinfo", Type: field.TypeString, Nullable: true, Size: 2147483647}, {Name: "srcinfo_hash", Type: field.TypeString, Nullable: true}, + {Name: "pkgbuild", Type: field.TypeString, Nullable: true}, } // DbPackagesTable holds the schema information for the "db_packages" table. DbPackagesTable = &schema.Table{ diff --git a/ent/mutation.go b/ent/mutation.go index 6f9b5d2..e137851 100644 --- a/ent/mutation.go +++ b/ent/mutation.go @@ -60,6 +60,7 @@ type DbPackageMutation struct { addio_out *int64 srcinfo *string srcinfo_hash *string + pkgbuild *string clearedFields map[string]struct{} done bool oldValue func(context.Context) (*DbPackage, error) @@ -1308,6 +1309,55 @@ func (m *DbPackageMutation) ResetSrcinfoHash() { delete(m.clearedFields, dbpackage.FieldSrcinfoHash) } +// SetPkgbuild sets the "pkgbuild" field. +func (m *DbPackageMutation) SetPkgbuild(s string) { + m.pkgbuild = &s +} + +// Pkgbuild returns the value of the "pkgbuild" field in the mutation. +func (m *DbPackageMutation) Pkgbuild() (r string, exists bool) { + v := m.pkgbuild + if v == nil { + return + } + return *v, true +} + +// OldPkgbuild returns the old "pkgbuild" field's value of the DbPackage entity. +// If the DbPackage object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *DbPackageMutation) OldPkgbuild(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldPkgbuild is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldPkgbuild requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldPkgbuild: %w", err) + } + return oldValue.Pkgbuild, nil +} + +// ClearPkgbuild clears the value of the "pkgbuild" field. +func (m *DbPackageMutation) ClearPkgbuild() { + m.pkgbuild = nil + m.clearedFields[dbpackage.FieldPkgbuild] = struct{}{} +} + +// PkgbuildCleared returns if the "pkgbuild" field was cleared in this mutation. +func (m *DbPackageMutation) PkgbuildCleared() bool { + _, ok := m.clearedFields[dbpackage.FieldPkgbuild] + return ok +} + +// ResetPkgbuild resets all changes to the "pkgbuild" field. +func (m *DbPackageMutation) ResetPkgbuild() { + m.pkgbuild = nil + delete(m.clearedFields, dbpackage.FieldPkgbuild) +} + // Where appends a list predicates to the DbPackageMutation builder. func (m *DbPackageMutation) Where(ps ...predicate.DbPackage) { m.predicates = append(m.predicates, ps...) @@ -1327,7 +1377,7 @@ func (m *DbPackageMutation) Type() string { // order to get all numeric fields that were incremented/decremented, call // AddedFields(). func (m *DbPackageMutation) Fields() []string { - fields := make([]string, 0, 22) + fields := make([]string, 0, 23) if m.pkgbase != nil { fields = append(fields, dbpackage.FieldPkgbase) } @@ -1394,6 +1444,9 @@ func (m *DbPackageMutation) Fields() []string { if m.srcinfo_hash != nil { fields = append(fields, dbpackage.FieldSrcinfoHash) } + if m.pkgbuild != nil { + fields = append(fields, dbpackage.FieldPkgbuild) + } return fields } @@ -1446,6 +1499,8 @@ func (m *DbPackageMutation) Field(name string) (ent.Value, bool) { return m.Srcinfo() case dbpackage.FieldSrcinfoHash: return m.SrcinfoHash() + case dbpackage.FieldPkgbuild: + return m.Pkgbuild() } return nil, false } @@ -1499,6 +1554,8 @@ func (m *DbPackageMutation) OldField(ctx context.Context, name string) (ent.Valu return m.OldSrcinfo(ctx) case dbpackage.FieldSrcinfoHash: return m.OldSrcinfoHash(ctx) + case dbpackage.FieldPkgbuild: + return m.OldPkgbuild(ctx) } return nil, fmt.Errorf("unknown DbPackage field %s", name) } @@ -1662,6 +1719,13 @@ func (m *DbPackageMutation) SetField(name string, value ent.Value) error { } m.SetSrcinfoHash(v) return nil + case dbpackage.FieldPkgbuild: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetPkgbuild(v) + return nil } return fmt.Errorf("unknown DbPackage field %s", name) } @@ -1812,6 +1876,9 @@ func (m *DbPackageMutation) ClearedFields() []string { if m.FieldCleared(dbpackage.FieldSrcinfoHash) { fields = append(fields, dbpackage.FieldSrcinfoHash) } + if m.FieldCleared(dbpackage.FieldPkgbuild) { + fields = append(fields, dbpackage.FieldPkgbuild) + } return fields } @@ -1883,6 +1950,9 @@ func (m *DbPackageMutation) ClearField(name string) error { case dbpackage.FieldSrcinfoHash: m.ClearSrcinfoHash() return nil + case dbpackage.FieldPkgbuild: + m.ClearPkgbuild() + return nil } return fmt.Errorf("unknown DbPackage nullable field %s", name) } @@ -1957,6 +2027,9 @@ func (m *DbPackageMutation) ResetField(name string) error { case dbpackage.FieldSrcinfoHash: m.ResetSrcinfoHash() return nil + case dbpackage.FieldPkgbuild: + m.ResetPkgbuild() + return nil } return fmt.Errorf("unknown DbPackage field %s", name) } diff --git a/ent/schema/dbpackage.go b/ent/schema/dbpackage.go index 589b883..aa91373 100644 --- a/ent/schema/dbpackage.go +++ b/ent/schema/dbpackage.go @@ -35,6 +35,7 @@ func (DbPackage) Fields() []ent.Field { field.Int64("io_out").Optional().Nillable(), field.Text("srcinfo").Optional().Nillable(), field.String("srcinfo_hash").Optional(), + field.String("pkgbuild").Optional(), } } diff --git a/utils.go b/utils.go index 5a78cb9..6bffa13 100644 --- a/utils.go +++ b/utils.go @@ -185,6 +185,8 @@ func (b *BuildManager) refreshSRCINFOs(ctx context.Context, path string) error { if err != nil { log.Infof("Unable to determine status for package %s: %v", proto.Pkgbase, err) b.repoPurge[proto.FullRepo] <- []*ProtoPackage{proto} + } else { + proto.DbPackage.Update().SetPkgbuild(proto.Pkgbuild) } } } @@ -313,6 +315,7 @@ func genQueue() ([]*ProtoPackage, error) { FullRepo: pkg.Repository.String() + "-" + pkg.March, Hash: pkg.Hash, DbPackage: pkg, + Pkgbuild: pkg.Pkgbuild, }) } return pkgbuilds, nil