db optimize

ent/series_query.go

@@ -4,8 +4,10 @@ package ent
 
 import (
 	"context"
+	"database/sql/driver"
 	"fmt"
 	"math"
+	"polaris/ent/episode"
 	"polaris/ent/predicate"
 	"polaris/ent/series"
 
@@ -17,10 +19,11 @@ import (
 // SeriesQuery is the builder for querying Series entities.
 type SeriesQuery struct {
 	config
-	ctx        *QueryContext
-	order      []series.OrderOption
-	inters     []Interceptor
-	predicates []predicate.Series
+	ctx          *QueryContext
+	order        []series.OrderOption
+	inters       []Interceptor
+	predicates   []predicate.Series
+	withEpisodes *EpisodeQuery
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -57,6 +60,28 @@ func (sq *SeriesQuery) Order(o ...series.OrderOption) *SeriesQuery {
 	return sq
 }
 
+// QueryEpisodes chains the current query on the "episodes" edge.
+func (sq *SeriesQuery) QueryEpisodes() *EpisodeQuery {
+	query := (&EpisodeClient{config: sq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := sq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := sq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(series.Table, series.FieldID, selector),
+			sqlgraph.To(episode.Table, episode.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, series.EpisodesTable, series.EpisodesColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(sq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
 // First returns the first Series entity from the query.
 // Returns a *NotFoundError when no Series was found.
 func (sq *SeriesQuery) First(ctx context.Context) (*Series, error) {
@@ -244,17 +269,29 @@ func (sq *SeriesQuery) Clone() *SeriesQuery {
 		return nil
 	}
 	return &SeriesQuery{
-		config:     sq.config,
-		ctx:        sq.ctx.Clone(),
-		order:      append([]series.OrderOption{}, sq.order...),
-		inters:     append([]Interceptor{}, sq.inters...),
-		predicates: append([]predicate.Series{}, sq.predicates...),
+		config:       sq.config,
+		ctx:          sq.ctx.Clone(),
+		order:        append([]series.OrderOption{}, sq.order...),
+		inters:       append([]Interceptor{}, sq.inters...),
+		predicates:   append([]predicate.Series{}, sq.predicates...),
+		withEpisodes: sq.withEpisodes.Clone(),
 		// clone intermediate query.
 		sql:  sq.sql.Clone(),
 		path: sq.path,
 	}
 }
 
+// WithEpisodes tells the query-builder to eager-load the nodes that are connected to
+// the "episodes" edge. The optional arguments are used to configure the query builder of the edge.
+func (sq *SeriesQuery) WithEpisodes(opts ...func(*EpisodeQuery)) *SeriesQuery {
+	query := (&EpisodeClient{config: sq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	sq.withEpisodes = query
+	return sq
+}
+
 // GroupBy is used to group vertices by one or more fields/columns.
 // It is often used with aggregate functions, like: count, max, mean, min, sum.
 //
@@ -331,8 +368,11 @@ func (sq *SeriesQuery) prepareQuery(ctx context.Context) error {
 
 func (sq *SeriesQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Series, error) {
 	var (
-		nodes = []*Series{}
-		_spec = sq.querySpec()
+		nodes       = []*Series{}
+		_spec       = sq.querySpec()
+		loadedTypes = [1]bool{
+			sq.withEpisodes != nil,
+		}
 	)
 	_spec.ScanValues = func(columns []string) ([]any, error) {
 		return (*Series).scanValues(nil, columns)
@@ -340,6 +380,7 @@ func (sq *SeriesQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Serie
 	_spec.Assign = func(columns []string, values []any) error {
 		node := &Series{config: sq.config}
 		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
 	for i := range hooks {
@@ -351,9 +392,48 @@ func (sq *SeriesQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Serie
 	if len(nodes) == 0 {
 		return nodes, nil
 	}
+	if query := sq.withEpisodes; query != nil {
+		if err := sq.loadEpisodes(ctx, query, nodes,
+			func(n *Series) { n.Edges.Episodes = []*Episode{} },
+			func(n *Series, e *Episode) { n.Edges.Episodes = append(n.Edges.Episodes, e) }); err != nil {
+			return nil, err
+		}
+	}
 	return nodes, nil
 }
 
+func (sq *SeriesQuery) loadEpisodes(ctx context.Context, query *EpisodeQuery, nodes []*Series, init func(*Series), assign func(*Series, *Episode)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[int]*Series)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	query.withFKs = true
+	query.Where(predicate.Episode(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(series.EpisodesColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.series_episodes
+		if fk == nil {
+			return fmt.Errorf(`foreign-key "series_episodes" is nil for node %v`, n.ID)
+		}
+		node, ok := nodeids[*fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "series_episodes" returned %v for node %v`, *fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
+
 func (sq *SeriesQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := sq.querySpec()
 	_spec.Node.Columns = sq.ctx.Fields