updated deps; switched sitemap lib; ent regen

ent/roundstats/where.go

@@ -10,357 +10,227 @@ import (
 
 // ID filters vertices based on their ID field.
 func ID(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
+	return predicate.RoundStats(sql.FieldEQ(FieldID, id))
 }
 
 // IDEQ applies the EQ predicate on the ID field.
 func IDEQ(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
+	return predicate.RoundStats(sql.FieldEQ(FieldID, id))
 }
 
 // IDNEQ applies the NEQ predicate on the ID field.
 func IDNEQ(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldID), id))
-	})
+	return predicate.RoundStats(sql.FieldNEQ(FieldID, id))
 }
 
 // IDIn applies the In predicate on the ID field.
 func IDIn(ids ...int) predicate.RoundStats {
-	return predicate.RoundStats(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.RoundStats(sql.FieldIn(FieldID, ids...))
 }
 
 // IDNotIn applies the NotIn predicate on the ID field.
 func IDNotIn(ids ...int) predicate.RoundStats {
-	return predicate.RoundStats(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.RoundStats(sql.FieldNotIn(FieldID, ids...))
 }
 
 // IDGT applies the GT predicate on the ID field.
 func IDGT(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldID), id))
-	})
+	return predicate.RoundStats(sql.FieldGT(FieldID, id))
 }
 
 // IDGTE applies the GTE predicate on the ID field.
 func IDGTE(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldID), id))
-	})
+	return predicate.RoundStats(sql.FieldGTE(FieldID, id))
 }
 
 // IDLT applies the LT predicate on the ID field.
 func IDLT(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldID), id))
-	})
+	return predicate.RoundStats(sql.FieldLT(FieldID, id))
 }
 
 // IDLTE applies the LTE predicate on the ID field.
 func IDLTE(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldID), id))
-	})
+	return predicate.RoundStats(sql.FieldLTE(FieldID, id))
 }
 
 // Round applies equality check predicate on the "round" field. It's identical to RoundEQ.
 func Round(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldRound), v))
-	})
+	return predicate.RoundStats(sql.FieldEQ(FieldRound, v))
 }
 
 // Bank applies equality check predicate on the "bank" field. It's identical to BankEQ.
 func Bank(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldBank), v))
-	})
+	return predicate.RoundStats(sql.FieldEQ(FieldBank, v))
 }
 
 // Equipment applies equality check predicate on the "equipment" field. It's identical to EquipmentEQ.
 func Equipment(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldEquipment), v))
-	})
+	return predicate.RoundStats(sql.FieldEQ(FieldEquipment, v))
 }
 
 // Spent applies equality check predicate on the "spent" field. It's identical to SpentEQ.
 func Spent(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldSpent), v))
-	})
+	return predicate.RoundStats(sql.FieldEQ(FieldSpent, v))
 }
 
 // RoundEQ applies the EQ predicate on the "round" field.
 func RoundEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldRound), v))
-	})
+	return predicate.RoundStats(sql.FieldEQ(FieldRound, v))
 }
 
 // RoundNEQ applies the NEQ predicate on the "round" field.
 func RoundNEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldRound), v))
-	})
+	return predicate.RoundStats(sql.FieldNEQ(FieldRound, v))
 }
 
 // RoundIn applies the In predicate on the "round" field.
 func RoundIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldRound), v...))
-	})
+	return predicate.RoundStats(sql.FieldIn(FieldRound, vs...))
 }
 
 // RoundNotIn applies the NotIn predicate on the "round" field.
 func RoundNotIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldRound), v...))
-	})
+	return predicate.RoundStats(sql.FieldNotIn(FieldRound, vs...))
 }
 
 // RoundGT applies the GT predicate on the "round" field.
 func RoundGT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldRound), v))
-	})
+	return predicate.RoundStats(sql.FieldGT(FieldRound, v))
 }
 
 // RoundGTE applies the GTE predicate on the "round" field.
 func RoundGTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldRound), v))
-	})
+	return predicate.RoundStats(sql.FieldGTE(FieldRound, v))
 }
 
 // RoundLT applies the LT predicate on the "round" field.
 func RoundLT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldRound), v))
-	})
+	return predicate.RoundStats(sql.FieldLT(FieldRound, v))
 }
 
 // RoundLTE applies the LTE predicate on the "round" field.
 func RoundLTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldRound), v))
-	})
+	return predicate.RoundStats(sql.FieldLTE(FieldRound, v))
 }
 
 // BankEQ applies the EQ predicate on the "bank" field.
 func BankEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldBank), v))
-	})
+	return predicate.RoundStats(sql.FieldEQ(FieldBank, v))
 }
 
 // BankNEQ applies the NEQ predicate on the "bank" field.
 func BankNEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldBank), v))
-	})
+	return predicate.RoundStats(sql.FieldNEQ(FieldBank, v))
 }
 
 // BankIn applies the In predicate on the "bank" field.
 func BankIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldBank), v...))
-	})
+	return predicate.RoundStats(sql.FieldIn(FieldBank, vs...))
 }
 
 // BankNotIn applies the NotIn predicate on the "bank" field.
 func BankNotIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldBank), v...))
-	})
+	return predicate.RoundStats(sql.FieldNotIn(FieldBank, vs...))
 }
 
 // BankGT applies the GT predicate on the "bank" field.
 func BankGT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldBank), v))
-	})
+	return predicate.RoundStats(sql.FieldGT(FieldBank, v))
 }
 
 // BankGTE applies the GTE predicate on the "bank" field.
 func BankGTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldBank), v))
-	})
+	return predicate.RoundStats(sql.FieldGTE(FieldBank, v))
 }
 
 // BankLT applies the LT predicate on the "bank" field.
 func BankLT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldBank), v))
-	})
+	return predicate.RoundStats(sql.FieldLT(FieldBank, v))
 }
 
 // BankLTE applies the LTE predicate on the "bank" field.
 func BankLTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldBank), v))
-	})
+	return predicate.RoundStats(sql.FieldLTE(FieldBank, v))
 }
 
 // EquipmentEQ applies the EQ predicate on the "equipment" field.
 func EquipmentEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldEquipment), v))
-	})
+	return predicate.RoundStats(sql.FieldEQ(FieldEquipment, v))
 }
 
 // EquipmentNEQ applies the NEQ predicate on the "equipment" field.
 func EquipmentNEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldEquipment), v))
-	})
+	return predicate.RoundStats(sql.FieldNEQ(FieldEquipment, v))
 }
 
 // EquipmentIn applies the In predicate on the "equipment" field.
 func EquipmentIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldEquipment), v...))
-	})
+	return predicate.RoundStats(sql.FieldIn(FieldEquipment, vs...))
 }
 
 // EquipmentNotIn applies the NotIn predicate on the "equipment" field.
 func EquipmentNotIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldEquipment), v...))
-	})
+	return predicate.RoundStats(sql.FieldNotIn(FieldEquipment, vs...))
 }
 
 // EquipmentGT applies the GT predicate on the "equipment" field.
 func EquipmentGT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldEquipment), v))
-	})
+	return predicate.RoundStats(sql.FieldGT(FieldEquipment, v))
 }
 
 // EquipmentGTE applies the GTE predicate on the "equipment" field.
 func EquipmentGTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldEquipment), v))
-	})
+	return predicate.RoundStats(sql.FieldGTE(FieldEquipment, v))
 }
 
 // EquipmentLT applies the LT predicate on the "equipment" field.
 func EquipmentLT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldEquipment), v))
-	})
+	return predicate.RoundStats(sql.FieldLT(FieldEquipment, v))
 }
 
 // EquipmentLTE applies the LTE predicate on the "equipment" field.
 func EquipmentLTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldEquipment), v))
-	})
+	return predicate.RoundStats(sql.FieldLTE(FieldEquipment, v))
 }
 
 // SpentEQ applies the EQ predicate on the "spent" field.
 func SpentEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldSpent), v))
-	})
+	return predicate.RoundStats(sql.FieldEQ(FieldSpent, v))
 }
 
 // SpentNEQ applies the NEQ predicate on the "spent" field.
 func SpentNEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldSpent), v))
-	})
+	return predicate.RoundStats(sql.FieldNEQ(FieldSpent, v))
 }
 
 // SpentIn applies the In predicate on the "spent" field.
 func SpentIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldSpent), v...))
-	})
+	return predicate.RoundStats(sql.FieldIn(FieldSpent, vs...))
 }
 
 // SpentNotIn applies the NotIn predicate on the "spent" field.
 func SpentNotIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldSpent), v...))
-	})
+	return predicate.RoundStats(sql.FieldNotIn(FieldSpent, vs...))
 }
 
 // SpentGT applies the GT predicate on the "spent" field.
 func SpentGT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldSpent), v))
-	})
+	return predicate.RoundStats(sql.FieldGT(FieldSpent, v))
 }
 
 // SpentGTE applies the GTE predicate on the "spent" field.
 func SpentGTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldSpent), v))
-	})
+	return predicate.RoundStats(sql.FieldGTE(FieldSpent, v))
 }
 
 // SpentLT applies the LT predicate on the "spent" field.
 func SpentLT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldSpent), v))
-	})
+	return predicate.RoundStats(sql.FieldLT(FieldSpent, v))
 }
 
 // SpentLTE applies the LTE predicate on the "spent" field.
 func SpentLTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldSpent), v))
-	})
+	return predicate.RoundStats(sql.FieldLTE(FieldSpent, v))
 }
 
 // HasMatchPlayer applies the HasEdge predicate on the "match_player" edge.
@@ -368,7 +238,6 @@ func HasMatchPlayer() predicate.RoundStats {
 	return predicate.RoundStats(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
-			sqlgraph.To(MatchPlayerTable, FieldID),
 			sqlgraph.Edge(sqlgraph.M2O, true, MatchPlayerTable, MatchPlayerColumn),
 		)
 		sqlgraph.HasNeighbors(s, step)