CSGOWTF/csgowtfd
3
0
Fork 0
Code Issues Pull Requests Releases 1 Wiki Activity

regenerate ent

Browse Source
This commit is contained in:
Giovanni Harting
2025-10-26 05:09:47 +01:00
parent 5358d9dd0f
commit ab8b0b983c
46 changed files with 6050 additions and 5607 deletions
Download Patch File Download Diff File Expand all files Collapse all files

468
ent/matchplayer_query.go
View File

@@ -8,6 +8,7 @@ import (
"fmt"
"math"
"entgo.io/ent"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
"entgo.io/ent/schema/field"
@@ -41,44 +42,44 @@ type MatchPlayerQuery struct {
}
// Where adds a new predicate for the MatchPlayerQuery builder.
func (mpq *MatchPlayerQuery) Where(ps ...predicate.MatchPlayer) *MatchPlayerQuery {
mpq.predicates = append(mpq.predicates, ps...)
return mpq
func (_q *MatchPlayerQuery) Where(ps ...predicate.MatchPlayer) *MatchPlayerQuery {
_q.predicates = append(_q.predicates, ps...)
return _q
}
// Limit the number of records to be returned by this query.
func (mpq *MatchPlayerQuery) Limit(limit int) *MatchPlayerQuery {
mpq.ctx.Limit = &limit
return mpq
func (_q *MatchPlayerQuery) Limit(limit int) *MatchPlayerQuery {
_q.ctx.Limit = &limit
return _q
}
// Offset to start from.
func (mpq *MatchPlayerQuery) Offset(offset int) *MatchPlayerQuery {
mpq.ctx.Offset = &offset
return mpq
func (_q *MatchPlayerQuery) Offset(offset int) *MatchPlayerQuery {
_q.ctx.Offset = &offset
return _q
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (mpq *MatchPlayerQuery) Unique(unique bool) *MatchPlayerQuery {
mpq.ctx.Unique = &unique
return mpq
func (_q *MatchPlayerQuery) Unique(unique bool) *MatchPlayerQuery {
_q.ctx.Unique = &unique
return _q
}
// Order specifies how the records should be ordered.
func (mpq *MatchPlayerQuery) Order(o ...matchplayer.OrderOption) *MatchPlayerQuery {
mpq.order = append(mpq.order, o...)
return mpq
func (_q *MatchPlayerQuery) Order(o ...matchplayer.OrderOption) *MatchPlayerQuery {
_q.order = append(_q.order, o...)
return _q
}
// QueryMatches chains the current query on the "matches" edge.
func (mpq *MatchPlayerQuery) QueryMatches() *MatchQuery {
query := (&MatchClient{config: mpq.config}).Query()
func (_q *MatchPlayerQuery) QueryMatches() *MatchQuery {
query := (&MatchClient{config: _q.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := mpq.prepareQuery(ctx); err != nil {
if err := _q.prepareQuery(ctx); err != nil {
return nil, err
}
selector := mpq.sqlQuery(ctx)
selector := _q.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
@@ -87,20 +88,20 @@ func (mpq *MatchPlayerQuery) QueryMatches() *MatchQuery {
sqlgraph.To(match.Table, match.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, matchplayer.MatchesTable, matchplayer.MatchesColumn),
)
fromU = sqlgraph.SetNeighbors(mpq.driver.Dialect(), step)
fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
return fromU, nil
}
return query
}
// QueryPlayers chains the current query on the "players" edge.
func (mpq *MatchPlayerQuery) QueryPlayers() *PlayerQuery {
query := (&PlayerClient{config: mpq.config}).Query()
func (_q *MatchPlayerQuery) QueryPlayers() *PlayerQuery {
query := (&PlayerClient{config: _q.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := mpq.prepareQuery(ctx); err != nil {
if err := _q.prepareQuery(ctx); err != nil {
return nil, err
}
selector := mpq.sqlQuery(ctx)
selector := _q.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
@@ -109,20 +110,20 @@ func (mpq *MatchPlayerQuery) QueryPlayers() *PlayerQuery {
sqlgraph.To(player.Table, player.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, matchplayer.PlayersTable, matchplayer.PlayersColumn),
)
fromU = sqlgraph.SetNeighbors(mpq.driver.Dialect(), step)
fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
return fromU, nil
}
return query
}
// QueryWeaponStats chains the current query on the "weapon_stats" edge.
func (mpq *MatchPlayerQuery) QueryWeaponStats() *WeaponQuery {
query := (&WeaponClient{config: mpq.config}).Query()
func (_q *MatchPlayerQuery) QueryWeaponStats() *WeaponQuery {
query := (&WeaponClient{config: _q.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := mpq.prepareQuery(ctx); err != nil {
if err := _q.prepareQuery(ctx); err != nil {
return nil, err
}
selector := mpq.sqlQuery(ctx)
selector := _q.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
@@ -131,20 +132,20 @@ func (mpq *MatchPlayerQuery) QueryWeaponStats() *WeaponQuery {
sqlgraph.To(weapon.Table, weapon.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, matchplayer.WeaponStatsTable, matchplayer.WeaponStatsColumn),
)
fromU = sqlgraph.SetNeighbors(mpq.driver.Dialect(), step)
fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
return fromU, nil
}
return query
}
// QueryRoundStats chains the current query on the "round_stats" edge.
func (mpq *MatchPlayerQuery) QueryRoundStats() *RoundStatsQuery {
query := (&RoundStatsClient{config: mpq.config}).Query()
func (_q *MatchPlayerQuery) QueryRoundStats() *RoundStatsQuery {
query := (&RoundStatsClient{config: _q.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := mpq.prepareQuery(ctx); err != nil {
if err := _q.prepareQuery(ctx); err != nil {
return nil, err
}
selector := mpq.sqlQuery(ctx)
selector := _q.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
@@ -153,20 +154,20 @@ func (mpq *MatchPlayerQuery) QueryRoundStats() *RoundStatsQuery {
sqlgraph.To(roundstats.Table, roundstats.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, matchplayer.RoundStatsTable, matchplayer.RoundStatsColumn),
)
fromU = sqlgraph.SetNeighbors(mpq.driver.Dialect(), step)
fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
return fromU, nil
}
return query
}
// QuerySpray chains the current query on the "spray" edge.
func (mpq *MatchPlayerQuery) QuerySpray() *SprayQuery {
query := (&SprayClient{config: mpq.config}).Query()
func (_q *MatchPlayerQuery) QuerySpray() *SprayQuery {
query := (&SprayClient{config: _q.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := mpq.prepareQuery(ctx); err != nil {
if err := _q.prepareQuery(ctx); err != nil {
return nil, err
}
selector := mpq.sqlQuery(ctx)
selector := _q.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
@@ -175,20 +176,20 @@ func (mpq *MatchPlayerQuery) QuerySpray() *SprayQuery {
sqlgraph.To(spray.Table, spray.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, matchplayer.SprayTable, matchplayer.SprayColumn),
)
fromU = sqlgraph.SetNeighbors(mpq.driver.Dialect(), step)
fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
return fromU, nil
}
return query
}
// QueryMessages chains the current query on the "messages" edge.
func (mpq *MatchPlayerQuery) QueryMessages() *MessagesQuery {
query := (&MessagesClient{config: mpq.config}).Query()
func (_q *MatchPlayerQuery) QueryMessages() *MessagesQuery {
query := (&MessagesClient{config: _q.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := mpq.prepareQuery(ctx); err != nil {
if err := _q.prepareQuery(ctx); err != nil {
return nil, err
}
selector := mpq.sqlQuery(ctx)
selector := _q.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
@@ -197,7 +198,7 @@ func (mpq *MatchPlayerQuery) QueryMessages() *MessagesQuery {
sqlgraph.To(messages.Table, messages.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, matchplayer.MessagesTable, matchplayer.MessagesColumn),
)
fromU = sqlgraph.SetNeighbors(mpq.driver.Dialect(), step)
fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
return fromU, nil
}
return query
@@ -205,8 +206,8 @@ func (mpq *MatchPlayerQuery) QueryMessages() *MessagesQuery {
// First returns the first MatchPlayer entity from the query.
// Returns a *NotFoundError when no MatchPlayer was found.
func (mpq *MatchPlayerQuery) First(ctx context.Context) (*MatchPlayer, error) {
nodes, err := mpq.Limit(1).All(setContextOp(ctx, mpq.ctx, "First"))
func (_q *MatchPlayerQuery) First(ctx context.Context) (*MatchPlayer, error) {
nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
if err != nil {
return nil, err
}
@@ -217,8 +218,8 @@ func (mpq *MatchPlayerQuery) First(ctx context.Context) (*MatchPlayer, error) {
}
// FirstX is like First, but panics if an error occurs.
func (mpq *MatchPlayerQuery) FirstX(ctx context.Context) *MatchPlayer {
node, err := mpq.First(ctx)
func (_q *MatchPlayerQuery) FirstX(ctx context.Context) *MatchPlayer {
node, err := _q.First(ctx)
if err != nil && !IsNotFound(err) {
panic(err)
}
@@ -227,9 +228,9 @@ func (mpq *MatchPlayerQuery) FirstX(ctx context.Context) *MatchPlayer {
// FirstID returns the first MatchPlayer ID from the query.
// Returns a *NotFoundError when no MatchPlayer ID was found.
func (mpq *MatchPlayerQuery) FirstID(ctx context.Context) (id int, err error) {
func (_q *MatchPlayerQuery) FirstID(ctx context.Context) (id int, err error) {
var ids []int
if ids, err = mpq.Limit(1).IDs(setContextOp(ctx, mpq.ctx, "FirstID")); err != nil {
if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
return
}
if len(ids) == 0 {
@@ -240,8 +241,8 @@ func (mpq *MatchPlayerQuery) FirstID(ctx context.Context) (id int, err error) {
}
// FirstIDX is like FirstID, but panics if an error occurs.
func (mpq *MatchPlayerQuery) FirstIDX(ctx context.Context) int {
id, err := mpq.FirstID(ctx)
func (_q *MatchPlayerQuery) FirstIDX(ctx context.Context) int {
id, err := _q.FirstID(ctx)
if err != nil && !IsNotFound(err) {
panic(err)
}
@@ -251,8 +252,8 @@ func (mpq *MatchPlayerQuery) FirstIDX(ctx context.Context) int {
// Only returns a single MatchPlayer entity found by the query, ensuring it only returns one.
// Returns a *NotSingularError when more than one MatchPlayer entity is found.
// Returns a *NotFoundError when no MatchPlayer entities are found.
func (mpq *MatchPlayerQuery) Only(ctx context.Context) (*MatchPlayer, error) {
nodes, err := mpq.Limit(2).All(setContextOp(ctx, mpq.ctx, "Only"))
func (_q *MatchPlayerQuery) Only(ctx context.Context) (*MatchPlayer, error) {
nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
if err != nil {
return nil, err
}
@@ -267,8 +268,8 @@ func (mpq *MatchPlayerQuery) Only(ctx context.Context) (*MatchPlayer, error) {
}
// OnlyX is like Only, but panics if an error occurs.
func (mpq *MatchPlayerQuery) OnlyX(ctx context.Context) *MatchPlayer {
node, err := mpq.Only(ctx)
func (_q *MatchPlayerQuery) OnlyX(ctx context.Context) *MatchPlayer {
node, err := _q.Only(ctx)
if err != nil {
panic(err)
}
@@ -278,9 +279,9 @@ func (mpq *MatchPlayerQuery) OnlyX(ctx context.Context) *MatchPlayer {
// OnlyID is like Only, but returns the only MatchPlayer ID in the query.
// Returns a *NotSingularError when more than one MatchPlayer ID is found.
// Returns a *NotFoundError when no entities are found.
func (mpq *MatchPlayerQuery) OnlyID(ctx context.Context) (id int, err error) {
func (_q *MatchPlayerQuery) OnlyID(ctx context.Context) (id int, err error) {
var ids []int
if ids, err = mpq.Limit(2).IDs(setContextOp(ctx, mpq.ctx, "OnlyID")); err != nil {
if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
return
}
switch len(ids) {
@@ -295,8 +296,8 @@ func (mpq *MatchPlayerQuery) OnlyID(ctx context.Context) (id int, err error) {
}
// OnlyIDX is like OnlyID, but panics if an error occurs.
func (mpq *MatchPlayerQuery) OnlyIDX(ctx context.Context) int {
id, err := mpq.OnlyID(ctx)
func (_q *MatchPlayerQuery) OnlyIDX(ctx context.Context) int {
id, err := _q.OnlyID(ctx)
if err != nil {
panic(err)
}
@@ -304,18 +305,18 @@ func (mpq *MatchPlayerQuery) OnlyIDX(ctx context.Context) int {
}
// All executes the query and returns a list of MatchPlayers.
func (mpq *MatchPlayerQuery) All(ctx context.Context) ([]*MatchPlayer, error) {
ctx = setContextOp(ctx, mpq.ctx, "All")
if err := mpq.prepareQuery(ctx); err != nil {
func (_q *MatchPlayerQuery) All(ctx context.Context) ([]*MatchPlayer, error) {
ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
if err := _q.prepareQuery(ctx); err != nil {
return nil, err
}
qr := querierAll[[]*MatchPlayer, *MatchPlayerQuery]()
return withInterceptors[[]*MatchPlayer](ctx, mpq, qr, mpq.inters)
return withInterceptors[[]*MatchPlayer](ctx, _q, qr, _q.inters)
}
// AllX is like All, but panics if an error occurs.
func (mpq *MatchPlayerQuery) AllX(ctx context.Context) []*MatchPlayer {
nodes, err := mpq.All(ctx)
func (_q *MatchPlayerQuery) AllX(ctx context.Context) []*MatchPlayer {
nodes, err := _q.All(ctx)
if err != nil {
panic(err)
}
@@ -323,20 +324,20 @@ func (mpq *MatchPlayerQuery) AllX(ctx context.Context) []*MatchPlayer {
}
// IDs executes the query and returns a list of MatchPlayer IDs.
func (mpq *MatchPlayerQuery) IDs(ctx context.Context) (ids []int, err error) {
if mpq.ctx.Unique == nil && mpq.path != nil {
mpq.Unique(true)
func (_q *MatchPlayerQuery) IDs(ctx context.Context) (ids []int, err error) {
if _q.ctx.Unique == nil && _q.path != nil {
_q.Unique(true)
}
ctx = setContextOp(ctx, mpq.ctx, "IDs")
if err = mpq.Select(matchplayer.FieldID).Scan(ctx, &ids); err != nil {
ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
if err = _q.Select(matchplayer.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
}
// IDsX is like IDs, but panics if an error occurs.
func (mpq *MatchPlayerQuery) IDsX(ctx context.Context) []int {
ids, err := mpq.IDs(ctx)
func (_q *MatchPlayerQuery) IDsX(ctx context.Context) []int {
ids, err := _q.IDs(ctx)
if err != nil {
panic(err)
}
@@ -344,17 +345,17 @@ func (mpq *MatchPlayerQuery) IDsX(ctx context.Context) []int {
}
// Count returns the count of the given query.
func (mpq *MatchPlayerQuery) Count(ctx context.Context) (int, error) {
ctx = setContextOp(ctx, mpq.ctx, "Count")
if err := mpq.prepareQuery(ctx); err != nil {
func (_q *MatchPlayerQuery) Count(ctx context.Context) (int, error) {
ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
if err := _q.prepareQuery(ctx); err != nil {
return 0, err
}
return withInterceptors[int](ctx, mpq, querierCount[*MatchPlayerQuery](), mpq.inters)
return withInterceptors[int](ctx, _q, querierCount[*MatchPlayerQuery](), _q.inters)
}
// CountX is like Count, but panics if an error occurs.
func (mpq *MatchPlayerQuery) CountX(ctx context.Context) int {
count, err := mpq.Count(ctx)
func (_q *MatchPlayerQuery) CountX(ctx context.Context) int {
count, err := _q.Count(ctx)
if err != nil {
panic(err)
}
@@ -362,9 +363,9 @@ func (mpq *MatchPlayerQuery) CountX(ctx context.Context) int {
}
// Exist returns true if the query has elements in the graph.
func (mpq *MatchPlayerQuery) Exist(ctx context.Context) (bool, error) {
ctx = setContextOp(ctx, mpq.ctx, "Exist")
switch _, err := mpq.FirstID(ctx); {
func (_q *MatchPlayerQuery) Exist(ctx context.Context) (bool, error) {
ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
switch _, err := _q.FirstID(ctx); {
case IsNotFound(err):
return false, nil
case err != nil:
@@ -375,8 +376,8 @@ func (mpq *MatchPlayerQuery) Exist(ctx context.Context) (bool, error) {
}
// ExistX is like Exist, but panics if an error occurs.
func (mpq *MatchPlayerQuery) ExistX(ctx context.Context) bool {
exist, err := mpq.Exist(ctx)
func (_q *MatchPlayerQuery) ExistX(ctx context.Context) bool {
exist, err := _q.Exist(ctx)
if err != nil {
panic(err)
}
@@ -385,92 +386,93 @@ func (mpq *MatchPlayerQuery) ExistX(ctx context.Context) bool {
// Clone returns a duplicate of the MatchPlayerQuery builder, including all associated steps. It can be
// used to prepare common query builders and use them differently after the clone is made.
func (mpq *MatchPlayerQuery) Clone() *MatchPlayerQuery {
if mpq == nil {
func (_q *MatchPlayerQuery) Clone() *MatchPlayerQuery {
if _q == nil {
return nil
}
return &MatchPlayerQuery{
config: mpq.config,
ctx: mpq.ctx.Clone(),
order: append([]matchplayer.OrderOption{}, mpq.order...),
inters: append([]Interceptor{}, mpq.inters...),
predicates: append([]predicate.MatchPlayer{}, mpq.predicates...),
withMatches: mpq.withMatches.Clone(),
withPlayers: mpq.withPlayers.Clone(),
withWeaponStats: mpq.withWeaponStats.Clone(),
withRoundStats: mpq.withRoundStats.Clone(),
withSpray: mpq.withSpray.Clone(),
withMessages: mpq.withMessages.Clone(),
config: _q.config,
ctx: _q.ctx.Clone(),
order: append([]matchplayer.OrderOption{}, _q.order...),
inters: append([]Interceptor{}, _q.inters...),
predicates: append([]predicate.MatchPlayer{}, _q.predicates...),
withMatches: _q.withMatches.Clone(),
withPlayers: _q.withPlayers.Clone(),
withWeaponStats: _q.withWeaponStats.Clone(),
withRoundStats: _q.withRoundStats.Clone(),
withSpray: _q.withSpray.Clone(),
withMessages: _q.withMessages.Clone(),
// clone intermediate query.
sql: mpq.sql.Clone(),
path: mpq.path,
sql: _q.sql.Clone(),
path: _q.path,
modifiers: append([]func(*sql.Selector){}, _q.modifiers...),
}
}
// WithMatches tells the query-builder to eager-load the nodes that are connected to
// the "matches" edge. The optional arguments are used to configure the query builder of the edge.
func (mpq *MatchPlayerQuery) WithMatches(opts ...func(*MatchQuery)) *MatchPlayerQuery {
query := (&MatchClient{config: mpq.config}).Query()
func (_q *MatchPlayerQuery) WithMatches(opts ...func(*MatchQuery)) *MatchPlayerQuery {
query := (&MatchClient{config: _q.config}).Query()
for _, opt := range opts {
opt(query)
}
mpq.withMatches = query
return mpq
_q.withMatches = query
return _q
}
// WithPlayers tells the query-builder to eager-load the nodes that are connected to
// the "players" edge. The optional arguments are used to configure the query builder of the edge.
func (mpq *MatchPlayerQuery) WithPlayers(opts ...func(*PlayerQuery)) *MatchPlayerQuery {
query := (&PlayerClient{config: mpq.config}).Query()
func (_q *MatchPlayerQuery) WithPlayers(opts ...func(*PlayerQuery)) *MatchPlayerQuery {
query := (&PlayerClient{config: _q.config}).Query()
for _, opt := range opts {
opt(query)
}
mpq.withPlayers = query
return mpq
_q.withPlayers = query
return _q
}
// WithWeaponStats tells the query-builder to eager-load the nodes that are connected to
// the "weapon_stats" edge. The optional arguments are used to configure the query builder of the edge.
func (mpq *MatchPlayerQuery) WithWeaponStats(opts ...func(*WeaponQuery)) *MatchPlayerQuery {
query := (&WeaponClient{config: mpq.config}).Query()
func (_q *MatchPlayerQuery) WithWeaponStats(opts ...func(*WeaponQuery)) *MatchPlayerQuery {
query := (&WeaponClient{config: _q.config}).Query()
for _, opt := range opts {
opt(query)
}
mpq.withWeaponStats = query
return mpq
_q.withWeaponStats = query
return _q
}
// WithRoundStats tells the query-builder to eager-load the nodes that are connected to
// the "round_stats" edge. The optional arguments are used to configure the query builder of the edge.
func (mpq *MatchPlayerQuery) WithRoundStats(opts ...func(*RoundStatsQuery)) *MatchPlayerQuery {
query := (&RoundStatsClient{config: mpq.config}).Query()
func (_q *MatchPlayerQuery) WithRoundStats(opts ...func(*RoundStatsQuery)) *MatchPlayerQuery {
query := (&RoundStatsClient{config: _q.config}).Query()
for _, opt := range opts {
opt(query)
}
mpq.withRoundStats = query
return mpq
_q.withRoundStats = query
return _q
}
// WithSpray tells the query-builder to eager-load the nodes that are connected to
// the "spray" edge. The optional arguments are used to configure the query builder of the edge.
func (mpq *MatchPlayerQuery) WithSpray(opts ...func(*SprayQuery)) *MatchPlayerQuery {
query := (&SprayClient{config: mpq.config}).Query()
func (_q *MatchPlayerQuery) WithSpray(opts ...func(*SprayQuery)) *MatchPlayerQuery {
query := (&SprayClient{config: _q.config}).Query()
for _, opt := range opts {
opt(query)
}
mpq.withSpray = query
return mpq
_q.withSpray = query
return _q
}
// WithMessages tells the query-builder to eager-load the nodes that are connected to
// the "messages" edge. The optional arguments are used to configure the query builder of the edge.
func (mpq *MatchPlayerQuery) WithMessages(opts ...func(*MessagesQuery)) *MatchPlayerQuery {
query := (&MessagesClient{config: mpq.config}).Query()
func (_q *MatchPlayerQuery) WithMessages(opts ...func(*MessagesQuery)) *MatchPlayerQuery {
query := (&MessagesClient{config: _q.config}).Query()
for _, opt := range opts {
opt(query)
}
mpq.withMessages = query
return mpq
_q.withMessages = query
return _q
}
// GroupBy is used to group vertices by one or more fields/columns.
@@ -487,10 +489,10 @@ func (mpq *MatchPlayerQuery) WithMessages(opts ...func(*MessagesQuery)) *MatchPl
// GroupBy(matchplayer.FieldTeamID).
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (mpq *MatchPlayerQuery) GroupBy(field string, fields ...string) *MatchPlayerGroupBy {
mpq.ctx.Fields = append([]string{field}, fields...)
grbuild := &MatchPlayerGroupBy{build: mpq}
grbuild.flds = &mpq.ctx.Fields
func (_q *MatchPlayerQuery) GroupBy(field string, fields ...string) *MatchPlayerGroupBy {
_q.ctx.Fields = append([]string{field}, fields...)
grbuild := &MatchPlayerGroupBy{build: _q}
grbuild.flds = &_q.ctx.Fields
grbuild.label = matchplayer.Label
grbuild.scan = grbuild.Scan
return grbuild
@@ -508,114 +510,114 @@ func (mpq *MatchPlayerQuery) GroupBy(field string, fields ...string) *MatchPlaye
// client.MatchPlayer.Query().
// Select(matchplayer.FieldTeamID).
// Scan(ctx, &v)
func (mpq *MatchPlayerQuery) Select(fields ...string) *MatchPlayerSelect {
mpq.ctx.Fields = append(mpq.ctx.Fields, fields...)
sbuild := &MatchPlayerSelect{MatchPlayerQuery: mpq}
func (_q *MatchPlayerQuery) Select(fields ...string) *MatchPlayerSelect {
_q.ctx.Fields = append(_q.ctx.Fields, fields...)
sbuild := &MatchPlayerSelect{MatchPlayerQuery: _q}
sbuild.label = matchplayer.Label
sbuild.flds, sbuild.scan = &mpq.ctx.Fields, sbuild.Scan
sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
return sbuild
}
// Aggregate returns a MatchPlayerSelect configured with the given aggregations.
func (mpq *MatchPlayerQuery) Aggregate(fns ...AggregateFunc) *MatchPlayerSelect {
return mpq.Select().Aggregate(fns...)
func (_q *MatchPlayerQuery) Aggregate(fns ...AggregateFunc) *MatchPlayerSelect {
return _q.Select().Aggregate(fns...)
}
func (mpq *MatchPlayerQuery) prepareQuery(ctx context.Context) error {
for _, inter := range mpq.inters {
func (_q *MatchPlayerQuery) prepareQuery(ctx context.Context) error {
for _, inter := range _q.inters {
if inter == nil {
return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
}
if trv, ok := inter.(Traverser); ok {
if err := trv.Traverse(ctx, mpq); err != nil {
if err := trv.Traverse(ctx, _q); err != nil {
return err
}
}
}
for _, f := range mpq.ctx.Fields {
for _, f := range _q.ctx.Fields {
if !matchplayer.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
}
if mpq.path != nil {
prev, err := mpq.path(ctx)
if _q.path != nil {
prev, err := _q.path(ctx)
if err != nil {
return err
}
mpq.sql = prev
_q.sql = prev
}
return nil
}
func (mpq *MatchPlayerQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*MatchPlayer, error) {
func (_q *MatchPlayerQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*MatchPlayer, error) {
var (
nodes = []*MatchPlayer{}
_spec = mpq.querySpec()
_spec = _q.querySpec()
loadedTypes = [6]bool{
mpq.withMatches != nil,
mpq.withPlayers != nil,
mpq.withWeaponStats != nil,
mpq.withRoundStats != nil,
mpq.withSpray != nil,
mpq.withMessages != nil,
_q.withMatches != nil,
_q.withPlayers != nil,
_q.withWeaponStats != nil,
_q.withRoundStats != nil,
_q.withSpray != nil,
_q.withMessages != nil,
}
)
_spec.ScanValues = func(columns []string) ([]any, error) {
return (*MatchPlayer).scanValues(nil, columns)
}
_spec.Assign = func(columns []string, values []any) error {
node := &MatchPlayer{config: mpq.config}
node := &MatchPlayer{config: _q.config}
nodes = append(nodes, node)
node.Edges.loadedTypes = loadedTypes
return node.assignValues(columns, values)
}
if len(mpq.modifiers) > 0 {
_spec.Modifiers = mpq.modifiers
if len(_q.modifiers) > 0 {
_spec.Modifiers = _q.modifiers
}
for i := range hooks {
hooks[i](ctx, _spec)
}
if err := sqlgraph.QueryNodes(ctx, mpq.driver, _spec); err != nil {
if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
return nil, err
}
if len(nodes) == 0 {
return nodes, nil
}
if query := mpq.withMatches; query != nil {
if err := mpq.loadMatches(ctx, query, nodes, nil,
if query := _q.withMatches; query != nil {
if err := _q.loadMatches(ctx, query, nodes, nil,
func(n *MatchPlayer, e *Match) { n.Edges.Matches = e }); err != nil {
return nil, err
}
}
if query := mpq.withPlayers; query != nil {
if err := mpq.loadPlayers(ctx, query, nodes, nil,
if query := _q.withPlayers; query != nil {
if err := _q.loadPlayers(ctx, query, nodes, nil,
func(n *MatchPlayer, e *Player) { n.Edges.Players = e }); err != nil {
return nil, err
}
}
if query := mpq.withWeaponStats; query != nil {
if err := mpq.loadWeaponStats(ctx, query, nodes,
if query := _q.withWeaponStats; query != nil {
if err := _q.loadWeaponStats(ctx, query, nodes,
func(n *MatchPlayer) { n.Edges.WeaponStats = []*Weapon{} },
func(n *MatchPlayer, e *Weapon) { n.Edges.WeaponStats = append(n.Edges.WeaponStats, e) }); err != nil {
return nil, err
}
}
if query := mpq.withRoundStats; query != nil {
if err := mpq.loadRoundStats(ctx, query, nodes,
if query := _q.withRoundStats; query != nil {
if err := _q.loadRoundStats(ctx, query, nodes,
func(n *MatchPlayer) { n.Edges.RoundStats = []*RoundStats{} },
func(n *MatchPlayer, e *RoundStats) { n.Edges.RoundStats = append(n.Edges.RoundStats, e) }); err != nil {
return nil, err
}
}
if query := mpq.withSpray; query != nil {
if err := mpq.loadSpray(ctx, query, nodes,
if query := _q.withSpray; query != nil {
if err := _q.loadSpray(ctx, query, nodes,
func(n *MatchPlayer) { n.Edges.Spray = []*Spray{} },
func(n *MatchPlayer, e *Spray) { n.Edges.Spray = append(n.Edges.Spray, e) }); err != nil {
return nil, err
}
}
if query := mpq.withMessages; query != nil {
if err := mpq.loadMessages(ctx, query, nodes,
if query := _q.withMessages; query != nil {
if err := _q.loadMessages(ctx, query, nodes,
func(n *MatchPlayer) { n.Edges.Messages = []*Messages{} },
func(n *MatchPlayer, e *Messages) { n.Edges.Messages = append(n.Edges.Messages, e) }); err != nil {
return nil, err
@@ -624,7 +626,7 @@ func (mpq *MatchPlayerQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]
return nodes, nil
}
func (mpq *MatchPlayerQuery) loadMatches(ctx context.Context, query *MatchQuery, nodes []*MatchPlayer, init func(*MatchPlayer), assign func(*MatchPlayer, *Match)) error {
func (_q *MatchPlayerQuery) loadMatches(ctx context.Context, query *MatchQuery, nodes []*MatchPlayer, init func(*MatchPlayer), assign func(*MatchPlayer, *Match)) error {
ids := make([]uint64, 0, len(nodes))
nodeids := make(map[uint64][]*MatchPlayer)
for i := range nodes {
@@ -653,7 +655,7 @@ func (mpq *MatchPlayerQuery) loadMatches(ctx context.Context, query *MatchQuery,
}
return nil
}
func (mpq *MatchPlayerQuery) loadPlayers(ctx context.Context, query *PlayerQuery, nodes []*MatchPlayer, init func(*MatchPlayer), assign func(*MatchPlayer, *Player)) error {
func (_q *MatchPlayerQuery) loadPlayers(ctx context.Context, query *PlayerQuery, nodes []*MatchPlayer, init func(*MatchPlayer), assign func(*MatchPlayer, *Player)) error {
ids := make([]uint64, 0, len(nodes))
nodeids := make(map[uint64][]*MatchPlayer)
for i := range nodes {
@@ -682,7 +684,7 @@ func (mpq *MatchPlayerQuery) loadPlayers(ctx context.Context, query *PlayerQuery
}
return nil
}
func (mpq *MatchPlayerQuery) loadWeaponStats(ctx context.Context, query *WeaponQuery, nodes []*MatchPlayer, init func(*MatchPlayer), assign func(*MatchPlayer, *Weapon)) error {
func (_q *MatchPlayerQuery) loadWeaponStats(ctx context.Context, query *WeaponQuery, nodes []*MatchPlayer, init func(*MatchPlayer), assign func(*MatchPlayer, *Weapon)) error {
fks := make([]driver.Value, 0, len(nodes))
nodeids := make(map[int]*MatchPlayer)
for i := range nodes {
@@ -713,7 +715,7 @@ func (mpq *MatchPlayerQuery) loadWeaponStats(ctx context.Context, query *WeaponQ
}
return nil
}
func (mpq *MatchPlayerQuery) loadRoundStats(ctx context.Context, query *RoundStatsQuery, nodes []*MatchPlayer, init func(*MatchPlayer), assign func(*MatchPlayer, *RoundStats)) error {
func (_q *MatchPlayerQuery) loadRoundStats(ctx context.Context, query *RoundStatsQuery, nodes []*MatchPlayer, init func(*MatchPlayer), assign func(*MatchPlayer, *RoundStats)) error {
fks := make([]driver.Value, 0, len(nodes))
nodeids := make(map[int]*MatchPlayer)
for i := range nodes {
@@ -744,7 +746,7 @@ func (mpq *MatchPlayerQuery) loadRoundStats(ctx context.Context, query *RoundSta
}
return nil
}
func (mpq *MatchPlayerQuery) loadSpray(ctx context.Context, query *SprayQuery, nodes []*MatchPlayer, init func(*MatchPlayer), assign func(*MatchPlayer, *Spray)) error {
func (_q *MatchPlayerQuery) loadSpray(ctx context.Context, query *SprayQuery, nodes []*MatchPlayer, init func(*MatchPlayer), assign func(*MatchPlayer, *Spray)) error {
fks := make([]driver.Value, 0, len(nodes))
nodeids := make(map[int]*MatchPlayer)
for i := range nodes {
@@ -775,7 +777,7 @@ func (mpq *MatchPlayerQuery) loadSpray(ctx context.Context, query *SprayQuery, n
}
return nil
}
func (mpq *MatchPlayerQuery) loadMessages(ctx context.Context, query *MessagesQuery, nodes []*MatchPlayer, init func(*MatchPlayer), assign func(*MatchPlayer, *Messages)) error {
func (_q *MatchPlayerQuery) loadMessages(ctx context.Context, query *MessagesQuery, nodes []*MatchPlayer, init func(*MatchPlayer), assign func(*MatchPlayer, *Messages)) error {
fks := make([]driver.Value, 0, len(nodes))
nodeids := make(map[int]*MatchPlayer)
for i := range nodes {
@@ -807,27 +809,27 @@ func (mpq *MatchPlayerQuery) loadMessages(ctx context.Context, query *MessagesQu
return nil
}
func (mpq *MatchPlayerQuery) sqlCount(ctx context.Context) (int, error) {
_spec := mpq.querySpec()
if len(mpq.modifiers) > 0 {
_spec.Modifiers = mpq.modifiers
func (_q *MatchPlayerQuery) sqlCount(ctx context.Context) (int, error) {
_spec := _q.querySpec()
if len(_q.modifiers) > 0 {
_spec.Modifiers = _q.modifiers
}
_spec.Node.Columns = mpq.ctx.Fields
if len(mpq.ctx.Fields) > 0 {
_spec.Unique = mpq.ctx.Unique != nil && *mpq.ctx.Unique
_spec.Node.Columns = _q.ctx.Fields
if len(_q.ctx.Fields) > 0 {
_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
}
return sqlgraph.CountNodes(ctx, mpq.driver, _spec)
return sqlgraph.CountNodes(ctx, _q.driver, _spec)
}
func (mpq *MatchPlayerQuery) querySpec() *sqlgraph.QuerySpec {
func (_q *MatchPlayerQuery) querySpec() *sqlgraph.QuerySpec {
_spec := sqlgraph.NewQuerySpec(matchplayer.Table, matchplayer.Columns, sqlgraph.NewFieldSpec(matchplayer.FieldID, field.TypeInt))
_spec.From = mpq.sql
if unique := mpq.ctx.Unique; unique != nil {
_spec.From = _q.sql
if unique := _q.ctx.Unique; unique != nil {
_spec.Unique = *unique
} else if mpq.path != nil {
} else if _q.path != nil {
_spec.Unique = true
}
if fields := mpq.ctx.Fields; len(fields) > 0 {
if fields := _q.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, matchplayer.FieldID)
for i := range fields {
@@ -835,27 +837,27 @@ func (mpq *MatchPlayerQuery) querySpec() *sqlgraph.QuerySpec {
_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
}
}
if mpq.withMatches != nil {
if _q.withMatches != nil {
_spec.Node.AddColumnOnce(matchplayer.FieldMatchStats)
}
if mpq.withPlayers != nil {
if _q.withPlayers != nil {
_spec.Node.AddColumnOnce(matchplayer.FieldPlayerStats)
}
}
if ps := mpq.predicates; len(ps) > 0 {
if ps := _q.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
}
if limit := mpq.ctx.Limit; limit != nil {
if limit := _q.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
if offset := mpq.ctx.Offset; offset != nil {
if offset := _q.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := mpq.order; len(ps) > 0 {
if ps := _q.order; len(ps) > 0 {
_spec.Order = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
@@ -865,45 +867,45 @@ func (mpq *MatchPlayerQuery) querySpec() *sqlgraph.QuerySpec {
return _spec
}
func (mpq *MatchPlayerQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(mpq.driver.Dialect())
func (_q *MatchPlayerQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(_q.driver.Dialect())
t1 := builder.Table(matchplayer.Table)
columns := mpq.ctx.Fields
columns := _q.ctx.Fields
if len(columns) == 0 {
columns = matchplayer.Columns
}
selector := builder.Select(t1.Columns(columns...)...).From(t1)
if mpq.sql != nil {
selector = mpq.sql
if _q.sql != nil {
selector = _q.sql
selector.Select(selector.Columns(columns...)...)
}
if mpq.ctx.Unique != nil && *mpq.ctx.Unique {
if _q.ctx.Unique != nil && *_q.ctx.Unique {
selector.Distinct()
}
for _, m := range mpq.modifiers {
for _, m := range _q.modifiers {
m(selector)
}
for _, p := range mpq.predicates {
for _, p := range _q.predicates {
p(selector)
}
for _, p := range mpq.order {
for _, p := range _q.order {
p(selector)
}
if offset := mpq.ctx.Offset; offset != nil {
if offset := _q.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
if limit := mpq.ctx.Limit; limit != nil {
if limit := _q.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
}
// Modify adds a query modifier for attaching custom logic to queries.
func (mpq *MatchPlayerQuery) Modify(modifiers ...func(s *sql.Selector)) *MatchPlayerSelect {
mpq.modifiers = append(mpq.modifiers, modifiers...)
return mpq.Select()
func (_q *MatchPlayerQuery) Modify(modifiers ...func(s *sql.Selector)) *MatchPlayerSelect {
_q.modifiers = append(_q.modifiers, modifiers...)
return _q.Select()
}
// MatchPlayerGroupBy is the group-by builder for MatchPlayer entities.
@@ -913,41 +915,41 @@ type MatchPlayerGroupBy struct {
}
// Aggregate adds the given aggregation functions to the group-by query.
func (mpgb *MatchPlayerGroupBy) Aggregate(fns ...AggregateFunc) *MatchPlayerGroupBy {
mpgb.fns = append(mpgb.fns, fns...)
return mpgb
func (_g *MatchPlayerGroupBy) Aggregate(fns ...AggregateFunc) *MatchPlayerGroupBy {
_g.fns = append(_g.fns, fns...)
return _g
}
// Scan applies the selector query and scans the result into the given value.
func (mpgb *MatchPlayerGroupBy) Scan(ctx context.Context, v any) error {
ctx = setContextOp(ctx, mpgb.build.ctx, "GroupBy")
if err := mpgb.build.prepareQuery(ctx); err != nil {
func (_g *MatchPlayerGroupBy) Scan(ctx context.Context, v any) error {
ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
if err := _g.build.prepareQuery(ctx); err != nil {
return err
}
return scanWithInterceptors[*MatchPlayerQuery, *MatchPlayerGroupBy](ctx, mpgb.build, mpgb, mpgb.build.inters, v)
return scanWithInterceptors[*MatchPlayerQuery, *MatchPlayerGroupBy](ctx, _g.build, _g, _g.build.inters, v)
}
func (mpgb *MatchPlayerGroupBy) sqlScan(ctx context.Context, root *MatchPlayerQuery, v any) error {
func (_g *MatchPlayerGroupBy) sqlScan(ctx context.Context, root *MatchPlayerQuery, v any) error {
selector := root.sqlQuery(ctx).Select()
aggregation := make([]string, 0, len(mpgb.fns))
for _, fn := range mpgb.fns {
aggregation := make([]string, 0, len(_g.fns))
for _, fn := range _g.fns {
aggregation = append(aggregation, fn(selector))
}
if len(selector.SelectedColumns()) == 0 {
columns := make([]string, 0, len(*mpgb.flds)+len(mpgb.fns))
for _, f := range *mpgb.flds {
columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
for _, f := range *_g.flds {
columns = append(columns, selector.C(f))
}
columns = append(columns, aggregation...)
selector.Select(columns...)
}
selector.GroupBy(selector.Columns(*mpgb.flds...)...)
selector.GroupBy(selector.Columns(*_g.flds...)...)
if err := selector.Err(); err != nil {
return err
}
rows := &sql.Rows{}
query, args := selector.Query()
if err := mpgb.build.driver.Query(ctx, query, args, rows); err != nil {
if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
return err
}
defer rows.Close()
@@ -961,27 +963,27 @@ type MatchPlayerSelect struct {
}
// Aggregate adds the given aggregation functions to the selector query.
func (mps *MatchPlayerSelect) Aggregate(fns ...AggregateFunc) *MatchPlayerSelect {
mps.fns = append(mps.fns, fns...)
return mps
func (_s *MatchPlayerSelect) Aggregate(fns ...AggregateFunc) *MatchPlayerSelect {
_s.fns = append(_s.fns, fns...)
return _s
}
// Scan applies the selector query and scans the result into the given value.
func (mps *MatchPlayerSelect) Scan(ctx context.Context, v any) error {
ctx = setContextOp(ctx, mps.ctx, "Select")
if err := mps.prepareQuery(ctx); err != nil {
func (_s *MatchPlayerSelect) Scan(ctx context.Context, v any) error {
ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
if err := _s.prepareQuery(ctx); err != nil {
return err
}
return scanWithInterceptors[*MatchPlayerQuery, *MatchPlayerSelect](ctx, mps.MatchPlayerQuery, mps, mps.inters, v)
return scanWithInterceptors[*MatchPlayerQuery, *MatchPlayerSelect](ctx, _s.MatchPlayerQuery, _s, _s.inters, v)
}
func (mps *MatchPlayerSelect) sqlScan(ctx context.Context, root *MatchPlayerQuery, v any) error {
func (_s *MatchPlayerSelect) sqlScan(ctx context.Context, root *MatchPlayerQuery, v any) error {
selector := root.sqlQuery(ctx)
aggregation := make([]string, 0, len(mps.fns))
for _, fn := range mps.fns {
aggregation := make([]string, 0, len(_s.fns))
for _, fn := range _s.fns {
aggregation = append(aggregation, fn(selector))
}
switch n := len(*mps.selector.flds); {
switch n := len(*_s.selector.flds); {
case n == 0 && len(aggregation) > 0:
selector.Select(aggregation...)
case n != 0 && len(aggregation) > 0:
@@ -989,7 +991,7 @@ func (mps *MatchPlayerSelect) sqlScan(ctx context.Context, root *MatchPlayerQuer
}
rows := &sql.Rows{}
query, args := selector.Query()
if err := mps.driver.Query(ctx, query, args, rows); err != nil {
if err := _s.driver.Query(ctx, query, args, rows); err != nil {
return err
}
defer rows.Close()
@@ -997,7 +999,7 @@ func (mps *MatchPlayerSelect) sqlScan(ctx context.Context, root *MatchPlayerQuer
}
// Modify adds a query modifier for attaching custom logic to queries.
func (mps *MatchPlayerSelect) Modify(modifiers ...func(s *sql.Selector)) *MatchPlayerSelect {
mps.modifiers = append(mps.modifiers, modifiers...)
return mps
func (_s *MatchPlayerSelect) Modify(modifiers ...func(s *sql.Selector)) *MatchPlayerSelect {
_s.modifiers = append(_s.modifiers, modifiers...)
return _s
}