···

       
504
       
504
       
 
       
type filter struct {

     

       
505
       
505
       
 
       
	key string

     

       
506
       
506
       
 
       
	arg any

     

       
507
       
507
       
+
       
	cmp string

     

       
507
       
508
       
 
       
}

     

       
508
       
509
       
 
       


     

       
509
       
509
       
-
       
func Filter(key string, arg any) filter {

     

       
510
       
510
       
+
       
func FilterEq(key string, arg any) filter {

     

       
510
       
511
       
 
       
	return filter{

     

       
511
       
512
       
 
       
		key: key,

     

       
512
       
513
       
 
       
		arg: arg,

     

       
514
       
514
       
+
       
		cmp: "=",

     

       
515
       
515
       
+
       
	}

     

       
516
       
516
       
+
       
}

     

       
517
       
517
       
+
       


     

       
518
       
518
       
+
       
func FilterNotEq(key string, arg any) filter {

     

       
519
       
519
       
+
       
	return filter{

     

       
520
       
520
       
+
       
		key: key,

     

       
521
       
521
       
+
       
		arg: arg,

     

       
522
       
522
       
+
       
		cmp: "<>",

     

       
513
       
523
       
 
       
	}

     

       
514
       
524
       
 
       
}

     

       
515
       
525
       
 
       


     

       
516
       
526
       
 
       
func (f filter) Condition() string {

     

       
517
       
517
       
-
       
	return fmt.Sprintf("%s = ?", f.key)

     

       
527
       
527
       
+
       
	return fmt.Sprintf("%s %s ?", f.key, f.cmp)

     

       
518
       
528
       
 
       
}

     

···

       
988
       
988
       
 
       
//

     

       
989
       
989
       
 
       
// `w` is parent of none, so it is the top of the stack

     

       
990
       
990
       
 
       
func GetStack(e Execer, stackId string) (Stack, error) {

     

       
991
       
991
       
-
       
	unorderedPulls, err := GetPulls(e, Filter("stack_id", stackId))

     

       
991
       
991
       
+
       
	unorderedPulls, err := GetPulls(

     

       
992
       
992
       
+
       
		e,

     

       
993
       
993
       
+
       
		FilterEq("stack_id", stackId),

     

       
994
       
994
       
+
       
		FilterNotEq("state", PullDeleted),

     

       
995
       
995
       
+
       
	)

     

       
992
       
996
       
 
       
	if err != nil {

     

       
993
       
997
       
 
       
		return nil, err

     

       
994
       
998
       
 
       
	}

     

···

       
188
       
188
       
 
       


     

       
189
       
189
       
 
       
		err = db.AddArtifact(d, artifact)

     

       
190
       
190
       
 
       
	case models.CommitOperationDelete:

     

       
191
       
191
       
-
       
		err = db.DeleteArtifact(d, db.Filter("did", did), db.Filter("rkey", e.Commit.RKey))

     

       
191
       
191
       
+
       
		err = db.DeleteArtifact(d, db.FilterEq("did", did), db.FilterEq("rkey", e.Commit.RKey))

     

       
192
       
192
       
 
       
	}

     

       
193
       
193
       
 
       


     

       
194
       
194
       
 
       
	if err != nil {

     
···

       
276
       
276
       
 
       


     

       
277
       
277
       
 
       
		err = db.UpsertProfile(tx, &profile)

     

       
278
       
278
       
 
       
	case models.CommitOperationDelete:

     

       
279
       
279
       
-
       
		err = db.DeleteArtifact(d, db.Filter("did", did), db.Filter("rkey", e.Commit.RKey))

     

       
279
       
279
       
+
       
		err = db.DeleteArtifact(d, db.FilterEq("did", did), db.FilterEq("rkey", e.Commit.RKey))

     

       
280
       
280
       
 
       
	}

     

       
281
       
281
       
 
       


     

       
282
       
282
       
 
       
	if err != nil {

     

···

       
154
       
154
       
 
       


     

       
155
       
155
       
 
       
	artifacts, err := db.GetArtifact(

     

       
156
       
156
       
 
       
		s.db,

     

       
157
       
157
       
-
       
		db.Filter("repo_at", f.RepoAt),

     

       
158
       
158
       
-
       
		db.Filter("tag", tag.Tag.Hash[:]),

     

       
159
       
159
       
-
       
		db.Filter("name", filename),

     

       
157
       
157
       
+
       
		db.FilterEq("repo_at", f.RepoAt),

     

       
158
       
158
       
+
       
		db.FilterEq("tag", tag.Tag.Hash[:]),

     

       
159
       
159
       
+
       
		db.FilterEq("name", filename),

     

       
160
       
160
       
 
       
	)

     

       
161
       
161
       
 
       
	if err != nil {

     

       
162
       
162
       
 
       
		log.Println("failed to get artifacts", err)

     
···

       
196
       
196
       
 
       


     

       
197
       
197
       
 
       
	artifacts, err := db.GetArtifact(

     

       
198
       
198
       
 
       
		s.db,

     

       
199
       
199
       
-
       
		db.Filter("repo_at", f.RepoAt),

     

       
200
       
200
       
-
       
		db.Filter("tag", tag[:]),

     

       
201
       
201
       
-
       
		db.Filter("name", filename),

     

       
199
       
199
       
+
       
		db.FilterEq("repo_at", f.RepoAt),

     

       
200
       
200
       
+
       
		db.FilterEq("tag", tag[:]),

     

       
201
       
201
       
+
       
		db.FilterEq("name", filename),

     

       
202
       
202
       
 
       
	)

     

       
203
       
203
       
 
       
	if err != nil {

     

       
204
       
204
       
 
       
		log.Println("failed to get artifacts", err)

     
···

       
238
       
238
       
 
       
	defer tx.Rollback()

     

       
239
       
239
       
 
       


     

       
240
       
240
       
 
       
	err = db.DeleteArtifact(tx,

     

       
241
       
241
       
-
       
		db.Filter("repo_at", f.RepoAt),

     

       
242
       
242
       
-
       
		db.Filter("tag", artifact.Tag[:]),

     

       
243
       
243
       
-
       
		db.Filter("name", filename),

     

       
241
       
241
       
+
       
		db.FilterEq("repo_at", f.RepoAt),

     

       
242
       
242
       
+
       
		db.FilterEq("tag", artifact.Tag[:]),

     

       
243
       
243
       
+
       
		db.FilterEq("name", filename),

     

       
244
       
244
       
 
       
	)

     

       
245
       
245
       
 
       
	if err != nil {

     

       
246
       
246
       
 
       
		log.Println("failed to remove artifact record from db", err)

     

···

       
455
       
455
       
 
       


     

       
456
       
456
       
 
       
	pulls, err := db.GetPulls(

     

       
457
       
457
       
 
       
		s.db,

     

       
458
       
458
       
-
       
		db.Filter("repo_at", f.RepoAt),

     

       
459
       
459
       
-
       
		db.Filter("state", state),

     

       
458
       
458
       
+
       
		db.FilterEq("repo_at", f.RepoAt),

     

       
459
       
459
       
+
       
		db.FilterEq("state", state),

     

       
460
       
460
       
 
       
	)

     

       
461
       
461
       
 
       
	if err != nil {

     

       
462
       
462
       
 
       
		log.Println("failed to get pulls", err)

     
···

       
1745
       
1745
       
 
       
			tx,

     

       
1746
       
1746
       
 
       
			p.ParentChangeId,

     

       
1747
       
1747
       
 
       
			// these should be enough filters to be unique per-stack

     

       
1748
       
1748
       
-
       
			db.Filter("repo_at", p.RepoAt.String()),

     

       
1749
       
1749
       
-
       
			db.Filter("owner_did", p.OwnerDid),

     

       
1750
       
1750
       
-
       
			db.Filter("change_id", p.ChangeId),

     

       
1748
       
1748
       
+
       
			db.FilterEq("repo_at", p.RepoAt.String()),

     

       
1749
       
1749
       
+
       
			db.FilterEq("owner_did", p.OwnerDid),

     

       
1750
       
1750
       
+
       
			db.FilterEq("change_id", p.ChangeId),

     

       
1751
       
1751
       
 
       
		)

     

       
1752
       
1752
       
 
       


     

       
1753
       
1753
       
 
       
		if err != nil {

     

···

       
518
       
518
       
 
       
		return

     

       
519
       
519
       
 
       
	}

     

       
520
       
520
       
 
       


     

       
521
       
521
       
-
       
	artifacts, err := db.GetArtifact(s.db, db.Filter("repo_at", f.RepoAt))

     

       
521
       
521
       
+
       
	artifacts, err := db.GetArtifact(s.db, db.FilterEq("repo_at", f.RepoAt))

     

       
522
       
522
       
 
       
	if err != nil {

     

       
523
       
523
       
 
       
		log.Println("failed grab artifacts", err)

     

       
524
       
524
       
 
       
		return