updated deps; switched sitemap lib; ent regen

2023-03-03 20:10:31 +01:00
parent e9a5daa9e3
commit 727d530378
52 changed files with 2626 additions and 5665 deletions
--- a/ent/weapon/where.go
+++ b/ent/weapon/where.go
@@ -10,357 +10,227 @@ import (

 // ID filters vertices based on their ID field.
 func ID(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
+	return predicate.Weapon(sql.FieldEQ(FieldID, id))
 }

 // IDEQ applies the EQ predicate on the ID field.
 func IDEQ(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
+	return predicate.Weapon(sql.FieldEQ(FieldID, id))
 }

 // IDNEQ applies the NEQ predicate on the ID field.
 func IDNEQ(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldID), id))
-	})
+	return predicate.Weapon(sql.FieldNEQ(FieldID, id))
 }

 // IDIn applies the In predicate on the ID field.
 func IDIn(ids ...int) predicate.Weapon {
-	return predicate.Weapon(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.Weapon(sql.FieldIn(FieldID, ids...))
 }

 // IDNotIn applies the NotIn predicate on the ID field.
 func IDNotIn(ids ...int) predicate.Weapon {
-	return predicate.Weapon(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.Weapon(sql.FieldNotIn(FieldID, ids...))
 }

 // IDGT applies the GT predicate on the ID field.
 func IDGT(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldID), id))
-	})
+	return predicate.Weapon(sql.FieldGT(FieldID, id))
 }

 // IDGTE applies the GTE predicate on the ID field.
 func IDGTE(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldID), id))
-	})
+	return predicate.Weapon(sql.FieldGTE(FieldID, id))
 }

 // IDLT applies the LT predicate on the ID field.
 func IDLT(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldID), id))
-	})
+	return predicate.Weapon(sql.FieldLT(FieldID, id))
 }

 // IDLTE applies the LTE predicate on the ID field.
 func IDLTE(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldID), id))
-	})
+	return predicate.Weapon(sql.FieldLTE(FieldID, id))
 }

 // Victim applies equality check predicate on the "victim" field. It's identical to VictimEQ.
 func Victim(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldVictim), v))
-	})
+	return predicate.Weapon(sql.FieldEQ(FieldVictim, v))
 }

 // Dmg applies equality check predicate on the "dmg" field. It's identical to DmgEQ.
 func Dmg(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldDmg), v))
-	})
+	return predicate.Weapon(sql.FieldEQ(FieldDmg, v))
 }

 // EqType applies equality check predicate on the "eq_type" field. It's identical to EqTypeEQ.
 func EqType(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldEqType), v))
-	})
+	return predicate.Weapon(sql.FieldEQ(FieldEqType, v))
 }

 // HitGroup applies equality check predicate on the "hit_group" field. It's identical to HitGroupEQ.
 func HitGroup(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldHitGroup), v))
-	})
+	return predicate.Weapon(sql.FieldEQ(FieldHitGroup, v))
 }

 // VictimEQ applies the EQ predicate on the "victim" field.
 func VictimEQ(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldVictim), v))
-	})
+	return predicate.Weapon(sql.FieldEQ(FieldVictim, v))
 }

 // VictimNEQ applies the NEQ predicate on the "victim" field.
 func VictimNEQ(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldVictim), v))
-	})
+	return predicate.Weapon(sql.FieldNEQ(FieldVictim, v))
 }

 // VictimIn applies the In predicate on the "victim" field.
 func VictimIn(vs ...uint64) predicate.Weapon {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldVictim), v...))
-	})
+	return predicate.Weapon(sql.FieldIn(FieldVictim, vs...))
 }

 // VictimNotIn applies the NotIn predicate on the "victim" field.
 func VictimNotIn(vs ...uint64) predicate.Weapon {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldVictim), v...))
-	})
+	return predicate.Weapon(sql.FieldNotIn(FieldVictim, vs...))
 }

 // VictimGT applies the GT predicate on the "victim" field.
 func VictimGT(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldVictim), v))
-	})
+	return predicate.Weapon(sql.FieldGT(FieldVictim, v))
 }

 // VictimGTE applies the GTE predicate on the "victim" field.
 func VictimGTE(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldVictim), v))
-	})
+	return predicate.Weapon(sql.FieldGTE(FieldVictim, v))
 }

 // VictimLT applies the LT predicate on the "victim" field.
 func VictimLT(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldVictim), v))
-	})
+	return predicate.Weapon(sql.FieldLT(FieldVictim, v))
 }

 // VictimLTE applies the LTE predicate on the "victim" field.
 func VictimLTE(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldVictim), v))
-	})
+	return predicate.Weapon(sql.FieldLTE(FieldVictim, v))
 }

 // DmgEQ applies the EQ predicate on the "dmg" field.
 func DmgEQ(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldDmg), v))
-	})
+	return predicate.Weapon(sql.FieldEQ(FieldDmg, v))
 }

 // DmgNEQ applies the NEQ predicate on the "dmg" field.
 func DmgNEQ(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldDmg), v))
-	})
+	return predicate.Weapon(sql.FieldNEQ(FieldDmg, v))
 }

 // DmgIn applies the In predicate on the "dmg" field.
 func DmgIn(vs ...uint) predicate.Weapon {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldDmg), v...))
-	})
+	return predicate.Weapon(sql.FieldIn(FieldDmg, vs...))
 }

 // DmgNotIn applies the NotIn predicate on the "dmg" field.
 func DmgNotIn(vs ...uint) predicate.Weapon {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldDmg), v...))
-	})
+	return predicate.Weapon(sql.FieldNotIn(FieldDmg, vs...))
 }

 // DmgGT applies the GT predicate on the "dmg" field.
 func DmgGT(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldDmg), v))
-	})
+	return predicate.Weapon(sql.FieldGT(FieldDmg, v))
 }

 // DmgGTE applies the GTE predicate on the "dmg" field.
 func DmgGTE(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldDmg), v))
-	})
+	return predicate.Weapon(sql.FieldGTE(FieldDmg, v))
 }

 // DmgLT applies the LT predicate on the "dmg" field.
 func DmgLT(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldDmg), v))
-	})
+	return predicate.Weapon(sql.FieldLT(FieldDmg, v))
 }

 // DmgLTE applies the LTE predicate on the "dmg" field.
 func DmgLTE(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldDmg), v))
-	})
+	return predicate.Weapon(sql.FieldLTE(FieldDmg, v))
 }

 // EqTypeEQ applies the EQ predicate on the "eq_type" field.
 func EqTypeEQ(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldEqType), v))
-	})
+	return predicate.Weapon(sql.FieldEQ(FieldEqType, v))
 }

 // EqTypeNEQ applies the NEQ predicate on the "eq_type" field.
 func EqTypeNEQ(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldEqType), v))
-	})
+	return predicate.Weapon(sql.FieldNEQ(FieldEqType, v))
 }

 // EqTypeIn applies the In predicate on the "eq_type" field.
 func EqTypeIn(vs ...int) predicate.Weapon {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldEqType), v...))
-	})
+	return predicate.Weapon(sql.FieldIn(FieldEqType, vs...))
 }

 // EqTypeNotIn applies the NotIn predicate on the "eq_type" field.
 func EqTypeNotIn(vs ...int) predicate.Weapon {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldEqType), v...))
-	})
+	return predicate.Weapon(sql.FieldNotIn(FieldEqType, vs...))
 }

 // EqTypeGT applies the GT predicate on the "eq_type" field.
 func EqTypeGT(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldEqType), v))
-	})
+	return predicate.Weapon(sql.FieldGT(FieldEqType, v))
 }

 // EqTypeGTE applies the GTE predicate on the "eq_type" field.
 func EqTypeGTE(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldEqType), v))
-	})
+	return predicate.Weapon(sql.FieldGTE(FieldEqType, v))
 }

 // EqTypeLT applies the LT predicate on the "eq_type" field.
 func EqTypeLT(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldEqType), v))
-	})
+	return predicate.Weapon(sql.FieldLT(FieldEqType, v))
 }

 // EqTypeLTE applies the LTE predicate on the "eq_type" field.
 func EqTypeLTE(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldEqType), v))
-	})
+	return predicate.Weapon(sql.FieldLTE(FieldEqType, v))
 }

 // HitGroupEQ applies the EQ predicate on the "hit_group" field.
 func HitGroupEQ(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.EQ(s.C(FieldHitGroup), v))
-	})
+	return predicate.Weapon(sql.FieldEQ(FieldHitGroup, v))
 }

 // HitGroupNEQ applies the NEQ predicate on the "hit_group" field.
 func HitGroupNEQ(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.NEQ(s.C(FieldHitGroup), v))
-	})
+	return predicate.Weapon(sql.FieldNEQ(FieldHitGroup, v))
 }

 // HitGroupIn applies the In predicate on the "hit_group" field.
 func HitGroupIn(vs ...int) predicate.Weapon {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldHitGroup), v...))
-	})
+	return predicate.Weapon(sql.FieldIn(FieldHitGroup, vs...))
 }

 // HitGroupNotIn applies the NotIn predicate on the "hit_group" field.
 func HitGroupNotIn(vs ...int) predicate.Weapon {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldHitGroup), v...))
-	})
+	return predicate.Weapon(sql.FieldNotIn(FieldHitGroup, vs...))
 }

 // HitGroupGT applies the GT predicate on the "hit_group" field.
 func HitGroupGT(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.GT(s.C(FieldHitGroup), v))
-	})
+	return predicate.Weapon(sql.FieldGT(FieldHitGroup, v))
 }

 // HitGroupGTE applies the GTE predicate on the "hit_group" field.
 func HitGroupGTE(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.GTE(s.C(FieldHitGroup), v))
-	})
+	return predicate.Weapon(sql.FieldGTE(FieldHitGroup, v))
 }

 // HitGroupLT applies the LT predicate on the "hit_group" field.
 func HitGroupLT(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.LT(s.C(FieldHitGroup), v))
-	})
+	return predicate.Weapon(sql.FieldLT(FieldHitGroup, v))
 }

 // HitGroupLTE applies the LTE predicate on the "hit_group" field.
 func HitGroupLTE(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.LTE(s.C(FieldHitGroup), v))
-	})
+	return predicate.Weapon(sql.FieldLTE(FieldHitGroup, v))
 }

 // HasStat applies the HasEdge predicate on the "stat" edge.
@@ -368,7 +238,6 @@ func HasStat() predicate.Weapon {
 	return predicate.Weapon(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
-			sqlgraph.To(StatTable, FieldID),
 			sqlgraph.Edge(sqlgraph.M2O, true, StatTable, StatColumn),
 		)
 		sqlgraph.HasNeighbors(s, step)