query.tmpl

{{/*
Copyright 2019-present Facebook Inc. All rights reserved.
This source code is licensed under the Apache 2.0 license found
in the LICENSE file in the root directory of this source tree.
*/}}

{{/* gotype: entgo.io/ent/entc/gen.typeScope */}}

{{/* Additional fields for the builder. */}}
{{ define "dialect/sql/query/fields" }}
	{{- with $.UnexportedForeignKeys }}
		withFKs bool
	{{- end }}
	{{- with $tmpls := matchTemplate "dialect/sql/query/fields/additional/*" }}
		{{- range $tmpl := $tmpls }}
			{{- xtemplate $tmpl $ }}
		{{- end }}
	{{- end }}
{{- end }}

{{ define "dialect/sql/query" }}
{{ $pkg := $.Scope.Package }}
{{ $builder := pascal $.Scope.Builder }}
{{ $receiver := receiver $builder }}

func ({{ $receiver }} *{{ $builder }}) sqlAll(ctx context.Context, hooks ...queryHook) ([]*{{ $.Name }}, error) {
	var (
		nodes = []*{{ $.Name }}{}
		{{- with $.UnexportedForeignKeys }}
			withFKs = {{ $receiver }}.withFKs
		{{- end }}
		_spec = {{ $receiver }}.querySpec()
		{{- with $.Edges }}
			loadedTypes = [{{ len . }}]bool{
				{{- range $e := . }}
					{{ $receiver }}.{{ $e.EagerLoadField }} != nil,
				{{- end }}
			}
		{{- end }}
	)
	{{- with $.UnexportedForeignKeys }}
			{{- with $.FKEdges }}
				if {{ range $i, $e := . }}{{ if gt $i 0 }} || {{ end }}{{ $receiver }}.{{ $e.EagerLoadField }} != nil{{ end }} {
					withFKs = true
				}
			{{- end }}
			if withFKs {
				_spec.Node.Columns = append(_spec.Node.Columns, {{ $.Package }}.ForeignKeys...)
			}
	{{- end }}
	_spec.ScanValues = func(columns []string) ([]interface{}, error) {
		return (*{{ $.Name }}).scanValues(nil, columns)
	}
	_spec.Assign = func(columns []string, values []interface{}) error {
		node := &{{ $.Name }}{config: {{ $receiver }}.config}
		nodes = append(nodes, node)
		{{- with $.Edges }}
			node.Edges.loadedTypes = loadedTypes
		{{- end }}
		return node.assignValues(columns, values)
	}
	{{- /* Allow mutating the sqlgraph.QuerySpec by ent extensions or user templates.*/}}
	{{- with $tmpls := matchTemplate "dialect/sql/query/spec/*" }}
		{{- range $tmpl := $tmpls }}
			{{- xtemplate $tmpl $ }}
		{{- end }}
	{{- end }}
	for i := range hooks {
		hooks[i](ctx, _spec)
	}
	if err := sqlgraph.QueryNodes(ctx, {{ $receiver }}.driver, _spec); err != nil {
		return nil, err
	}
	if len(nodes) == 0 {
		return nodes, nil
	}
	{{- range $e := $.Edges }}
		{{- with extend $ "Rec" $receiver "Edge" $e }}
			{{ template "dialect/sql/query/eagerloading" . }}
		{{- end }}
	{{- end }}
	{{- /* Allow extensions to inject code using templates to process nodes before they are returned. */}}
	{{- with $tmpls := matchTemplate "dialect/sql/query/all/nodes/*" }}
		{{- range $tmpl := $tmpls }}
			{{- xtemplate $tmpl $ }}
		{{- end }}
	{{- end }}
	return nodes, nil
}

func ({{ $receiver }} *{{ $builder }}) sqlCount(ctx context.Context) (int, error) {
	_spec := {{ $receiver }}.querySpec()
	{{- /* Allow mutating the sqlgraph.QuerySpec by ent extensions or user templates. */}}
	{{- with $tmpls := matchTemplate "dialect/sql/query/spec/*" }}
		{{- range $tmpl := $tmpls }}
			{{- xtemplate $tmpl $ }}
		{{- end }}
	{{- end }}
	_spec.Node.Columns = {{ $receiver }}.fields
	if len({{ $receiver }}.fields) > 0 {
		{{- /* In case of field selection, configure query to unique only if was explicitly set to true. */}}
		_spec.Unique = {{ $receiver }}.unique != nil && *{{ $receiver }}.unique
	}
	return sqlgraph.CountNodes(ctx, {{ $receiver }}.driver, _spec)
}

func ({{ $receiver }} *{{ $builder }}) sqlExist(ctx context.Context) (bool, error) {
	n, err := {{ $receiver }}.sqlCount(ctx)
	if err != nil {
		return false, fmt.Errorf("{{ $pkg }}: check existence: %w", err)
	}
	return n > 0, nil
}

func ({{ $receiver }} *{{ $builder }}) querySpec() *sqlgraph.QuerySpec {
	_spec := &sqlgraph.QuerySpec{
		Node: &sqlgraph.NodeSpec{
			Table: {{ $.Package }}.Table,
			Columns: {{ $.Package }}.Columns,
			ID: &sqlgraph.FieldSpec{
				Type: field.{{ $.ID.Type.ConstName }},
				Column: {{ $.Package }}.{{ $.ID.Constant }},
			},
		},
		From: {{ $receiver }}.sql,
		Unique: true,
	}
	if unique := {{ $receiver }}.unique; unique != nil {
		_spec.Unique = *unique
	}
	if fields := {{ $receiver }}.fields; len(fields) > 0 {
		_spec.Node.Columns = make([]string, 0, len(fields))
		_spec.Node.Columns = append(_spec.Node.Columns, {{ $.Package }}.{{ $.ID.Constant }})
		for i := range fields {
			if fields[i] != {{ $.Package }}.{{ $.ID.Constant }} {
				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
			}
		}
	}
	if ps := {{ $receiver }}.predicates; len(ps) > 0 {
		_spec.Predicate = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	if limit := {{ $receiver }}.limit; limit != nil {
		_spec.Limit = *limit
	}
	if offset := {{ $receiver }}.offset; offset != nil {
		_spec.Offset = *offset
	}
	if ps := {{ $receiver }}.order; len(ps) > 0 {
		_spec.Order = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	return _spec
}

{{ template "dialect/sql/query/selector" $ }}


{{- /* Allow adding methods to the query-builder by ent extensions or user templates.*/}}
{{- with $tmpls := matchTemplate "dialect/sql/query/additional/*" }}
	{{- range $tmpl := $tmpls }}
		{{- xtemplate $tmpl $ }}
	{{- end }}
{{- end }}

{{ end }}

{{ define "dialect/sql/query/selector" }}
{{ $builder := pascal $.Scope.Builder }}
{{ $receiver := receiver $builder }}

func ({{ $receiver }} *{{ $builder }}) sqlQuery(ctx context.Context) *sql.Selector {
	builder := sql.Dialect({{ $receiver }}.driver.Dialect())
	t1 := builder.Table({{ $.Package }}.Table)
	columns := {{ $receiver }}.fields
	if len(columns) == 0 {
		columns = {{ $.Package }}.Columns
	}
	selector := builder.Select(t1.Columns(columns...)...).From(t1)
	if {{ $receiver }}.sql != nil {
		selector = {{ $receiver }}.sql
		selector.Select(selector.Columns(columns...)...)
	}
	if {{ $receiver }}.unique != nil && *{{ $receiver }}.unique {
		selector.Distinct()
	}
	{{- /* Allow mutating the sql.Selector by ent extensions or user templates.*/}}
	{{- with $tmpls := matchTemplate "dialect/sql/query/selector/*" }}
		{{- range $tmpl := $tmpls }}
			{{- xtemplate $tmpl $ }}
		{{- end }}
	{{- end }}
	for _, p := range {{ $receiver }}.predicates {
		p(selector)
	}
	for _, p := range {{ $receiver }}.order {
		p(selector)
	}
	if offset := {{ $receiver }}.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 := {{ $receiver }}.limit; limit != nil {
		selector.Limit(*limit)
	}
	return selector
}
{{ end }}

{{/* query/path defines the query generation for path of a given edge. */}}
{{ define "dialect/sql/query/path" }}
	{{- $n := $ }} {{/* the node we start the query from. */}}
	{{- $e := $.Scope.Edge }} {{/* the edge we need to genegrate the path to. */}}
	{{- $ident := $.Scope.Ident -}}
	{{- $receiver := $.Scope.Receiver }}
	selector := {{ $receiver }}.sqlQuery(ctx)
	if err := selector.Err(); err != nil {
		return nil, err
	}
	step := sqlgraph.NewStep(
		sqlgraph.From({{ $n.Package }}.Table, {{ $n.Package }}.{{ $n.ID.Constant }}, selector),
		sqlgraph.To({{ $e.Type.Package }}.Table, {{ $e.Type.Package }}.{{ $e.Type.ID.Constant }}),
		sqlgraph.Edge(sqlgraph.{{ $e.Rel.Type }}, {{ $e.IsInverse }}, {{ $n.Package }}.{{ $e.TableConstant }},
			{{- if $e.M2M -}}
				{{ $n.Package }}.{{ $e.PKConstant }}...
			{{- else -}}
				{{ $n.Package }}.{{ $e.ColumnConstant }}
			{{- end -}}
		),
	)
	{{- /* Allow mutating the sqlgraph.Step by ent extensions or user templates.*/}}
	{{- with $tmpls := matchTemplate "dialect/sql/query/path/*" }}
		{{- range $tmpl := $tmpls }}
			{{- xtemplate $tmpl $ }}
		{{- end }}
	{{- end }}
	{{ $ident }} = sqlgraph.SetNeighbors({{ $receiver }}.driver.Dialect(), step)
{{ end }}

{{/* query/from defines the query generation for an edge query from a given node. */}}
{{ define "dialect/sql/query/from" }}
	{{- $n := $ }} {{/* the node we start the query from. */}}
	{{- $e := $.Scope.Edge }} {{/* the edge we need to genegrate the path to. */}}
	{{- $ident := $.Scope.Ident -}}
	{{- $receiver := $.Scope.Receiver -}}
	id := {{ $receiver }}.ID
	step := sqlgraph.NewStep(
		sqlgraph.From({{ $n.Package }}.Table, {{ $n.Package }}.{{ $n.ID.Constant }}, id),
		sqlgraph.To({{ $e.Type.Package }}.Table, {{ $e.Type.Package }}.{{ $e.Type.ID.Constant }}),
		sqlgraph.Edge(sqlgraph.{{ $e.Rel.Type }}, {{ $e.IsInverse }}, {{ $n.Package }}.{{ $e.TableConstant }},
			{{- if $e.M2M -}}
				{{ $n.Package }}.{{ $e.PKConstant }}...
			{{- else -}}
				{{ $n.Package }}.{{ $e.ColumnConstant }}
			{{- end -}}
		),
	)
	{{- /* Allow mutating the sqlgraph.Step by ent extensions or user templates.*/}}
	{{- with $tmpls := matchTemplate "dialect/sql/query/from/*" }}
		{{- range $tmpl := $tmpls }}
			{{- xtemplate $tmpl $ }}
		{{- end }}
	{{- end }}
	{{ $ident }} = sqlgraph.Neighbors({{ $receiver }}.driver.Dialect(), step)
{{ end }}

{{ define "dialect/sql/query/eagerloading" }}
	{{- $e := $.Scope.Edge }}
	{{- $receiver := $.Scope.Rec }}
	if query := {{ $receiver }}.{{ $e.EagerLoadField }}; query != nil {
		{{- if $e.M2M }}
			edgeids := make([]driver.Value, len(nodes))
			byid := make(map[{{ $.ID.Type }}]*{{ $.Name }})
			nids := make(map[{{ $e.Type.ID.Type }}]map[*{{ $.Name }}]struct{})
			for i, node := range nodes {
				edgeids[i] = node.ID
				byid[node.ID] = node
				node.Edges.{{ $e.StructField }} = []*{{ $e.Type.Name }}{}
			}
			query.Where(func(s *sql.Selector) {
				joinT := sql.Table({{ $.Package }}.{{ $e.TableConstant }})
				{{- $edgeid := print $e.Type.Package "." $e.Type.ID.Constant }}
				{{- $fk1idx := 1 }}{{- $fk2idx := 0 }}{{ if $e.IsInverse }}{{ $fk1idx = 0 }}{{ $fk2idx = 1 }}{{ end }}
				s.Join(joinT).On(s.C({{ $edgeid }}), joinT.C({{ $.Package }}.{{ $e.PKConstant }}[{{ $fk1idx }}]))
				s.Where(sql.InValues(joinT.C({{ $.Package }}.{{ $e.PKConstant }}[{{ $fk2idx }}]), edgeids...))
				columns := s.SelectedColumns()
				s.Select(joinT.C({{ $.Package }}.{{ $e.PKConstant }}[{{ $fk2idx }}]))
				s.AppendSelect(columns...)
				s.SetDistinct(false)
			})
			neighbors, err := query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
				assign := spec.Assign
				values := spec.ScanValues
				{{- $out := "sql.NullInt64" }}{{ if $.ID.UserDefined }}{{ $out = $.ID.ScanType }}{{ end }}
				{{- $in := "sql.NullInt64" }}{{ if $e.Type.ID.UserDefined }}{{ $in = $e.Type.ID.ScanType }}{{ end }}
				spec.ScanValues = func(columns []string) ([]interface{}, error) {
					values, err := values(columns[1:])
					if err != nil {
						return nil, err
					}
					return append([]interface{}{new({{ $out }})}, values...), nil
				}
				spec.Assign = func(columns []string, values []interface{}) error {
					outValue := {{ with extend $ "Arg" "values[0]" "Field" $.ID "ScanType" $out }}{{ template "dialect/sql/query/eagerloading/m2massign" . }}{{ end }}
					inValue := {{ with extend $ "Arg" "values[1]" "Field" $e.Type.ID "ScanType" $in }}{{ template "dialect/sql/query/eagerloading/m2massign" . }}{{ end }}
					if nids[inValue] == nil {
						nids[inValue] = map[*{{ $.Name }}]struct{}{byid[outValue]: struct{}{}}
						return assign(columns[1:], values[1:])
					}
					nids[inValue][byid[outValue]] = struct{}{}
					return nil
				}
			})
			if err != nil {
				return nil, err
			}
			for _, n := range neighbors {
				nodes, ok := nids[n.ID]
				if !ok {
					return nil, fmt.Errorf(`unexpected "{{ $e.Name }}" node returned %v`, n.ID)
				}
				for kn := range nodes {
					kn.Edges.{{ $e.StructField }} = append(kn.Edges.{{ $e.StructField }}, n)
				}
			}
		{{- else if $e.OwnFK }}
			ids := make([]{{ $e.Type.ID.Type }}, 0, len(nodes))
			nodeids := make(map[{{ $e.Type.ID.Type }}][]*{{ $.Name }})
			for i := range nodes {
				{{- $fk := $e.ForeignKey }}
				{{- if $fk.Field.Nillable }}
					if nodes[i].{{ $fk.StructField }} == nil {
						continue
					}
				{{- end }}
				fk := {{ if $fk.Field.Nillable }}*{{ end }}nodes[i].{{ $fk.StructField }}
				if _, ok := nodeids[fk]; !ok {
					ids = append(ids, fk)
				}
				nodeids[fk] = append(nodeids[fk], nodes[i])
			}
			query.Where({{ $e.Type.Package }}.IDIn(ids...))
			neighbors, err := query.All(ctx)
			if err != nil {
				return nil, err
			}
			for _, n := range neighbors {
				nodes, ok := nodeids[n.ID]
				if !ok {
					return nil, fmt.Errorf(`unexpected foreign-key "{{ $fk.Field.Name }}" returned %v`, n.ID)
				}
				for i := range nodes {
					nodes[i].Edges.{{ $e.StructField }} = n
				}
			}
		{{- else }}
			fks := make([]driver.Value, 0, len(nodes))
			nodeids := make(map[{{ $.ID.Type }}]*{{ $.Name }})
			for i := range nodes {
				fks = append(fks, nodes[i].ID)
				nodeids[nodes[i].ID] = nodes[i]
				{{- if $e.O2M }}
					nodes[i].Edges.{{ $e.StructField }} = []*{{ $e.Type.Name }}{}
				{{- end }}
			}
			{{- with $e.Type.UnexportedForeignKeys }}
				query.withFKs = true
			{{- end }}
			query.Where(predicate.{{ $e.Type.Name }}(func(s *sql.Selector) {
				s.Where(sql.InValues({{ $.Package }}.{{ $e.ColumnConstant }}, fks...))
			}))
			neighbors, err := query.All(ctx)
			if err != nil {
				return nil, err
			}
			for _, n := range neighbors {
				{{- $fk := $e.ForeignKey }}
				fk := n.{{ $fk.StructField }}
				{{- if $fk.Field.Nillable }}
					if fk == nil {
						return nil, fmt.Errorf(`foreign-key "{{ $fk.Field.Name }}" is nil for node %v`, n.ID)
					}
				{{- end }}
				node, ok := nodeids[{{ if $fk.Field.Nillable }}*{{ end }}fk]
				if !ok {
					return nil, fmt.Errorf(`unexpected foreign-key "{{ $fk.Field.Name }}" returned %v for node %v`, {{ if $fk.Field.Nillable }}*{{ end }}fk, n.ID)
				}
				node.Edges.{{ $e.StructField }} = {{ if $e.Unique }}n{{ else }}append(node.Edges.{{ $e.StructField }}, n){{ end }}
			}
		{{- end }}
	}
{{ end }}

{{ define "dialect/sql/query/eagerloading/m2massign" }}
	{{- $arg := $.Scope.Arg }}
	{{- $field := $.Scope.Field }}
	{{- $scantype := $.Scope.ScanType }}
	{{- if hasPrefix $scantype "sql" -}}
		{{ printf "%s.(*%s)" $arg $scantype | $field.ScanTypeField -}}
	{{- else -}}
		{{ if not $field.Nillable }}*{{ end }}{{ printf "%s.(*%s)" $arg $scantype }}
	{{- end }}
{{- end }}

{{ define "dialect/sql/query/preparecheck" }}
	{{- $pkg := $.Scope.Package }}
	{{- $receiver := $.Scope.Receiver }}
	for _, f := range {{ $receiver }}.fields {
		if !{{ $.Package }}.ValidColumn(f) {
			return &ValidationError{Name: f, err: fmt.Errorf("{{ $pkg }}: invalid field %q for query", f)}
		}
	}
{{- end }}