added avg ping recording

ent/matchplayer.go

@@ -81,6 +81,8 @@ type MatchPlayer struct {
 	PlayerStats uint64 `json:"player_stats,omitempty"`
 	// FlashAssists holds the value of the "flash_assists" field.
 	FlashAssists int `json:"flash_assists,omitempty"`
+	// AvgPing holds the value of the "avg_ping" field.
+	AvgPing float64 `json:"avg_ping,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
 	// The values are being populated by the MatchPlayerQuery when eager-loading is set.
 	Edges MatchPlayerEdges `json:"edges"`
@@ -172,7 +174,7 @@ func (*MatchPlayer) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
 	for i := range columns {
 		switch columns[i] {
-		case matchplayer.FieldFlashDurationSelf, matchplayer.FieldFlashDurationTeam, matchplayer.FieldFlashDurationEnemy:
+		case matchplayer.FieldFlashDurationSelf, matchplayer.FieldFlashDurationTeam, matchplayer.FieldFlashDurationEnemy, matchplayer.FieldAvgPing:
 			values[i] = new(sql.NullFloat64)
 		case matchplayer.FieldID, matchplayer.FieldTeamID, matchplayer.FieldKills, matchplayer.FieldDeaths, matchplayer.FieldAssists, matchplayer.FieldHeadshot, matchplayer.FieldMvp, matchplayer.FieldScore, matchplayer.FieldRankNew, matchplayer.FieldRankOld, matchplayer.FieldMk2, matchplayer.FieldMk3, matchplayer.FieldMk4, matchplayer.FieldMk5, matchplayer.FieldDmgEnemy, matchplayer.FieldDmgTeam, matchplayer.FieldUdHe, matchplayer.FieldUdFlames, matchplayer.FieldUdFlash, matchplayer.FieldUdDecoy, matchplayer.FieldUdSmoke, matchplayer.FieldKast, matchplayer.FieldFlashTotalSelf, matchplayer.FieldFlashTotalTeam, matchplayer.FieldFlashTotalEnemy, matchplayer.FieldMatchStats, matchplayer.FieldPlayerStats, matchplayer.FieldFlashAssists:
 			values[i] = new(sql.NullInt64)
@@ -391,6 +393,12 @@ func (mp *MatchPlayer) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				mp.FlashAssists = int(value.Int64)
 			}
+		case matchplayer.FieldAvgPing:
+			if value, ok := values[i].(*sql.NullFloat64); !ok {
+				return fmt.Errorf("unexpected type %T for field avg_ping", values[i])
+			} else if value.Valid {
+				mp.AvgPing = value.Float64
+			}
 		}
 	}
 	return nil
@@ -544,6 +552,9 @@ func (mp *MatchPlayer) String() string {
 	builder.WriteString(", ")
 	builder.WriteString("flash_assists=")
 	builder.WriteString(fmt.Sprintf("%v", mp.FlashAssists))
+	builder.WriteString(", ")
+	builder.WriteString("avg_ping=")
+	builder.WriteString(fmt.Sprintf("%v", mp.AvgPing))
 	builder.WriteByte(')')
 	return builder.String()
 }

ent/matchplayer/matchplayer.go

@@ -75,6 +75,8 @@ const (
 	FieldPlayerStats = "player_stats"
 	// FieldFlashAssists holds the string denoting the flash_assists field in the database.
 	FieldFlashAssists = "flash_assists"
+	// FieldAvgPing holds the string denoting the avg_ping field in the database.
+	FieldAvgPing = "avg_ping"
 	// EdgeMatches holds the string denoting the matches edge name in mutations.
 	EdgeMatches = "matches"
 	// EdgePlayers holds the string denoting the players edge name in mutations.
@@ -168,6 +170,7 @@ var Columns = []string{
 	FieldMatchStats,
 	FieldPlayerStats,
 	FieldFlashAssists,
+	FieldAvgPing,
 }
 
 // ValidColumn reports if the column name is valid (part of the table columns).

ent/matchplayer/where.go

@@ -296,6 +296,13 @@ func FlashAssists(v int) predicate.MatchPlayer {
 	})
 }
 
+// AvgPing applies equality check predicate on the "avg_ping" field. It's identical to AvgPingEQ.
+func AvgPing(v float64) predicate.MatchPlayer {
+	return predicate.MatchPlayer(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldAvgPing), v))
+	})
+}
+
 // TeamIDEQ applies the EQ predicate on the "team_id" field.
 func TeamIDEQ(v int) predicate.MatchPlayer {
 	return predicate.MatchPlayer(func(s *sql.Selector) {
@@ -2645,6 +2652,84 @@ func FlashAssistsNotNil() predicate.MatchPlayer {
 	})
 }
 
+// AvgPingEQ applies the EQ predicate on the "avg_ping" field.
+func AvgPingEQ(v float64) predicate.MatchPlayer {
+	return predicate.MatchPlayer(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldAvgPing), v))
+	})
+}
+
+// AvgPingNEQ applies the NEQ predicate on the "avg_ping" field.
+func AvgPingNEQ(v float64) predicate.MatchPlayer {
+	return predicate.MatchPlayer(func(s *sql.Selector) {
+		s.Where(sql.NEQ(s.C(FieldAvgPing), v))
+	})
+}
+
+// AvgPingIn applies the In predicate on the "avg_ping" field.
+func AvgPingIn(vs ...float64) predicate.MatchPlayer {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.MatchPlayer(func(s *sql.Selector) {
+		s.Where(sql.In(s.C(FieldAvgPing), v...))
+	})
+}
+
+// AvgPingNotIn applies the NotIn predicate on the "avg_ping" field.
+func AvgPingNotIn(vs ...float64) predicate.MatchPlayer {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.MatchPlayer(func(s *sql.Selector) {
+		s.Where(sql.NotIn(s.C(FieldAvgPing), v...))
+	})
+}
+
+// AvgPingGT applies the GT predicate on the "avg_ping" field.
+func AvgPingGT(v float64) predicate.MatchPlayer {
+	return predicate.MatchPlayer(func(s *sql.Selector) {
+		s.Where(sql.GT(s.C(FieldAvgPing), v))
+	})
+}
+
+// AvgPingGTE applies the GTE predicate on the "avg_ping" field.
+func AvgPingGTE(v float64) predicate.MatchPlayer {
+	return predicate.MatchPlayer(func(s *sql.Selector) {
+		s.Where(sql.GTE(s.C(FieldAvgPing), v))
+	})
+}
+
+// AvgPingLT applies the LT predicate on the "avg_ping" field.
+func AvgPingLT(v float64) predicate.MatchPlayer {
+	return predicate.MatchPlayer(func(s *sql.Selector) {
+		s.Where(sql.LT(s.C(FieldAvgPing), v))
+	})
+}
+
+// AvgPingLTE applies the LTE predicate on the "avg_ping" field.
+func AvgPingLTE(v float64) predicate.MatchPlayer {
+	return predicate.MatchPlayer(func(s *sql.Selector) {
+		s.Where(sql.LTE(s.C(FieldAvgPing), v))
+	})
+}
+
+// AvgPingIsNil applies the IsNil predicate on the "avg_ping" field.
+func AvgPingIsNil() predicate.MatchPlayer {
+	return predicate.MatchPlayer(func(s *sql.Selector) {
+		s.Where(sql.IsNull(s.C(FieldAvgPing)))
+	})
+}
+
+// AvgPingNotNil applies the NotNil predicate on the "avg_ping" field.
+func AvgPingNotNil() predicate.MatchPlayer {
+	return predicate.MatchPlayer(func(s *sql.Selector) {
+		s.Where(sql.NotNull(s.C(FieldAvgPing)))
+	})
+}
+
 // HasMatches applies the HasEdge predicate on the "matches" edge.
 func HasMatches() predicate.MatchPlayer {
 	return predicate.MatchPlayer(func(s *sql.Selector) {

ent/matchplayer_create.go

@@ -417,6 +417,20 @@ func (mpc *MatchPlayerCreate) SetNillableFlashAssists(i *int) *MatchPlayerCreate
 	return mpc
 }
 
+// SetAvgPing sets the "avg_ping" field.
+func (mpc *MatchPlayerCreate) SetAvgPing(f float64) *MatchPlayerCreate {
+	mpc.mutation.SetAvgPing(f)
+	return mpc
+}
+
+// SetNillableAvgPing sets the "avg_ping" field if the given value is not nil.
+func (mpc *MatchPlayerCreate) SetNillableAvgPing(f *float64) *MatchPlayerCreate {
+	if f != nil {
+		mpc.SetAvgPing(*f)
+	}
+	return mpc
+}
+
 // SetMatchesID sets the "matches" edge to the Match entity by ID.
 func (mpc *MatchPlayerCreate) SetMatchesID(id uint64) *MatchPlayerCreate {
 	mpc.mutation.SetMatchesID(id)
@@ -764,6 +778,10 @@ func (mpc *MatchPlayerCreate) createSpec() (*MatchPlayer, *sqlgraph.CreateSpec)
 		_spec.SetField(matchplayer.FieldFlashAssists, field.TypeInt, value)
 		_node.FlashAssists = value
 	}
+	if value, ok := mpc.mutation.AvgPing(); ok {
+		_spec.SetField(matchplayer.FieldAvgPing, field.TypeFloat64, value)
+		_node.AvgPing = value
+	}
 	if nodes := mpc.mutation.MatchesIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2O,

ent/matchplayer_update.go

@@ -772,6 +772,33 @@ func (mpu *MatchPlayerUpdate) ClearFlashAssists() *MatchPlayerUpdate {
 	return mpu
 }
 
+// SetAvgPing sets the "avg_ping" field.
+func (mpu *MatchPlayerUpdate) SetAvgPing(f float64) *MatchPlayerUpdate {
+	mpu.mutation.ResetAvgPing()
+	mpu.mutation.SetAvgPing(f)
+	return mpu
+}
+
+// SetNillableAvgPing sets the "avg_ping" field if the given value is not nil.
+func (mpu *MatchPlayerUpdate) SetNillableAvgPing(f *float64) *MatchPlayerUpdate {
+	if f != nil {
+		mpu.SetAvgPing(*f)
+	}
+	return mpu
+}
+
+// AddAvgPing adds f to the "avg_ping" field.
+func (mpu *MatchPlayerUpdate) AddAvgPing(f float64) *MatchPlayerUpdate {
+	mpu.mutation.AddAvgPing(f)
+	return mpu
+}
+
+// ClearAvgPing clears the value of the "avg_ping" field.
+func (mpu *MatchPlayerUpdate) ClearAvgPing() *MatchPlayerUpdate {
+	mpu.mutation.ClearAvgPing()
+	return mpu
+}
+
 // SetMatchesID sets the "matches" edge to the Match entity by ID.
 func (mpu *MatchPlayerUpdate) SetMatchesID(id uint64) *MatchPlayerUpdate {
 	mpu.mutation.SetMatchesID(id)
@@ -1308,6 +1335,15 @@ func (mpu *MatchPlayerUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if mpu.mutation.FlashAssistsCleared() {
 		_spec.ClearField(matchplayer.FieldFlashAssists, field.TypeInt)
 	}
+	if value, ok := mpu.mutation.AvgPing(); ok {
+		_spec.SetField(matchplayer.FieldAvgPing, field.TypeFloat64, value)
+	}
+	if value, ok := mpu.mutation.AddedAvgPing(); ok {
+		_spec.AddField(matchplayer.FieldAvgPing, field.TypeFloat64, value)
+	}
+	if mpu.mutation.AvgPingCleared() {
+		_spec.ClearField(matchplayer.FieldAvgPing, field.TypeFloat64)
+	}
 	if mpu.mutation.MatchesCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2O,
@@ -2353,6 +2389,33 @@ func (mpuo *MatchPlayerUpdateOne) ClearFlashAssists() *MatchPlayerUpdateOne {
 	return mpuo
 }
 
+// SetAvgPing sets the "avg_ping" field.
+func (mpuo *MatchPlayerUpdateOne) SetAvgPing(f float64) *MatchPlayerUpdateOne {
+	mpuo.mutation.ResetAvgPing()
+	mpuo.mutation.SetAvgPing(f)
+	return mpuo
+}
+
+// SetNillableAvgPing sets the "avg_ping" field if the given value is not nil.
+func (mpuo *MatchPlayerUpdateOne) SetNillableAvgPing(f *float64) *MatchPlayerUpdateOne {
+	if f != nil {
+		mpuo.SetAvgPing(*f)
+	}
+	return mpuo
+}
+
+// AddAvgPing adds f to the "avg_ping" field.
+func (mpuo *MatchPlayerUpdateOne) AddAvgPing(f float64) *MatchPlayerUpdateOne {
+	mpuo.mutation.AddAvgPing(f)
+	return mpuo
+}
+
+// ClearAvgPing clears the value of the "avg_ping" field.
+func (mpuo *MatchPlayerUpdateOne) ClearAvgPing() *MatchPlayerUpdateOne {
+	mpuo.mutation.ClearAvgPing()
+	return mpuo
+}
+
 // SetMatchesID sets the "matches" edge to the Match entity by ID.
 func (mpuo *MatchPlayerUpdateOne) SetMatchesID(id uint64) *MatchPlayerUpdateOne {
 	mpuo.mutation.SetMatchesID(id)
@@ -2919,6 +2982,15 @@ func (mpuo *MatchPlayerUpdateOne) sqlSave(ctx context.Context) (_node *MatchPlay
 	if mpuo.mutation.FlashAssistsCleared() {
 		_spec.ClearField(matchplayer.FieldFlashAssists, field.TypeInt)
 	}
+	if value, ok := mpuo.mutation.AvgPing(); ok {
+		_spec.SetField(matchplayer.FieldAvgPing, field.TypeFloat64, value)
+	}
+	if value, ok := mpuo.mutation.AddedAvgPing(); ok {
+		_spec.AddField(matchplayer.FieldAvgPing, field.TypeFloat64, value)
+	}
+	if mpuo.mutation.AvgPingCleared() {
+		_spec.ClearField(matchplayer.FieldAvgPing, field.TypeFloat64)
+	}
 	if mpuo.mutation.MatchesCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2O,

ent/migrate/schema.go

@@ -65,6 +65,7 @@ var (
 		{Name: "flash_total_team", Type: field.TypeUint, Nullable: true},
 		{Name: "flash_total_enemy", Type: field.TypeUint, Nullable: true},
 		{Name: "flash_assists", Type: field.TypeInt, Nullable: true},
+		{Name: "avg_ping", Type: field.TypeFloat64, Nullable: true},
 		{Name: "match_stats", Type: field.TypeUint64, Nullable: true},
 		{Name: "player_stats", Type: field.TypeUint64, Nullable: true},
 	}
@@ -76,13 +77,13 @@ var (
 		ForeignKeys: []*schema.ForeignKey{
 			{
 				Symbol:     "match_players_matches_stats",
-				Columns:    []*schema.Column{MatchPlayersColumns[31]},
+				Columns:    []*schema.Column{MatchPlayersColumns[32]},
 				RefColumns: []*schema.Column{MatchesColumns[0]},
 				OnDelete:   schema.SetNull,
 			},
 			{
 				Symbol:     "match_players_players_stats",
-				Columns:    []*schema.Column{MatchPlayersColumns[32]},
+				Columns:    []*schema.Column{MatchPlayersColumns[33]},
 				RefColumns: []*schema.Column{PlayersColumns[0]},
 				OnDelete:   schema.SetNull,
 			},

ent/mutation.go

@@ -1579,6 +1579,8 @@ type MatchPlayerMutation struct {
 	addflash_total_enemy    *int
 	flash_assists           *int
 	addflash_assists        *int
+	avg_ping                *float64
+	addavg_ping             *float64
 	clearedFields           map[string]struct{}
 	matches                 *uint64
 	clearedmatches          bool
@@ -3757,6 +3759,76 @@ func (m *MatchPlayerMutation) ResetFlashAssists() {
 	delete(m.clearedFields, matchplayer.FieldFlashAssists)
 }
 
+// SetAvgPing sets the "avg_ping" field.
+func (m *MatchPlayerMutation) SetAvgPing(f float64) {
+	m.avg_ping = &f
+	m.addavg_ping = nil
+}
+
+// AvgPing returns the value of the "avg_ping" field in the mutation.
+func (m *MatchPlayerMutation) AvgPing() (r float64, exists bool) {
+	v := m.avg_ping
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldAvgPing returns the old "avg_ping" field's value of the MatchPlayer entity.
+// If the MatchPlayer 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 *MatchPlayerMutation) OldAvgPing(ctx context.Context) (v float64, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldAvgPing is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldAvgPing requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldAvgPing: %w", err)
+	}
+	return oldValue.AvgPing, nil
+}
+
+// AddAvgPing adds f to the "avg_ping" field.
+func (m *MatchPlayerMutation) AddAvgPing(f float64) {
+	if m.addavg_ping != nil {
+		*m.addavg_ping += f
+	} else {
+		m.addavg_ping = &f
+	}
+}
+
+// AddedAvgPing returns the value that was added to the "avg_ping" field in this mutation.
+func (m *MatchPlayerMutation) AddedAvgPing() (r float64, exists bool) {
+	v := m.addavg_ping
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ClearAvgPing clears the value of the "avg_ping" field.
+func (m *MatchPlayerMutation) ClearAvgPing() {
+	m.avg_ping = nil
+	m.addavg_ping = nil
+	m.clearedFields[matchplayer.FieldAvgPing] = struct{}{}
+}
+
+// AvgPingCleared returns if the "avg_ping" field was cleared in this mutation.
+func (m *MatchPlayerMutation) AvgPingCleared() bool {
+	_, ok := m.clearedFields[matchplayer.FieldAvgPing]
+	return ok
+}
+
+// ResetAvgPing resets all changes to the "avg_ping" field.
+func (m *MatchPlayerMutation) ResetAvgPing() {
+	m.avg_ping = nil
+	m.addavg_ping = nil
+	delete(m.clearedFields, matchplayer.FieldAvgPing)
+}
+
 // SetMatchesID sets the "matches" edge to the Match entity by id.
 func (m *MatchPlayerMutation) SetMatchesID(id uint64) {
 	m.matches = &id
@@ -4070,7 +4142,7 @@ func (m *MatchPlayerMutation) Type() string {
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
 func (m *MatchPlayerMutation) Fields() []string {
-	fields := make([]string, 0, 32)
+	fields := make([]string, 0, 33)
 	if m.team_id != nil {
 		fields = append(fields, matchplayer.FieldTeamID)
 	}
@@ -4167,6 +4239,9 @@ func (m *MatchPlayerMutation) Fields() []string {
 	if m.flash_assists != nil {
 		fields = append(fields, matchplayer.FieldFlashAssists)
 	}
+	if m.avg_ping != nil {
+		fields = append(fields, matchplayer.FieldAvgPing)
+	}
 	return fields
 }
 
@@ -4239,6 +4314,8 @@ func (m *MatchPlayerMutation) Field(name string) (ent.Value, bool) {
 		return m.PlayerStats()
 	case matchplayer.FieldFlashAssists:
 		return m.FlashAssists()
+	case matchplayer.FieldAvgPing:
+		return m.AvgPing()
 	}
 	return nil, false
 }
@@ -4312,6 +4389,8 @@ func (m *MatchPlayerMutation) OldField(ctx context.Context, name string) (ent.Va
 		return m.OldPlayerStats(ctx)
 	case matchplayer.FieldFlashAssists:
 		return m.OldFlashAssists(ctx)
+	case matchplayer.FieldAvgPing:
+		return m.OldAvgPing(ctx)
 	}
 	return nil, fmt.Errorf("unknown MatchPlayer field %s", name)
 }
@@ -4545,6 +4624,13 @@ func (m *MatchPlayerMutation) SetField(name string, value ent.Value) error {
 		}
 		m.SetFlashAssists(v)
 		return nil
+	case matchplayer.FieldAvgPing:
+		v, ok := value.(float64)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetAvgPing(v)
+		return nil
 	}
 	return fmt.Errorf("unknown MatchPlayer field %s", name)
 }
@@ -4637,6 +4723,9 @@ func (m *MatchPlayerMutation) AddedFields() []string {
 	if m.addflash_assists != nil {
 		fields = append(fields, matchplayer.FieldFlashAssists)
 	}
+	if m.addavg_ping != nil {
+		fields = append(fields, matchplayer.FieldAvgPing)
+	}
 	return fields
 }
 
@@ -4701,6 +4790,8 @@ func (m *MatchPlayerMutation) AddedField(name string) (ent.Value, bool) {
 		return m.AddedFlashTotalEnemy()
 	case matchplayer.FieldFlashAssists:
 		return m.AddedFlashAssists()
+	case matchplayer.FieldAvgPing:
+		return m.AddedAvgPing()
 	}
 	return nil, false
 }
@@ -4906,6 +4997,13 @@ func (m *MatchPlayerMutation) AddField(name string, value ent.Value) error {
 		}
 		m.AddFlashAssists(v)
 		return nil
+	case matchplayer.FieldAvgPing:
+		v, ok := value.(float64)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddAvgPing(v)
+		return nil
 	}
 	return fmt.Errorf("unknown MatchPlayer numeric field %s", name)
 }
@@ -4989,6 +5087,9 @@ func (m *MatchPlayerMutation) ClearedFields() []string {
 	if m.FieldCleared(matchplayer.FieldFlashAssists) {
 		fields = append(fields, matchplayer.FieldFlashAssists)
 	}
+	if m.FieldCleared(matchplayer.FieldAvgPing) {
+		fields = append(fields, matchplayer.FieldAvgPing)
+	}
 	return fields
 }
 
@@ -5078,6 +5179,9 @@ func (m *MatchPlayerMutation) ClearField(name string) error {
 	case matchplayer.FieldFlashAssists:
 		m.ClearFlashAssists()
 		return nil
+	case matchplayer.FieldAvgPing:
+		m.ClearAvgPing()
+		return nil
 	}
 	return fmt.Errorf("unknown MatchPlayer nullable field %s", name)
 }
@@ -5182,6 +5286,9 @@ func (m *MatchPlayerMutation) ResetField(name string) error {
 	case matchplayer.FieldFlashAssists:
 		m.ResetFlashAssists()
 		return nil
+	case matchplayer.FieldAvgPing:
+		m.ResetAvgPing()
+		return nil
 	}
 	return fmt.Errorf("unknown MatchPlayer field %s", name)
 }

ent/schema/matchplayer.go

@@ -46,6 +46,7 @@ func (MatchPlayer) Fields() []ent.Field {
 		field.Uint64("match_stats").Optional(),
 		field.Uint64("player_stats").Optional(),
 		field.Int("flash_assists").Optional(),
+		field.Float("avg_ping").Optional(),
 	}
 }