From aab71ca05a75ead3def23d4befd6f597b08fb15f Mon Sep 17 00:00:00 2001 From: Ariel Mashraki Date: Thu, 17 Mar 2022 23:46:16 +0200 Subject: [PATCH] entc/gen: move selectbuilder scan functions to shared struct --- entc/gen/template/base.tmpl | 66 ++++++ entc/gen/template/builder/query.tmpl | 64 +----- .../cascadelete/ent/comment_query.go | 201 +---------------- entc/integration/cascadelete/ent/ent.go | 203 ++++++++++++++++++ .../integration/cascadelete/ent/post_query.go | 201 +---------------- .../integration/cascadelete/ent/user_query.go | 201 +---------------- entc/integration/config/ent/ent.go | 203 ++++++++++++++++++ entc/integration/config/ent/user_query.go | 201 +---------------- .../integration/customid/ent/account_query.go | 201 +---------------- entc/integration/customid/ent/blob_query.go | 201 +---------------- entc/integration/customid/ent/car_query.go | 201 +---------------- entc/integration/customid/ent/device_query.go | 201 +---------------- entc/integration/customid/ent/doc_query.go | 201 +---------------- entc/integration/customid/ent/ent.go | 203 ++++++++++++++++++ entc/integration/customid/ent/group_query.go | 201 +---------------- .../integration/customid/ent/mixinid_query.go | 201 +---------------- entc/integration/customid/ent/note_query.go | 201 +---------------- entc/integration/customid/ent/other_query.go | 201 +---------------- entc/integration/customid/ent/pet_query.go | 201 +---------------- .../integration/customid/ent/session_query.go | 201 +---------------- entc/integration/customid/ent/token_query.go | 201 +---------------- entc/integration/customid/ent/user_query.go | 201 +---------------- entc/integration/edgefield/ent/car_query.go | 201 +---------------- entc/integration/edgefield/ent/card_query.go | 201 +---------------- entc/integration/edgefield/ent/ent.go | 203 ++++++++++++++++++ entc/integration/edgefield/ent/info_query.go | 201 +---------------- .../edgefield/ent/metadata_query.go | 201 +---------------- entc/integration/edgefield/ent/node_query.go | 201 +---------------- entc/integration/edgefield/ent/pet_query.go | 201 +---------------- entc/integration/edgefield/ent/post_query.go | 201 +---------------- .../integration/edgefield/ent/rental_query.go | 201 +---------------- entc/integration/edgefield/ent/user_query.go | 201 +---------------- entc/integration/ent/card_query.go | 201 +---------------- entc/integration/ent/comment_query.go | 201 +---------------- entc/integration/ent/ent.go | 203 ++++++++++++++++++ entc/integration/ent/fieldtype_query.go | 201 +---------------- entc/integration/ent/file_query.go | 201 +---------------- entc/integration/ent/filetype_query.go | 201 +---------------- entc/integration/ent/goods_query.go | 201 +---------------- entc/integration/ent/group_query.go | 201 +---------------- entc/integration/ent/groupinfo_query.go | 201 +---------------- entc/integration/ent/item_query.go | 201 +---------------- entc/integration/ent/node_query.go | 201 +---------------- entc/integration/ent/pet_query.go | 201 +---------------- entc/integration/ent/spec_query.go | 201 +---------------- entc/integration/ent/task_query.go | 201 +---------------- entc/integration/ent/user_query.go | 201 +---------------- entc/integration/gremlin/ent/card_query.go | 201 +---------------- entc/integration/gremlin/ent/comment_query.go | 201 +---------------- entc/integration/gremlin/ent/ent.go | 203 ++++++++++++++++++ .../gremlin/ent/fieldtype_query.go | 201 +---------------- entc/integration/gremlin/ent/file_query.go | 201 +---------------- .../integration/gremlin/ent/filetype_query.go | 201 +---------------- entc/integration/gremlin/ent/goods_query.go | 201 +---------------- entc/integration/gremlin/ent/group_query.go | 201 +---------------- .../gremlin/ent/groupinfo_query.go | 201 +---------------- entc/integration/gremlin/ent/item_query.go | 201 +---------------- entc/integration/gremlin/ent/node_query.go | 201 +---------------- entc/integration/gremlin/ent/pet_query.go | 201 +---------------- entc/integration/gremlin/ent/spec_query.go | 201 +---------------- entc/integration/gremlin/ent/task_query.go | 201 +---------------- entc/integration/gremlin/ent/user_query.go | 201 +---------------- entc/integration/hooks/ent/card_query.go | 201 +---------------- entc/integration/hooks/ent/ent.go | 203 ++++++++++++++++++ entc/integration/hooks/ent/user_query.go | 201 +---------------- entc/integration/idtype/ent/ent.go | 203 ++++++++++++++++++ entc/integration/idtype/ent/user_query.go | 201 +---------------- entc/integration/json/ent/ent.go | 203 ++++++++++++++++++ entc/integration/json/ent/user_query.go | 201 +---------------- entc/integration/migrate/entv1/car_query.go | 201 +---------------- .../migrate/entv1/conversion_query.go | 201 +---------------- .../migrate/entv1/customtype_query.go | 201 +---------------- entc/integration/migrate/entv1/ent.go | 203 ++++++++++++++++++ entc/integration/migrate/entv1/user_query.go | 201 +---------------- entc/integration/migrate/entv2/car_query.go | 201 +---------------- .../migrate/entv2/conversion_query.go | 201 +---------------- .../migrate/entv2/customtype_query.go | 201 +---------------- entc/integration/migrate/entv2/ent.go | 203 ++++++++++++++++++ entc/integration/migrate/entv2/group_query.go | 201 +---------------- entc/integration/migrate/entv2/media_query.go | 201 +---------------- entc/integration/migrate/entv2/pet_query.go | 201 +---------------- entc/integration/migrate/entv2/user_query.go | 201 +---------------- .../migrate/versioned/car_query.go | 201 +---------------- entc/integration/migrate/versioned/ent.go | 203 ++++++++++++++++++ .../migrate/versioned/user_query.go | 201 +---------------- entc/integration/multischema/ent/ent.go | 203 ++++++++++++++++++ .../multischema/ent/group_query.go | 201 +---------------- entc/integration/multischema/ent/pet_query.go | 201 +---------------- .../integration/multischema/ent/user_query.go | 201 +---------------- entc/integration/privacy/ent/ent.go | 203 ++++++++++++++++++ entc/integration/privacy/ent/task_query.go | 201 +---------------- entc/integration/privacy/ent/team_query.go | 201 +---------------- entc/integration/privacy/ent/user_query.go | 201 +---------------- entc/integration/template/ent/ent.go | 203 ++++++++++++++++++ entc/integration/template/ent/group_query.go | 201 +---------------- entc/integration/template/ent/pet_query.go | 201 +---------------- entc/integration/template/ent/user_query.go | 201 +---------------- examples/edgeindex/ent/city_query.go | 201 +---------------- examples/edgeindex/ent/ent.go | 203 ++++++++++++++++++ examples/edgeindex/ent/street_query.go | 201 +---------------- examples/entcpkg/ent/ent.go | 203 ++++++++++++++++++ examples/entcpkg/ent/user_query.go | 201 +---------------- examples/fs/ent/ent.go | 203 ++++++++++++++++++ examples/fs/ent/file_query.go | 201 +---------------- examples/m2m2types/ent/ent.go | 203 ++++++++++++++++++ examples/m2m2types/ent/group_query.go | 201 +---------------- examples/m2m2types/ent/user_query.go | 201 +---------------- examples/m2mbidi/ent/ent.go | 203 ++++++++++++++++++ examples/m2mbidi/ent/user_query.go | 201 +---------------- examples/m2mrecur/ent/ent.go | 203 ++++++++++++++++++ examples/m2mrecur/ent/user_query.go | 201 +---------------- examples/o2m2types/ent/ent.go | 203 ++++++++++++++++++ examples/o2m2types/ent/pet_query.go | 201 +---------------- examples/o2m2types/ent/user_query.go | 201 +---------------- examples/o2mrecur/ent/ent.go | 203 ++++++++++++++++++ examples/o2mrecur/ent/node_query.go | 201 +---------------- examples/o2o2types/ent/card_query.go | 201 +---------------- examples/o2o2types/ent/ent.go | 203 ++++++++++++++++++ examples/o2o2types/ent/user_query.go | 201 +---------------- examples/o2obidi/ent/ent.go | 203 ++++++++++++++++++ examples/o2obidi/ent/user_query.go | 201 +---------------- examples/o2orecur/ent/ent.go | 203 ++++++++++++++++++ examples/o2orecur/ent/node_query.go | 201 +---------------- examples/privacyadmin/ent/ent.go | 203 ++++++++++++++++++ examples/privacyadmin/ent/user_query.go | 201 +---------------- examples/privacytenant/ent/ent.go | 203 ++++++++++++++++++ examples/privacytenant/ent/group_query.go | 201 +---------------- examples/privacytenant/ent/tenant_query.go | 201 +---------------- examples/privacytenant/ent/user_query.go | 201 +---------------- examples/start/ent/car_query.go | 201 +---------------- examples/start/ent/ent.go | 203 ++++++++++++++++++ examples/start/ent/group_query.go | 201 +---------------- examples/start/ent/user_query.go | 201 +---------------- examples/traversal/ent/ent.go | 203 ++++++++++++++++++ examples/traversal/ent/group_query.go | 201 +---------------- examples/traversal/ent/pet_query.go | 201 +---------------- examples/traversal/ent/user_query.go | 201 +---------------- examples/version/ent/ent.go | 203 ++++++++++++++++++ examples/version/ent/user_query.go | 201 +---------------- 139 files changed, 6894 insertions(+), 20835 deletions(-) diff --git a/entc/gen/template/base.tmpl b/entc/gen/template/base.tmpl index 4d76c12571..c4459d8e63 100644 --- a/entc/gen/template/base.tmpl +++ b/entc/gen/template/base.tmpl @@ -190,6 +190,72 @@ func IsConstraintError(err error) bool { return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func (context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +{{ range $t := primitives }} + {{ $plural := pascal $t | plural }} + // {{ $plural }} returns list of {{ plural $t }} from a selector. It is only allowed when selecting one field. + func (s *selector) {{ $plural }}(ctx context.Context) ([]{{ $t }}, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("{{ $pkg }}: %sSelect.{{ $plural }} is not achievable when selecting more than 1 field", s.typ) + } + var v []{{ $t }} + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil + } + + // {{ $plural }}X is like {{ $plural }}, but panics if an error occurs. + func (s *selector) {{ $plural }}X(ctx context.Context) []{{ $t }} { + v, err := s.{{ $plural }}(ctx) + if err != nil { + panic(err) + } + return v + } + + {{ $singular := pascal $t -}} + // {{ $singular }} returns a single {{ $t }} from a selector. It is only allowed when selecting one field. + func (s *selector) {{ $singular }}(ctx context.Context) (_ {{ $t }}, err error) { + var v []{{ $t }} + if v, err = s.{{ $plural }}(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("{{ $pkg }}: %sSelect.{{ $plural }} returned %d results when one was expected", s.typ, len(v)) + } + return + } + + // {{ $singular }}X is like {{ $singular }}, but panics if an error occurs. + func (s *selector) {{ $singular }}X(ctx context.Context) {{ $t }} { + v, err := s.{{ $singular }}(ctx) + if err != nil { + panic(err) + } + return v + } +{{ end }} + {{/* expand error types and global helpers. */}} {{ $tmpl = printf "dialect/%s/errors" $.Storage }} {{ if hasTemplate $tmpl }} diff --git a/entc/gen/template/builder/query.tmpl b/entc/gen/template/builder/query.tmpl index af29229490..bb5443b1a4 100644 --- a/entc/gen/template/builder/query.tmpl +++ b/entc/gen/template/builder/query.tmpl @@ -355,7 +355,10 @@ func ({{ $receiver }} *{{ $builder }}) GroupBy(field string, fields ...string) * {{- end }} func ({{ $receiver }} *{{ $builder }}) Select(fields ...string) *{{ $selectBuilder }} { {{ $receiver }}.fields = append({{ $receiver }}.fields, fields...) - return &{{ $selectBuilder }}{ {{ $builder }}: {{ $receiver }} } + sel := &{{ $selectBuilder }}{ {{ $builder }}: {{ $receiver }} } + sel.typ, sel.label = "{{ pascal $.Name }}", {{ $.Package }}.Label + sel.flds, sel.scan = &{{ $receiver }}.fields, sel.Scan + return sel } func ({{ $receiver }} *{{ $builder }}) prepareQuery(ctx context.Context) error { @@ -500,6 +503,7 @@ func ({{ $groupReceiver }} *{{ $groupBuilder }}) ScanX(ctx context.Context, v in // {{ $selectBuilder }} is the builder for selecting fields of {{ pascal $.Name }} entities. type {{ $selectBuilder }} struct { *{{ $builder }} + selector // intermediate query (i.e. traversal path). {{ $.Storage }} {{ $.Storage.Builder }} } @@ -514,64 +518,6 @@ func ({{ $selectReceiver }} *{{ $selectBuilder }}) Scan(ctx context.Context, v i return {{ $selectReceiver }}.{{ $.Storage }}Scan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func ({{ $selectReceiver }} *{{ $selectBuilder }}) ScanX(ctx context.Context, v interface{}) { - if err := {{ $selectReceiver }}.Scan(ctx, v); err != nil { - panic(err) - } -} - -{{ range $t := primitives }} - {{ $plural := pascal $t | plural }} - // {{ $plural }} returns list of {{ plural $t }} from a selector. It is only allowed when selecting one field. - func ({{ $selectReceiver }} *{{ $selectBuilder }}) {{ $plural }}(ctx context.Context) ([]{{ $t }}, error) { - if len({{ $selectReceiver }}.fields) > 1 { - return nil, errors.New("{{ $pkg }}: {{ $selectBuilder }}.{{ $plural }} is not achievable when selecting more than 1 field") - } - var v []{{ $t }} - if err := {{ $selectReceiver }}.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil - } - - // {{ $plural }}X is like {{ $plural }}, but panics if an error occurs. - func ({{ $selectReceiver }} *{{ $selectBuilder }}) {{ $plural }}X(ctx context.Context) []{{ $t }} { - v, err := {{ $selectReceiver }}.{{ $plural }}(ctx) - if err != nil { - panic(err) - } - return v - } - - {{ $singular := pascal $t -}} - // {{ $singular }} returns a single {{ $t }} from a selector. It is only allowed when selecting one field. - func ({{ $selectReceiver }} *{{ $selectBuilder }}) {{ $singular }}(ctx context.Context) (_ {{ $t }}, err error) { - var v []{{ $t }} - if v, err = {{ $selectReceiver }}.{{ $plural }}(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{ {{ $.Package }}.Label} - default: - err = fmt.Errorf("{{ $pkg }}: {{ $selectBuilder }}.{{ $plural }} returned %d results when one was expected", len(v)) - } - return - } - - // {{ $singular }}X is like {{ $singular }}, but panics if an error occurs. - func ({{ $selectReceiver }} *{{ $selectBuilder }}) {{ $singular }}X(ctx context.Context) {{ $t }} { - v, err := {{ $selectReceiver }}.{{ $singular }}(ctx) - if err != nil { - panic(err) - } - return v - } -{{ end }} - {{ with extend $ "Builder" $selectBuilder }} {{ $tmpl := printf "dialect/%s/select" $.Storage }} {{ xtemplate $tmpl . }} diff --git a/entc/integration/cascadelete/ent/comment_query.go b/entc/integration/cascadelete/ent/comment_query.go index 03079df0cf..109ab10b5e 100644 --- a/entc/integration/cascadelete/ent/comment_query.go +++ b/entc/integration/cascadelete/ent/comment_query.go @@ -331,7 +331,10 @@ func (cq *CommentQuery) GroupBy(field string, fields ...string) *CommentGroupBy // func (cq *CommentQuery) Select(fields ...string) *CommentSelect { cq.fields = append(cq.fields, fields...) - return &CommentSelect{CommentQuery: cq} + sel := &CommentSelect{CommentQuery: cq} + sel.typ, sel.label = "Comment", comment.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CommentQuery) prepareQuery(ctx context.Context) error { @@ -774,6 +777,7 @@ func (cgb *CommentGroupBy) sqlQuery() *sql.Selector { // CommentSelect is the builder for selecting fields of Comment entities. type CommentSelect struct { *CommentQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -787,201 +791,6 @@ func (cs *CommentSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CommentSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CommentSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CommentSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{comment.Label} - default: - err = fmt.Errorf("ent: CommentSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CommentSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CommentSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CommentSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{comment.Label} - default: - err = fmt.Errorf("ent: CommentSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CommentSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CommentSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CommentSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{comment.Label} - default: - err = fmt.Errorf("ent: CommentSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CommentSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CommentSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CommentSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{comment.Label} - default: - err = fmt.Errorf("ent: CommentSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CommentSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CommentSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/entc/integration/cascadelete/ent/ent.go b/entc/integration/cascadelete/ent/ent.go index a7948b85f2..1e42d6fdeb 100644 --- a/entc/integration/cascadelete/ent/ent.go +++ b/entc/integration/cascadelete/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -265,3 +266,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/cascadelete/ent/post_query.go b/entc/integration/cascadelete/ent/post_query.go index 120b01fcf4..ee6a7dc9c9 100644 --- a/entc/integration/cascadelete/ent/post_query.go +++ b/entc/integration/cascadelete/ent/post_query.go @@ -368,7 +368,10 @@ func (pq *PostQuery) GroupBy(field string, fields ...string) *PostGroupBy { // func (pq *PostQuery) Select(fields ...string) *PostSelect { pq.fields = append(pq.fields, fields...) - return &PostSelect{PostQuery: pq} + sel := &PostSelect{PostQuery: pq} + sel.typ, sel.label = "Post", post.Label + sel.flds, sel.scan = &pq.fields, sel.Scan + return sel } func (pq *PostQuery) prepareQuery(ctx context.Context) error { @@ -837,6 +840,7 @@ func (pgb *PostGroupBy) sqlQuery() *sql.Selector { // PostSelect is the builder for selecting fields of Post entities. type PostSelect struct { *PostQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -850,201 +854,6 @@ func (ps *PostSelect) Scan(ctx context.Context, v interface{}) error { return ps.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ps *PostSelect) ScanX(ctx context.Context, v interface{}) { - if err := ps.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Strings(ctx context.Context) ([]string, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PostSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ps *PostSelect) StringsX(ctx context.Context) []string { - v, err := ps.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ps.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{post.Label} - default: - err = fmt.Errorf("ent: PostSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ps *PostSelect) StringX(ctx context.Context) string { - v, err := ps.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Ints(ctx context.Context) ([]int, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PostSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ps *PostSelect) IntsX(ctx context.Context) []int { - v, err := ps.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ps.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{post.Label} - default: - err = fmt.Errorf("ent: PostSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ps *PostSelect) IntX(ctx context.Context) int { - v, err := ps.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PostSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ps *PostSelect) Float64sX(ctx context.Context) []float64 { - v, err := ps.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ps.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{post.Label} - default: - err = fmt.Errorf("ent: PostSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ps *PostSelect) Float64X(ctx context.Context) float64 { - v, err := ps.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PostSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ps *PostSelect) BoolsX(ctx context.Context) []bool { - v, err := ps.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ps.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{post.Label} - default: - err = fmt.Errorf("ent: PostSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ps *PostSelect) BoolX(ctx context.Context) bool { - v, err := ps.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ps *PostSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ps.sql.Query() diff --git a/entc/integration/cascadelete/ent/user_query.go b/entc/integration/cascadelete/ent/user_query.go index ca94983b55..4dac0aeca1 100644 --- a/entc/integration/cascadelete/ent/user_query.go +++ b/entc/integration/cascadelete/ent/user_query.go @@ -332,7 +332,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -774,6 +777,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -787,201 +791,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/entc/integration/config/ent/ent.go b/entc/integration/config/ent/ent.go index 66d42ead88..92581a844a 100644 --- a/entc/integration/config/ent/ent.go +++ b/entc/integration/config/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -261,3 +262,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/config/ent/user_query.go b/entc/integration/config/ent/user_query.go index 7c9890922c..e2a6a07a2e 100644 --- a/entc/integration/config/ent/user_query.go +++ b/entc/integration/config/ent/user_query.go @@ -294,7 +294,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -706,6 +709,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -719,201 +723,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/entc/integration/customid/ent/account_query.go b/entc/integration/customid/ent/account_query.go index d5e1c896a3..59fc43aceb 100644 --- a/entc/integration/customid/ent/account_query.go +++ b/entc/integration/customid/ent/account_query.go @@ -333,7 +333,10 @@ func (aq *AccountQuery) GroupBy(field string, fields ...string) *AccountGroupBy // func (aq *AccountQuery) Select(fields ...string) *AccountSelect { aq.fields = append(aq.fields, fields...) - return &AccountSelect{AccountQuery: aq} + sel := &AccountSelect{AccountQuery: aq} + sel.typ, sel.label = "Account", account.Label + sel.flds, sel.scan = &aq.fields, sel.Scan + return sel } func (aq *AccountQuery) prepareQuery(ctx context.Context) error { @@ -779,6 +782,7 @@ func (agb *AccountGroupBy) sqlQuery() *sql.Selector { // AccountSelect is the builder for selecting fields of Account entities. type AccountSelect struct { *AccountQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -792,201 +796,6 @@ func (as *AccountSelect) Scan(ctx context.Context, v interface{}) error { return as.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (as *AccountSelect) ScanX(ctx context.Context, v interface{}) { - if err := as.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (as *AccountSelect) Strings(ctx context.Context) ([]string, error) { - if len(as.fields) > 1 { - return nil, errors.New("ent: AccountSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := as.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (as *AccountSelect) StringsX(ctx context.Context) []string { - v, err := as.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (as *AccountSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = as.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{account.Label} - default: - err = fmt.Errorf("ent: AccountSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (as *AccountSelect) StringX(ctx context.Context) string { - v, err := as.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (as *AccountSelect) Ints(ctx context.Context) ([]int, error) { - if len(as.fields) > 1 { - return nil, errors.New("ent: AccountSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := as.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (as *AccountSelect) IntsX(ctx context.Context) []int { - v, err := as.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (as *AccountSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = as.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{account.Label} - default: - err = fmt.Errorf("ent: AccountSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (as *AccountSelect) IntX(ctx context.Context) int { - v, err := as.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (as *AccountSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(as.fields) > 1 { - return nil, errors.New("ent: AccountSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := as.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (as *AccountSelect) Float64sX(ctx context.Context) []float64 { - v, err := as.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (as *AccountSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = as.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{account.Label} - default: - err = fmt.Errorf("ent: AccountSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (as *AccountSelect) Float64X(ctx context.Context) float64 { - v, err := as.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (as *AccountSelect) Bools(ctx context.Context) ([]bool, error) { - if len(as.fields) > 1 { - return nil, errors.New("ent: AccountSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := as.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (as *AccountSelect) BoolsX(ctx context.Context) []bool { - v, err := as.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (as *AccountSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = as.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{account.Label} - default: - err = fmt.Errorf("ent: AccountSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (as *AccountSelect) BoolX(ctx context.Context) bool { - v, err := as.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (as *AccountSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := as.sql.Query() diff --git a/entc/integration/customid/ent/blob_query.go b/entc/integration/customid/ent/blob_query.go index a41c029c5f..98ed86a9cb 100644 --- a/entc/integration/customid/ent/blob_query.go +++ b/entc/integration/customid/ent/blob_query.go @@ -368,7 +368,10 @@ func (bq *BlobQuery) GroupBy(field string, fields ...string) *BlobGroupBy { // func (bq *BlobQuery) Select(fields ...string) *BlobSelect { bq.fields = append(bq.fields, fields...) - return &BlobSelect{BlobQuery: bq} + sel := &BlobSelect{BlobQuery: bq} + sel.typ, sel.label = "Blob", blob.Label + sel.flds, sel.scan = &bq.fields, sel.Scan + return sel } func (bq *BlobQuery) prepareQuery(ctx context.Context) error { @@ -887,6 +890,7 @@ func (bgb *BlobGroupBy) sqlQuery() *sql.Selector { // BlobSelect is the builder for selecting fields of Blob entities. type BlobSelect struct { *BlobQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -900,201 +904,6 @@ func (bs *BlobSelect) Scan(ctx context.Context, v interface{}) error { return bs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (bs *BlobSelect) ScanX(ctx context.Context, v interface{}) { - if err := bs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (bs *BlobSelect) Strings(ctx context.Context) ([]string, error) { - if len(bs.fields) > 1 { - return nil, errors.New("ent: BlobSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := bs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (bs *BlobSelect) StringsX(ctx context.Context) []string { - v, err := bs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (bs *BlobSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = bs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{blob.Label} - default: - err = fmt.Errorf("ent: BlobSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (bs *BlobSelect) StringX(ctx context.Context) string { - v, err := bs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (bs *BlobSelect) Ints(ctx context.Context) ([]int, error) { - if len(bs.fields) > 1 { - return nil, errors.New("ent: BlobSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := bs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (bs *BlobSelect) IntsX(ctx context.Context) []int { - v, err := bs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (bs *BlobSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = bs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{blob.Label} - default: - err = fmt.Errorf("ent: BlobSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (bs *BlobSelect) IntX(ctx context.Context) int { - v, err := bs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (bs *BlobSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(bs.fields) > 1 { - return nil, errors.New("ent: BlobSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := bs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (bs *BlobSelect) Float64sX(ctx context.Context) []float64 { - v, err := bs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (bs *BlobSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = bs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{blob.Label} - default: - err = fmt.Errorf("ent: BlobSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (bs *BlobSelect) Float64X(ctx context.Context) float64 { - v, err := bs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (bs *BlobSelect) Bools(ctx context.Context) ([]bool, error) { - if len(bs.fields) > 1 { - return nil, errors.New("ent: BlobSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := bs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (bs *BlobSelect) BoolsX(ctx context.Context) []bool { - v, err := bs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (bs *BlobSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = bs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{blob.Label} - default: - err = fmt.Errorf("ent: BlobSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (bs *BlobSelect) BoolX(ctx context.Context) bool { - v, err := bs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (bs *BlobSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := bs.sql.Query() diff --git a/entc/integration/customid/ent/car_query.go b/entc/integration/customid/ent/car_query.go index a35bf88fa0..4ea7933dcb 100644 --- a/entc/integration/customid/ent/car_query.go +++ b/entc/integration/customid/ent/car_query.go @@ -332,7 +332,10 @@ func (cq *CarQuery) GroupBy(field string, fields ...string) *CarGroupBy { // func (cq *CarQuery) Select(fields ...string) *CarSelect { cq.fields = append(cq.fields, fields...) - return &CarSelect{CarQuery: cq} + sel := &CarSelect{CarQuery: cq} + sel.typ, sel.label = "Car", car.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CarQuery) prepareQuery(ctx context.Context) error { @@ -785,6 +788,7 @@ func (cgb *CarGroupBy) sqlQuery() *sql.Selector { // CarSelect is the builder for selecting fields of Car entities. type CarSelect struct { *CarQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -798,201 +802,6 @@ func (cs *CarSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CarSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CarSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CarSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("ent: CarSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CarSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CarSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CarSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("ent: CarSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CarSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CarSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CarSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("ent: CarSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CarSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CarSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CarSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("ent: CarSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CarSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CarSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/entc/integration/customid/ent/device_query.go b/entc/integration/customid/ent/device_query.go index fb34a1206b..7bb63ef946 100644 --- a/entc/integration/customid/ent/device_query.go +++ b/entc/integration/customid/ent/device_query.go @@ -345,7 +345,10 @@ func (dq *DeviceQuery) GroupBy(field string, fields ...string) *DeviceGroupBy { // instead of selecting all fields in the entity. func (dq *DeviceQuery) Select(fields ...string) *DeviceSelect { dq.fields = append(dq.fields, fields...) - return &DeviceSelect{DeviceQuery: dq} + sel := &DeviceSelect{DeviceQuery: dq} + sel.typ, sel.label = "Device", device.Label + sel.flds, sel.scan = &dq.fields, sel.Scan + return sel } func (dq *DeviceQuery) prepareQuery(ctx context.Context) error { @@ -828,6 +831,7 @@ func (dgb *DeviceGroupBy) sqlQuery() *sql.Selector { // DeviceSelect is the builder for selecting fields of Device entities. type DeviceSelect struct { *DeviceQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -841,201 +845,6 @@ func (ds *DeviceSelect) Scan(ctx context.Context, v interface{}) error { return ds.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ds *DeviceSelect) ScanX(ctx context.Context, v interface{}) { - if err := ds.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ds *DeviceSelect) Strings(ctx context.Context) ([]string, error) { - if len(ds.fields) > 1 { - return nil, errors.New("ent: DeviceSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ds.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ds *DeviceSelect) StringsX(ctx context.Context) []string { - v, err := ds.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ds *DeviceSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ds.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{device.Label} - default: - err = fmt.Errorf("ent: DeviceSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ds *DeviceSelect) StringX(ctx context.Context) string { - v, err := ds.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ds *DeviceSelect) Ints(ctx context.Context) ([]int, error) { - if len(ds.fields) > 1 { - return nil, errors.New("ent: DeviceSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ds.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ds *DeviceSelect) IntsX(ctx context.Context) []int { - v, err := ds.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ds *DeviceSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ds.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{device.Label} - default: - err = fmt.Errorf("ent: DeviceSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ds *DeviceSelect) IntX(ctx context.Context) int { - v, err := ds.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ds *DeviceSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ds.fields) > 1 { - return nil, errors.New("ent: DeviceSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ds.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ds *DeviceSelect) Float64sX(ctx context.Context) []float64 { - v, err := ds.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ds *DeviceSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ds.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{device.Label} - default: - err = fmt.Errorf("ent: DeviceSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ds *DeviceSelect) Float64X(ctx context.Context) float64 { - v, err := ds.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ds *DeviceSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ds.fields) > 1 { - return nil, errors.New("ent: DeviceSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ds.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ds *DeviceSelect) BoolsX(ctx context.Context) []bool { - v, err := ds.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ds *DeviceSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ds.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{device.Label} - default: - err = fmt.Errorf("ent: DeviceSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ds *DeviceSelect) BoolX(ctx context.Context) bool { - v, err := ds.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ds *DeviceSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ds.sql.Query() diff --git a/entc/integration/customid/ent/doc_query.go b/entc/integration/customid/ent/doc_query.go index e3fd2b82b8..3b9bc12d22 100644 --- a/entc/integration/customid/ent/doc_query.go +++ b/entc/integration/customid/ent/doc_query.go @@ -368,7 +368,10 @@ func (dq *DocQuery) GroupBy(field string, fields ...string) *DocGroupBy { // func (dq *DocQuery) Select(fields ...string) *DocSelect { dq.fields = append(dq.fields, fields...) - return &DocSelect{DocQuery: dq} + sel := &DocSelect{DocQuery: dq} + sel.typ, sel.label = "Doc", doc.Label + sel.flds, sel.scan = &dq.fields, sel.Scan + return sel } func (dq *DocQuery) prepareQuery(ctx context.Context) error { @@ -851,6 +854,7 @@ func (dgb *DocGroupBy) sqlQuery() *sql.Selector { // DocSelect is the builder for selecting fields of Doc entities. type DocSelect struct { *DocQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -864,201 +868,6 @@ func (ds *DocSelect) Scan(ctx context.Context, v interface{}) error { return ds.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ds *DocSelect) ScanX(ctx context.Context, v interface{}) { - if err := ds.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ds *DocSelect) Strings(ctx context.Context) ([]string, error) { - if len(ds.fields) > 1 { - return nil, errors.New("ent: DocSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ds.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ds *DocSelect) StringsX(ctx context.Context) []string { - v, err := ds.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ds *DocSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ds.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{doc.Label} - default: - err = fmt.Errorf("ent: DocSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ds *DocSelect) StringX(ctx context.Context) string { - v, err := ds.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ds *DocSelect) Ints(ctx context.Context) ([]int, error) { - if len(ds.fields) > 1 { - return nil, errors.New("ent: DocSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ds.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ds *DocSelect) IntsX(ctx context.Context) []int { - v, err := ds.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ds *DocSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ds.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{doc.Label} - default: - err = fmt.Errorf("ent: DocSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ds *DocSelect) IntX(ctx context.Context) int { - v, err := ds.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ds *DocSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ds.fields) > 1 { - return nil, errors.New("ent: DocSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ds.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ds *DocSelect) Float64sX(ctx context.Context) []float64 { - v, err := ds.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ds *DocSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ds.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{doc.Label} - default: - err = fmt.Errorf("ent: DocSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ds *DocSelect) Float64X(ctx context.Context) float64 { - v, err := ds.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ds *DocSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ds.fields) > 1 { - return nil, errors.New("ent: DocSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ds.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ds *DocSelect) BoolsX(ctx context.Context) []bool { - v, err := ds.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ds *DocSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ds.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{doc.Label} - default: - err = fmt.Errorf("ent: DocSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ds *DocSelect) BoolX(ctx context.Context) bool { - v, err := ds.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ds *DocSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ds.sql.Query() diff --git a/entc/integration/customid/ent/ent.go b/entc/integration/customid/ent/ent.go index 8a1e034356..1912e6f2b0 100644 --- a/entc/integration/customid/ent/ent.go +++ b/entc/integration/customid/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -285,3 +286,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/customid/ent/group_query.go b/entc/integration/customid/ent/group_query.go index 65e82a6d20..255466b31a 100644 --- a/entc/integration/customid/ent/group_query.go +++ b/entc/integration/customid/ent/group_query.go @@ -308,7 +308,10 @@ func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy { // instead of selecting all fields in the entity. func (gq *GroupQuery) Select(fields ...string) *GroupSelect { gq.fields = append(gq.fields, fields...) - return &GroupSelect{GroupQuery: gq} + sel := &GroupSelect{GroupQuery: gq} + sel.typ, sel.label = "Group", group.Label + sel.flds, sel.scan = &gq.fields, sel.Scan + return sel } func (gq *GroupQuery) prepareQuery(ctx context.Context) error { @@ -790,6 +793,7 @@ func (ggb *GroupGroupBy) sqlQuery() *sql.Selector { // GroupSelect is the builder for selecting fields of Group entities. type GroupSelect struct { *GroupQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -803,201 +807,6 @@ func (gs *GroupSelect) Scan(ctx context.Context, v interface{}) error { return gs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gs *GroupSelect) ScanX(ctx context.Context, v interface{}) { - if err := gs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Strings(ctx context.Context) ([]string, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gs *GroupSelect) StringsX(ctx context.Context) []string { - v, err := gs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gs *GroupSelect) StringX(ctx context.Context) string { - v, err := gs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Ints(ctx context.Context) ([]int, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gs *GroupSelect) IntsX(ctx context.Context) []int { - v, err := gs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gs *GroupSelect) IntX(ctx context.Context) int { - v, err := gs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gs *GroupSelect) Float64sX(ctx context.Context) []float64 { - v, err := gs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gs *GroupSelect) Float64X(ctx context.Context) float64 { - v, err := gs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gs *GroupSelect) BoolsX(ctx context.Context) []bool { - v, err := gs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gs *GroupSelect) BoolX(ctx context.Context) bool { - v, err := gs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gs *GroupSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := gs.sql.Query() diff --git a/entc/integration/customid/ent/mixinid_query.go b/entc/integration/customid/ent/mixinid_query.go index 5c0e69adaa..f628c4f9a0 100644 --- a/entc/integration/customid/ent/mixinid_query.go +++ b/entc/integration/customid/ent/mixinid_query.go @@ -295,7 +295,10 @@ func (miq *MixinIDQuery) GroupBy(field string, fields ...string) *MixinIDGroupBy // func (miq *MixinIDQuery) Select(fields ...string) *MixinIDSelect { miq.fields = append(miq.fields, fields...) - return &MixinIDSelect{MixinIDQuery: miq} + sel := &MixinIDSelect{MixinIDQuery: miq} + sel.typ, sel.label = "MixinID", mixinid.Label + sel.flds, sel.scan = &miq.fields, sel.Scan + return sel } func (miq *MixinIDQuery) prepareQuery(ctx context.Context) error { @@ -707,6 +710,7 @@ func (migb *MixinIDGroupBy) sqlQuery() *sql.Selector { // MixinIDSelect is the builder for selecting fields of MixinID entities. type MixinIDSelect struct { *MixinIDQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -720,201 +724,6 @@ func (mis *MixinIDSelect) Scan(ctx context.Context, v interface{}) error { return mis.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (mis *MixinIDSelect) ScanX(ctx context.Context, v interface{}) { - if err := mis.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (mis *MixinIDSelect) Strings(ctx context.Context) ([]string, error) { - if len(mis.fields) > 1 { - return nil, errors.New("ent: MixinIDSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := mis.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (mis *MixinIDSelect) StringsX(ctx context.Context) []string { - v, err := mis.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (mis *MixinIDSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = mis.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{mixinid.Label} - default: - err = fmt.Errorf("ent: MixinIDSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (mis *MixinIDSelect) StringX(ctx context.Context) string { - v, err := mis.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (mis *MixinIDSelect) Ints(ctx context.Context) ([]int, error) { - if len(mis.fields) > 1 { - return nil, errors.New("ent: MixinIDSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := mis.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (mis *MixinIDSelect) IntsX(ctx context.Context) []int { - v, err := mis.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (mis *MixinIDSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = mis.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{mixinid.Label} - default: - err = fmt.Errorf("ent: MixinIDSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (mis *MixinIDSelect) IntX(ctx context.Context) int { - v, err := mis.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (mis *MixinIDSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(mis.fields) > 1 { - return nil, errors.New("ent: MixinIDSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := mis.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (mis *MixinIDSelect) Float64sX(ctx context.Context) []float64 { - v, err := mis.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (mis *MixinIDSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = mis.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{mixinid.Label} - default: - err = fmt.Errorf("ent: MixinIDSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (mis *MixinIDSelect) Float64X(ctx context.Context) float64 { - v, err := mis.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (mis *MixinIDSelect) Bools(ctx context.Context) ([]bool, error) { - if len(mis.fields) > 1 { - return nil, errors.New("ent: MixinIDSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := mis.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (mis *MixinIDSelect) BoolsX(ctx context.Context) []bool { - v, err := mis.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (mis *MixinIDSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = mis.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{mixinid.Label} - default: - err = fmt.Errorf("ent: MixinIDSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (mis *MixinIDSelect) BoolX(ctx context.Context) bool { - v, err := mis.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (mis *MixinIDSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := mis.sql.Query() diff --git a/entc/integration/customid/ent/note_query.go b/entc/integration/customid/ent/note_query.go index 4849926e1e..dc7e5f81a5 100644 --- a/entc/integration/customid/ent/note_query.go +++ b/entc/integration/customid/ent/note_query.go @@ -368,7 +368,10 @@ func (nq *NoteQuery) GroupBy(field string, fields ...string) *NoteGroupBy { // func (nq *NoteQuery) Select(fields ...string) *NoteSelect { nq.fields = append(nq.fields, fields...) - return &NoteSelect{NoteQuery: nq} + sel := &NoteSelect{NoteQuery: nq} + sel.typ, sel.label = "Note", note.Label + sel.flds, sel.scan = &nq.fields, sel.Scan + return sel } func (nq *NoteQuery) prepareQuery(ctx context.Context) error { @@ -851,6 +854,7 @@ func (ngb *NoteGroupBy) sqlQuery() *sql.Selector { // NoteSelect is the builder for selecting fields of Note entities. type NoteSelect struct { *NoteQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -864,201 +868,6 @@ func (ns *NoteSelect) Scan(ctx context.Context, v interface{}) error { return ns.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ns *NoteSelect) ScanX(ctx context.Context, v interface{}) { - if err := ns.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ns *NoteSelect) Strings(ctx context.Context) ([]string, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NoteSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ns *NoteSelect) StringsX(ctx context.Context) []string { - v, err := ns.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ns *NoteSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ns.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{note.Label} - default: - err = fmt.Errorf("ent: NoteSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ns *NoteSelect) StringX(ctx context.Context) string { - v, err := ns.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ns *NoteSelect) Ints(ctx context.Context) ([]int, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NoteSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ns *NoteSelect) IntsX(ctx context.Context) []int { - v, err := ns.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ns *NoteSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ns.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{note.Label} - default: - err = fmt.Errorf("ent: NoteSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ns *NoteSelect) IntX(ctx context.Context) int { - v, err := ns.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ns *NoteSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NoteSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ns *NoteSelect) Float64sX(ctx context.Context) []float64 { - v, err := ns.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ns *NoteSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ns.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{note.Label} - default: - err = fmt.Errorf("ent: NoteSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ns *NoteSelect) Float64X(ctx context.Context) float64 { - v, err := ns.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ns *NoteSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NoteSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ns *NoteSelect) BoolsX(ctx context.Context) []bool { - v, err := ns.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ns *NoteSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ns.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{note.Label} - default: - err = fmt.Errorf("ent: NoteSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ns *NoteSelect) BoolX(ctx context.Context) bool { - v, err := ns.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ns *NoteSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ns.sql.Query() diff --git a/entc/integration/customid/ent/other_query.go b/entc/integration/customid/ent/other_query.go index e97309e35e..eb3e84f7d3 100644 --- a/entc/integration/customid/ent/other_query.go +++ b/entc/integration/customid/ent/other_query.go @@ -271,7 +271,10 @@ func (oq *OtherQuery) GroupBy(field string, fields ...string) *OtherGroupBy { // instead of selecting all fields in the entity. func (oq *OtherQuery) Select(fields ...string) *OtherSelect { oq.fields = append(oq.fields, fields...) - return &OtherSelect{OtherQuery: oq} + sel := &OtherSelect{OtherQuery: oq} + sel.typ, sel.label = "Other", other.Label + sel.flds, sel.scan = &oq.fields, sel.Scan + return sel } func (oq *OtherQuery) prepareQuery(ctx context.Context) error { @@ -683,6 +686,7 @@ func (ogb *OtherGroupBy) sqlQuery() *sql.Selector { // OtherSelect is the builder for selecting fields of Other entities. type OtherSelect struct { *OtherQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -696,201 +700,6 @@ func (os *OtherSelect) Scan(ctx context.Context, v interface{}) error { return os.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (os *OtherSelect) ScanX(ctx context.Context, v interface{}) { - if err := os.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (os *OtherSelect) Strings(ctx context.Context) ([]string, error) { - if len(os.fields) > 1 { - return nil, errors.New("ent: OtherSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := os.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (os *OtherSelect) StringsX(ctx context.Context) []string { - v, err := os.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (os *OtherSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = os.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{other.Label} - default: - err = fmt.Errorf("ent: OtherSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (os *OtherSelect) StringX(ctx context.Context) string { - v, err := os.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (os *OtherSelect) Ints(ctx context.Context) ([]int, error) { - if len(os.fields) > 1 { - return nil, errors.New("ent: OtherSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := os.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (os *OtherSelect) IntsX(ctx context.Context) []int { - v, err := os.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (os *OtherSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = os.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{other.Label} - default: - err = fmt.Errorf("ent: OtherSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (os *OtherSelect) IntX(ctx context.Context) int { - v, err := os.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (os *OtherSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(os.fields) > 1 { - return nil, errors.New("ent: OtherSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := os.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (os *OtherSelect) Float64sX(ctx context.Context) []float64 { - v, err := os.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (os *OtherSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = os.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{other.Label} - default: - err = fmt.Errorf("ent: OtherSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (os *OtherSelect) Float64X(ctx context.Context) float64 { - v, err := os.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (os *OtherSelect) Bools(ctx context.Context) ([]bool, error) { - if len(os.fields) > 1 { - return nil, errors.New("ent: OtherSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := os.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (os *OtherSelect) BoolsX(ctx context.Context) []bool { - v, err := os.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (os *OtherSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = os.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{other.Label} - default: - err = fmt.Errorf("ent: OtherSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (os *OtherSelect) BoolX(ctx context.Context) bool { - v, err := os.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (os *OtherSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := os.sql.Query() diff --git a/entc/integration/customid/ent/pet_query.go b/entc/integration/customid/ent/pet_query.go index 4b4bdd8517..c9efa850b1 100644 --- a/entc/integration/customid/ent/pet_query.go +++ b/entc/integration/customid/ent/pet_query.go @@ -415,7 +415,10 @@ func (pq *PetQuery) GroupBy(field string, fields ...string) *PetGroupBy { // instead of selecting all fields in the entity. func (pq *PetQuery) Select(fields ...string) *PetSelect { pq.fields = append(pq.fields, fields...) - return &PetSelect{PetQuery: pq} + sel := &PetSelect{PetQuery: pq} + sel.typ, sel.label = "Pet", pet.Label + sel.flds, sel.scan = &pq.fields, sel.Scan + return sel } func (pq *PetQuery) prepareQuery(ctx context.Context) error { @@ -994,6 +997,7 @@ func (pgb *PetGroupBy) sqlQuery() *sql.Selector { // PetSelect is the builder for selecting fields of Pet entities. type PetSelect struct { *PetQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -1007,201 +1011,6 @@ func (ps *PetSelect) Scan(ctx context.Context, v interface{}) error { return ps.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ps *PetSelect) ScanX(ctx context.Context, v interface{}) { - if err := ps.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Strings(ctx context.Context) ([]string, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ps *PetSelect) StringsX(ctx context.Context) []string { - v, err := ps.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ps.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ps *PetSelect) StringX(ctx context.Context) string { - v, err := ps.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Ints(ctx context.Context) ([]int, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ps *PetSelect) IntsX(ctx context.Context) []int { - v, err := ps.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ps.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ps *PetSelect) IntX(ctx context.Context) int { - v, err := ps.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ps *PetSelect) Float64sX(ctx context.Context) []float64 { - v, err := ps.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ps.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ps *PetSelect) Float64X(ctx context.Context) float64 { - v, err := ps.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ps *PetSelect) BoolsX(ctx context.Context) []bool { - v, err := ps.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ps.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ps *PetSelect) BoolX(ctx context.Context) bool { - v, err := ps.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ps *PetSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ps.sql.Query() diff --git a/entc/integration/customid/ent/session_query.go b/entc/integration/customid/ent/session_query.go index 3ae962943f..8a4c48d9b3 100644 --- a/entc/integration/customid/ent/session_query.go +++ b/entc/integration/customid/ent/session_query.go @@ -309,7 +309,10 @@ func (sq *SessionQuery) GroupBy(field string, fields ...string) *SessionGroupBy // instead of selecting all fields in the entity. func (sq *SessionQuery) Select(fields ...string) *SessionSelect { sq.fields = append(sq.fields, fields...) - return &SessionSelect{SessionQuery: sq} + sel := &SessionSelect{SessionQuery: sq} + sel.typ, sel.label = "Session", session.Label + sel.flds, sel.scan = &sq.fields, sel.Scan + return sel } func (sq *SessionQuery) prepareQuery(ctx context.Context) error { @@ -762,6 +765,7 @@ func (sgb *SessionGroupBy) sqlQuery() *sql.Selector { // SessionSelect is the builder for selecting fields of Session entities. type SessionSelect struct { *SessionQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -775,201 +779,6 @@ func (ss *SessionSelect) Scan(ctx context.Context, v interface{}) error { return ss.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ss *SessionSelect) ScanX(ctx context.Context, v interface{}) { - if err := ss.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ss *SessionSelect) Strings(ctx context.Context) ([]string, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: SessionSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ss *SessionSelect) StringsX(ctx context.Context) []string { - v, err := ss.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ss *SessionSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ss.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{session.Label} - default: - err = fmt.Errorf("ent: SessionSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ss *SessionSelect) StringX(ctx context.Context) string { - v, err := ss.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ss *SessionSelect) Ints(ctx context.Context) ([]int, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: SessionSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ss *SessionSelect) IntsX(ctx context.Context) []int { - v, err := ss.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ss *SessionSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ss.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{session.Label} - default: - err = fmt.Errorf("ent: SessionSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ss *SessionSelect) IntX(ctx context.Context) int { - v, err := ss.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ss *SessionSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: SessionSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ss *SessionSelect) Float64sX(ctx context.Context) []float64 { - v, err := ss.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ss *SessionSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ss.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{session.Label} - default: - err = fmt.Errorf("ent: SessionSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ss *SessionSelect) Float64X(ctx context.Context) float64 { - v, err := ss.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ss *SessionSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: SessionSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ss *SessionSelect) BoolsX(ctx context.Context) []bool { - v, err := ss.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ss *SessionSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ss.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{session.Label} - default: - err = fmt.Errorf("ent: SessionSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ss *SessionSelect) BoolX(ctx context.Context) bool { - v, err := ss.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ss *SessionSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ss.sql.Query() diff --git a/entc/integration/customid/ent/token_query.go b/entc/integration/customid/ent/token_query.go index 029bc73d87..1a5e30f0af 100644 --- a/entc/integration/customid/ent/token_query.go +++ b/entc/integration/customid/ent/token_query.go @@ -333,7 +333,10 @@ func (tq *TokenQuery) GroupBy(field string, fields ...string) *TokenGroupBy { // func (tq *TokenQuery) Select(fields ...string) *TokenSelect { tq.fields = append(tq.fields, fields...) - return &TokenSelect{TokenQuery: tq} + sel := &TokenSelect{TokenQuery: tq} + sel.typ, sel.label = "Token", token.Label + sel.flds, sel.scan = &tq.fields, sel.Scan + return sel } func (tq *TokenQuery) prepareQuery(ctx context.Context) error { @@ -786,6 +789,7 @@ func (tgb *TokenGroupBy) sqlQuery() *sql.Selector { // TokenSelect is the builder for selecting fields of Token entities. type TokenSelect struct { *TokenQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -799,201 +803,6 @@ func (ts *TokenSelect) Scan(ctx context.Context, v interface{}) error { return ts.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ts *TokenSelect) ScanX(ctx context.Context, v interface{}) { - if err := ts.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ts *TokenSelect) Strings(ctx context.Context) ([]string, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TokenSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ts *TokenSelect) StringsX(ctx context.Context) []string { - v, err := ts.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ts *TokenSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ts.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{token.Label} - default: - err = fmt.Errorf("ent: TokenSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ts *TokenSelect) StringX(ctx context.Context) string { - v, err := ts.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ts *TokenSelect) Ints(ctx context.Context) ([]int, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TokenSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ts *TokenSelect) IntsX(ctx context.Context) []int { - v, err := ts.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ts *TokenSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ts.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{token.Label} - default: - err = fmt.Errorf("ent: TokenSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ts *TokenSelect) IntX(ctx context.Context) int { - v, err := ts.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ts *TokenSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TokenSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ts *TokenSelect) Float64sX(ctx context.Context) []float64 { - v, err := ts.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ts *TokenSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ts.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{token.Label} - default: - err = fmt.Errorf("ent: TokenSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ts *TokenSelect) Float64X(ctx context.Context) float64 { - v, err := ts.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ts *TokenSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TokenSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ts *TokenSelect) BoolsX(ctx context.Context) []bool { - v, err := ts.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ts *TokenSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ts.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{token.Label} - default: - err = fmt.Errorf("ent: TokenSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ts *TokenSelect) BoolX(ctx context.Context) bool { - v, err := ts.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ts *TokenSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ts.sql.Query() diff --git a/entc/integration/customid/ent/user_query.go b/entc/integration/customid/ent/user_query.go index 8cd1c6207c..c911393fdb 100644 --- a/entc/integration/customid/ent/user_query.go +++ b/entc/integration/customid/ent/user_query.go @@ -415,7 +415,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // instead of selecting all fields in the entity. func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -994,6 +997,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -1007,201 +1011,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/entc/integration/edgefield/ent/car_query.go b/entc/integration/edgefield/ent/car_query.go index 88296fdcfa..723efe9c7a 100644 --- a/entc/integration/edgefield/ent/car_query.go +++ b/entc/integration/edgefield/ent/car_query.go @@ -333,7 +333,10 @@ func (cq *CarQuery) GroupBy(field string, fields ...string) *CarGroupBy { // func (cq *CarQuery) Select(fields ...string) *CarSelect { cq.fields = append(cq.fields, fields...) - return &CarSelect{CarQuery: cq} + sel := &CarSelect{CarQuery: cq} + sel.typ, sel.label = "Car", car.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CarQuery) prepareQuery(ctx context.Context) error { @@ -775,6 +778,7 @@ func (cgb *CarGroupBy) sqlQuery() *sql.Selector { // CarSelect is the builder for selecting fields of Car entities. type CarSelect struct { *CarQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -788,201 +792,6 @@ func (cs *CarSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CarSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CarSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CarSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("ent: CarSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CarSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CarSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CarSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("ent: CarSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CarSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CarSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CarSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("ent: CarSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CarSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CarSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CarSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("ent: CarSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CarSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CarSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/entc/integration/edgefield/ent/card_query.go b/entc/integration/edgefield/ent/card_query.go index 3cc645379b..29b3bc1e9e 100644 --- a/entc/integration/edgefield/ent/card_query.go +++ b/entc/integration/edgefield/ent/card_query.go @@ -331,7 +331,10 @@ func (cq *CardQuery) GroupBy(field string, fields ...string) *CardGroupBy { // func (cq *CardQuery) Select(fields ...string) *CardSelect { cq.fields = append(cq.fields, fields...) - return &CardSelect{CardQuery: cq} + sel := &CardSelect{CardQuery: cq} + sel.typ, sel.label = "Card", card.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CardQuery) prepareQuery(ctx context.Context) error { @@ -774,6 +777,7 @@ func (cgb *CardGroupBy) sqlQuery() *sql.Selector { // CardSelect is the builder for selecting fields of Card entities. type CardSelect struct { *CardQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -787,201 +791,6 @@ func (cs *CardSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CardSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CardSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CardSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CardSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CardSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CardSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CardSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CardSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CardSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CardSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/entc/integration/edgefield/ent/ent.go b/entc/integration/edgefield/ent/ent.go index 1820cba41d..2d107dab9f 100644 --- a/entc/integration/edgefield/ent/ent.go +++ b/entc/integration/edgefield/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -277,3 +278,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/edgefield/ent/info_query.go b/entc/integration/edgefield/ent/info_query.go index aafa7b1134..84885514dd 100644 --- a/entc/integration/edgefield/ent/info_query.go +++ b/entc/integration/edgefield/ent/info_query.go @@ -331,7 +331,10 @@ func (iq *InfoQuery) GroupBy(field string, fields ...string) *InfoGroupBy { // func (iq *InfoQuery) Select(fields ...string) *InfoSelect { iq.fields = append(iq.fields, fields...) - return &InfoSelect{InfoQuery: iq} + sel := &InfoSelect{InfoQuery: iq} + sel.typ, sel.label = "Info", info.Label + sel.flds, sel.scan = &iq.fields, sel.Scan + return sel } func (iq *InfoQuery) prepareQuery(ctx context.Context) error { @@ -774,6 +777,7 @@ func (igb *InfoGroupBy) sqlQuery() *sql.Selector { // InfoSelect is the builder for selecting fields of Info entities. type InfoSelect struct { *InfoQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -787,201 +791,6 @@ func (is *InfoSelect) Scan(ctx context.Context, v interface{}) error { return is.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (is *InfoSelect) ScanX(ctx context.Context, v interface{}) { - if err := is.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (is *InfoSelect) Strings(ctx context.Context) ([]string, error) { - if len(is.fields) > 1 { - return nil, errors.New("ent: InfoSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := is.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (is *InfoSelect) StringsX(ctx context.Context) []string { - v, err := is.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (is *InfoSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = is.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{info.Label} - default: - err = fmt.Errorf("ent: InfoSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (is *InfoSelect) StringX(ctx context.Context) string { - v, err := is.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (is *InfoSelect) Ints(ctx context.Context) ([]int, error) { - if len(is.fields) > 1 { - return nil, errors.New("ent: InfoSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := is.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (is *InfoSelect) IntsX(ctx context.Context) []int { - v, err := is.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (is *InfoSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = is.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{info.Label} - default: - err = fmt.Errorf("ent: InfoSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (is *InfoSelect) IntX(ctx context.Context) int { - v, err := is.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (is *InfoSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(is.fields) > 1 { - return nil, errors.New("ent: InfoSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := is.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (is *InfoSelect) Float64sX(ctx context.Context) []float64 { - v, err := is.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (is *InfoSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = is.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{info.Label} - default: - err = fmt.Errorf("ent: InfoSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (is *InfoSelect) Float64X(ctx context.Context) float64 { - v, err := is.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (is *InfoSelect) Bools(ctx context.Context) ([]bool, error) { - if len(is.fields) > 1 { - return nil, errors.New("ent: InfoSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := is.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (is *InfoSelect) BoolsX(ctx context.Context) []bool { - v, err := is.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (is *InfoSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = is.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{info.Label} - default: - err = fmt.Errorf("ent: InfoSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (is *InfoSelect) BoolX(ctx context.Context) bool { - v, err := is.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (is *InfoSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := is.sql.Query() diff --git a/entc/integration/edgefield/ent/metadata_query.go b/entc/integration/edgefield/ent/metadata_query.go index b3f449b940..b1918a50dd 100644 --- a/entc/integration/edgefield/ent/metadata_query.go +++ b/entc/integration/edgefield/ent/metadata_query.go @@ -402,7 +402,10 @@ func (mq *MetadataQuery) GroupBy(field string, fields ...string) *MetadataGroupB // func (mq *MetadataQuery) Select(fields ...string) *MetadataSelect { mq.fields = append(mq.fields, fields...) - return &MetadataSelect{MetadataQuery: mq} + sel := &MetadataSelect{MetadataQuery: mq} + sel.typ, sel.label = "Metadata", metadata.Label + sel.flds, sel.scan = &mq.fields, sel.Scan + return sel } func (mq *MetadataQuery) prepareQuery(ctx context.Context) error { @@ -898,6 +901,7 @@ func (mgb *MetadataGroupBy) sqlQuery() *sql.Selector { // MetadataSelect is the builder for selecting fields of Metadata entities. type MetadataSelect struct { *MetadataQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -911,201 +915,6 @@ func (ms *MetadataSelect) Scan(ctx context.Context, v interface{}) error { return ms.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ms *MetadataSelect) ScanX(ctx context.Context, v interface{}) { - if err := ms.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ms *MetadataSelect) Strings(ctx context.Context) ([]string, error) { - if len(ms.fields) > 1 { - return nil, errors.New("ent: MetadataSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ms.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ms *MetadataSelect) StringsX(ctx context.Context) []string { - v, err := ms.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ms *MetadataSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ms.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{metadata.Label} - default: - err = fmt.Errorf("ent: MetadataSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ms *MetadataSelect) StringX(ctx context.Context) string { - v, err := ms.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ms *MetadataSelect) Ints(ctx context.Context) ([]int, error) { - if len(ms.fields) > 1 { - return nil, errors.New("ent: MetadataSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ms.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ms *MetadataSelect) IntsX(ctx context.Context) []int { - v, err := ms.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ms *MetadataSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ms.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{metadata.Label} - default: - err = fmt.Errorf("ent: MetadataSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ms *MetadataSelect) IntX(ctx context.Context) int { - v, err := ms.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ms *MetadataSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ms.fields) > 1 { - return nil, errors.New("ent: MetadataSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ms.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ms *MetadataSelect) Float64sX(ctx context.Context) []float64 { - v, err := ms.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ms *MetadataSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ms.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{metadata.Label} - default: - err = fmt.Errorf("ent: MetadataSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ms *MetadataSelect) Float64X(ctx context.Context) float64 { - v, err := ms.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ms *MetadataSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ms.fields) > 1 { - return nil, errors.New("ent: MetadataSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ms.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ms *MetadataSelect) BoolsX(ctx context.Context) []bool { - v, err := ms.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ms *MetadataSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ms.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{metadata.Label} - default: - err = fmt.Errorf("ent: MetadataSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ms *MetadataSelect) BoolX(ctx context.Context) bool { - v, err := ms.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ms *MetadataSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ms.sql.Query() diff --git a/entc/integration/edgefield/ent/node_query.go b/entc/integration/edgefield/ent/node_query.go index 2b88548bad..7d862e1d5a 100644 --- a/entc/integration/edgefield/ent/node_query.go +++ b/entc/integration/edgefield/ent/node_query.go @@ -366,7 +366,10 @@ func (nq *NodeQuery) GroupBy(field string, fields ...string) *NodeGroupBy { // func (nq *NodeQuery) Select(fields ...string) *NodeSelect { nq.fields = append(nq.fields, fields...) - return &NodeSelect{NodeQuery: nq} + sel := &NodeSelect{NodeQuery: nq} + sel.typ, sel.label = "Node", node.Label + sel.flds, sel.scan = &nq.fields, sel.Scan + return sel } func (nq *NodeQuery) prepareQuery(ctx context.Context) error { @@ -834,6 +837,7 @@ func (ngb *NodeGroupBy) sqlQuery() *sql.Selector { // NodeSelect is the builder for selecting fields of Node entities. type NodeSelect struct { *NodeQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -847,201 +851,6 @@ func (ns *NodeSelect) Scan(ctx context.Context, v interface{}) error { return ns.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ns *NodeSelect) ScanX(ctx context.Context, v interface{}) { - if err := ns.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Strings(ctx context.Context) ([]string, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ns *NodeSelect) StringsX(ctx context.Context) []string { - v, err := ns.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ns.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ns *NodeSelect) StringX(ctx context.Context) string { - v, err := ns.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Ints(ctx context.Context) ([]int, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ns *NodeSelect) IntsX(ctx context.Context) []int { - v, err := ns.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ns.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ns *NodeSelect) IntX(ctx context.Context) int { - v, err := ns.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ns *NodeSelect) Float64sX(ctx context.Context) []float64 { - v, err := ns.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ns.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ns *NodeSelect) Float64X(ctx context.Context) float64 { - v, err := ns.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ns *NodeSelect) BoolsX(ctx context.Context) []bool { - v, err := ns.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ns.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ns *NodeSelect) BoolX(ctx context.Context) bool { - v, err := ns.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ns *NodeSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ns.sql.Query() diff --git a/entc/integration/edgefield/ent/pet_query.go b/entc/integration/edgefield/ent/pet_query.go index 831fbd0a85..f6533c226e 100644 --- a/entc/integration/edgefield/ent/pet_query.go +++ b/entc/integration/edgefield/ent/pet_query.go @@ -331,7 +331,10 @@ func (pq *PetQuery) GroupBy(field string, fields ...string) *PetGroupBy { // func (pq *PetQuery) Select(fields ...string) *PetSelect { pq.fields = append(pq.fields, fields...) - return &PetSelect{PetQuery: pq} + sel := &PetSelect{PetQuery: pq} + sel.typ, sel.label = "Pet", pet.Label + sel.flds, sel.scan = &pq.fields, sel.Scan + return sel } func (pq *PetQuery) prepareQuery(ctx context.Context) error { @@ -774,6 +777,7 @@ func (pgb *PetGroupBy) sqlQuery() *sql.Selector { // PetSelect is the builder for selecting fields of Pet entities. type PetSelect struct { *PetQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -787,201 +791,6 @@ func (ps *PetSelect) Scan(ctx context.Context, v interface{}) error { return ps.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ps *PetSelect) ScanX(ctx context.Context, v interface{}) { - if err := ps.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Strings(ctx context.Context) ([]string, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ps *PetSelect) StringsX(ctx context.Context) []string { - v, err := ps.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ps.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ps *PetSelect) StringX(ctx context.Context) string { - v, err := ps.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Ints(ctx context.Context) ([]int, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ps *PetSelect) IntsX(ctx context.Context) []int { - v, err := ps.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ps.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ps *PetSelect) IntX(ctx context.Context) int { - v, err := ps.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ps *PetSelect) Float64sX(ctx context.Context) []float64 { - v, err := ps.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ps.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ps *PetSelect) Float64X(ctx context.Context) float64 { - v, err := ps.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ps *PetSelect) BoolsX(ctx context.Context) []bool { - v, err := ps.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ps.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ps *PetSelect) BoolX(ctx context.Context) bool { - v, err := ps.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ps *PetSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ps.sql.Query() diff --git a/entc/integration/edgefield/ent/post_query.go b/entc/integration/edgefield/ent/post_query.go index 38c80db0d3..5fb22b8c1e 100644 --- a/entc/integration/edgefield/ent/post_query.go +++ b/entc/integration/edgefield/ent/post_query.go @@ -331,7 +331,10 @@ func (pq *PostQuery) GroupBy(field string, fields ...string) *PostGroupBy { // func (pq *PostQuery) Select(fields ...string) *PostSelect { pq.fields = append(pq.fields, fields...) - return &PostSelect{PostQuery: pq} + sel := &PostSelect{PostQuery: pq} + sel.typ, sel.label = "Post", post.Label + sel.flds, sel.scan = &pq.fields, sel.Scan + return sel } func (pq *PostQuery) prepareQuery(ctx context.Context) error { @@ -777,6 +780,7 @@ func (pgb *PostGroupBy) sqlQuery() *sql.Selector { // PostSelect is the builder for selecting fields of Post entities. type PostSelect struct { *PostQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -790,201 +794,6 @@ func (ps *PostSelect) Scan(ctx context.Context, v interface{}) error { return ps.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ps *PostSelect) ScanX(ctx context.Context, v interface{}) { - if err := ps.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Strings(ctx context.Context) ([]string, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PostSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ps *PostSelect) StringsX(ctx context.Context) []string { - v, err := ps.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ps.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{post.Label} - default: - err = fmt.Errorf("ent: PostSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ps *PostSelect) StringX(ctx context.Context) string { - v, err := ps.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Ints(ctx context.Context) ([]int, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PostSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ps *PostSelect) IntsX(ctx context.Context) []int { - v, err := ps.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ps.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{post.Label} - default: - err = fmt.Errorf("ent: PostSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ps *PostSelect) IntX(ctx context.Context) int { - v, err := ps.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PostSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ps *PostSelect) Float64sX(ctx context.Context) []float64 { - v, err := ps.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ps.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{post.Label} - default: - err = fmt.Errorf("ent: PostSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ps *PostSelect) Float64X(ctx context.Context) float64 { - v, err := ps.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PostSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ps *PostSelect) BoolsX(ctx context.Context) []bool { - v, err := ps.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ps *PostSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ps.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{post.Label} - default: - err = fmt.Errorf("ent: PostSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ps *PostSelect) BoolX(ctx context.Context) bool { - v, err := ps.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ps *PostSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ps.sql.Query() diff --git a/entc/integration/edgefield/ent/rental_query.go b/entc/integration/edgefield/ent/rental_query.go index 0bd27a8c7e..c8818c5eb7 100644 --- a/entc/integration/edgefield/ent/rental_query.go +++ b/entc/integration/edgefield/ent/rental_query.go @@ -368,7 +368,10 @@ func (rq *RentalQuery) GroupBy(field string, fields ...string) *RentalGroupBy { // func (rq *RentalQuery) Select(fields ...string) *RentalSelect { rq.fields = append(rq.fields, fields...) - return &RentalSelect{RentalQuery: rq} + sel := &RentalSelect{RentalQuery: rq} + sel.typ, sel.label = "Rental", rental.Label + sel.flds, sel.scan = &rq.fields, sel.Scan + return sel } func (rq *RentalQuery) prepareQuery(ctx context.Context) error { @@ -838,6 +841,7 @@ func (rgb *RentalGroupBy) sqlQuery() *sql.Selector { // RentalSelect is the builder for selecting fields of Rental entities. type RentalSelect struct { *RentalQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -851,201 +855,6 @@ func (rs *RentalSelect) Scan(ctx context.Context, v interface{}) error { return rs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (rs *RentalSelect) ScanX(ctx context.Context, v interface{}) { - if err := rs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (rs *RentalSelect) Strings(ctx context.Context) ([]string, error) { - if len(rs.fields) > 1 { - return nil, errors.New("ent: RentalSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := rs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (rs *RentalSelect) StringsX(ctx context.Context) []string { - v, err := rs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (rs *RentalSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = rs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{rental.Label} - default: - err = fmt.Errorf("ent: RentalSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (rs *RentalSelect) StringX(ctx context.Context) string { - v, err := rs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (rs *RentalSelect) Ints(ctx context.Context) ([]int, error) { - if len(rs.fields) > 1 { - return nil, errors.New("ent: RentalSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := rs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (rs *RentalSelect) IntsX(ctx context.Context) []int { - v, err := rs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (rs *RentalSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = rs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{rental.Label} - default: - err = fmt.Errorf("ent: RentalSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (rs *RentalSelect) IntX(ctx context.Context) int { - v, err := rs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (rs *RentalSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(rs.fields) > 1 { - return nil, errors.New("ent: RentalSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := rs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (rs *RentalSelect) Float64sX(ctx context.Context) []float64 { - v, err := rs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (rs *RentalSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = rs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{rental.Label} - default: - err = fmt.Errorf("ent: RentalSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (rs *RentalSelect) Float64X(ctx context.Context) float64 { - v, err := rs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (rs *RentalSelect) Bools(ctx context.Context) ([]bool, error) { - if len(rs.fields) > 1 { - return nil, errors.New("ent: RentalSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := rs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (rs *RentalSelect) BoolsX(ctx context.Context) []bool { - v, err := rs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (rs *RentalSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = rs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{rental.Label} - default: - err = fmt.Errorf("ent: RentalSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (rs *RentalSelect) BoolX(ctx context.Context) bool { - v, err := rs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (rs *RentalSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := rs.sql.Query() diff --git a/entc/integration/edgefield/ent/user_query.go b/entc/integration/edgefield/ent/user_query.go index 8cb4aab965..f69a879965 100644 --- a/entc/integration/edgefield/ent/user_query.go +++ b/entc/integration/edgefield/ent/user_query.go @@ -581,7 +581,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -1205,6 +1208,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -1218,201 +1222,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/entc/integration/ent/card_query.go b/entc/integration/ent/card_query.go index d0cef51ed5..4320a7c9f1 100644 --- a/entc/integration/ent/card_query.go +++ b/entc/integration/ent/card_query.go @@ -371,7 +371,10 @@ func (cq *CardQuery) GroupBy(field string, fields ...string) *CardGroupBy { // func (cq *CardQuery) Select(fields ...string) *CardSelect { cq.fields = append(cq.fields, fields...) - return &CardSelect{CardQuery: cq} + sel := &CardSelect{CardQuery: cq} + sel.typ, sel.label = "Card", card.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CardQuery) prepareQuery(ctx context.Context) error { @@ -931,6 +934,7 @@ func (cgb *CardGroupBy) sqlQuery() *sql.Selector { // CardSelect is the builder for selecting fields of Card entities. type CardSelect struct { *CardQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -944,201 +948,6 @@ func (cs *CardSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CardSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CardSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CardSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CardSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CardSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CardSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CardSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CardSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CardSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CardSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/entc/integration/ent/comment_query.go b/entc/integration/ent/comment_query.go index 49f48a5ecf..cffe4e6c89 100644 --- a/entc/integration/ent/comment_query.go +++ b/entc/integration/ent/comment_query.go @@ -296,7 +296,10 @@ func (cq *CommentQuery) GroupBy(field string, fields ...string) *CommentGroupBy // func (cq *CommentQuery) Select(fields ...string) *CommentSelect { cq.fields = append(cq.fields, fields...) - return &CommentSelect{CommentQuery: cq} + sel := &CommentSelect{CommentQuery: cq} + sel.typ, sel.label = "Comment", comment.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CommentQuery) prepareQuery(ctx context.Context) error { @@ -749,6 +752,7 @@ func (cgb *CommentGroupBy) sqlQuery() *sql.Selector { // CommentSelect is the builder for selecting fields of Comment entities. type CommentSelect struct { *CommentQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -762,201 +766,6 @@ func (cs *CommentSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CommentSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CommentSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CommentSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{comment.Label} - default: - err = fmt.Errorf("ent: CommentSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CommentSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CommentSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CommentSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{comment.Label} - default: - err = fmt.Errorf("ent: CommentSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CommentSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CommentSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CommentSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{comment.Label} - default: - err = fmt.Errorf("ent: CommentSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CommentSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CommentSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CommentSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{comment.Label} - default: - err = fmt.Errorf("ent: CommentSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CommentSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CommentSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/entc/integration/ent/ent.go b/entc/integration/ent/ent.go index 068a68b73a..5545967d08 100644 --- a/entc/integration/ent/ent.go +++ b/entc/integration/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -287,3 +288,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/ent/fieldtype_query.go b/entc/integration/ent/fieldtype_query.go index 8f73dc652f..9e0a470d26 100644 --- a/entc/integration/ent/fieldtype_query.go +++ b/entc/integration/ent/fieldtype_query.go @@ -297,7 +297,10 @@ func (ftq *FieldTypeQuery) GroupBy(field string, fields ...string) *FieldTypeGro // func (ftq *FieldTypeQuery) Select(fields ...string) *FieldTypeSelect { ftq.fields = append(ftq.fields, fields...) - return &FieldTypeSelect{FieldTypeQuery: ftq} + sel := &FieldTypeSelect{FieldTypeQuery: ftq} + sel.typ, sel.label = "FieldType", fieldtype.Label + sel.flds, sel.scan = &ftq.fields, sel.Scan + return sel } func (ftq *FieldTypeQuery) prepareQuery(ctx context.Context) error { @@ -754,6 +757,7 @@ func (ftgb *FieldTypeGroupBy) sqlQuery() *sql.Selector { // FieldTypeSelect is the builder for selecting fields of FieldType entities. type FieldTypeSelect struct { *FieldTypeQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -767,201 +771,6 @@ func (fts *FieldTypeSelect) Scan(ctx context.Context, v interface{}) error { return fts.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (fts *FieldTypeSelect) ScanX(ctx context.Context, v interface{}) { - if err := fts.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Strings(ctx context.Context) ([]string, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FieldTypeSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (fts *FieldTypeSelect) StringsX(ctx context.Context) []string { - v, err := fts.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = fts.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{fieldtype.Label} - default: - err = fmt.Errorf("ent: FieldTypeSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (fts *FieldTypeSelect) StringX(ctx context.Context) string { - v, err := fts.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Ints(ctx context.Context) ([]int, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FieldTypeSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (fts *FieldTypeSelect) IntsX(ctx context.Context) []int { - v, err := fts.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = fts.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{fieldtype.Label} - default: - err = fmt.Errorf("ent: FieldTypeSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (fts *FieldTypeSelect) IntX(ctx context.Context) int { - v, err := fts.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FieldTypeSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (fts *FieldTypeSelect) Float64sX(ctx context.Context) []float64 { - v, err := fts.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = fts.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{fieldtype.Label} - default: - err = fmt.Errorf("ent: FieldTypeSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (fts *FieldTypeSelect) Float64X(ctx context.Context) float64 { - v, err := fts.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Bools(ctx context.Context) ([]bool, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FieldTypeSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (fts *FieldTypeSelect) BoolsX(ctx context.Context) []bool { - v, err := fts.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = fts.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{fieldtype.Label} - default: - err = fmt.Errorf("ent: FieldTypeSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (fts *FieldTypeSelect) BoolX(ctx context.Context) bool { - v, err := fts.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (fts *FieldTypeSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := fts.sql.Query() diff --git a/entc/integration/ent/file_query.go b/entc/integration/ent/file_query.go index 966ef19180..9b80d85420 100644 --- a/entc/integration/ent/file_query.go +++ b/entc/integration/ent/file_query.go @@ -407,7 +407,10 @@ func (fq *FileQuery) GroupBy(field string, fields ...string) *FileGroupBy { // func (fq *FileQuery) Select(fields ...string) *FileSelect { fq.fields = append(fq.fields, fields...) - return &FileSelect{FileQuery: fq} + sel := &FileSelect{FileQuery: fq} + sel.typ, sel.label = "File", file.Label + sel.flds, sel.scan = &fq.fields, sel.Scan + return sel } func (fq *FileQuery) prepareQuery(ctx context.Context) error { @@ -961,6 +964,7 @@ func (fgb *FileGroupBy) sqlQuery() *sql.Selector { // FileSelect is the builder for selecting fields of File entities. type FileSelect struct { *FileQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -974,201 +978,6 @@ func (fs *FileSelect) Scan(ctx context.Context, v interface{}) error { return fs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (fs *FileSelect) ScanX(ctx context.Context, v interface{}) { - if err := fs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Strings(ctx context.Context) ([]string, error) { - if len(fs.fields) > 1 { - return nil, errors.New("ent: FileSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := fs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (fs *FileSelect) StringsX(ctx context.Context) []string { - v, err := fs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = fs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{file.Label} - default: - err = fmt.Errorf("ent: FileSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (fs *FileSelect) StringX(ctx context.Context) string { - v, err := fs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Ints(ctx context.Context) ([]int, error) { - if len(fs.fields) > 1 { - return nil, errors.New("ent: FileSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := fs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (fs *FileSelect) IntsX(ctx context.Context) []int { - v, err := fs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = fs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{file.Label} - default: - err = fmt.Errorf("ent: FileSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (fs *FileSelect) IntX(ctx context.Context) int { - v, err := fs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(fs.fields) > 1 { - return nil, errors.New("ent: FileSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := fs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (fs *FileSelect) Float64sX(ctx context.Context) []float64 { - v, err := fs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = fs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{file.Label} - default: - err = fmt.Errorf("ent: FileSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (fs *FileSelect) Float64X(ctx context.Context) float64 { - v, err := fs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Bools(ctx context.Context) ([]bool, error) { - if len(fs.fields) > 1 { - return nil, errors.New("ent: FileSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := fs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (fs *FileSelect) BoolsX(ctx context.Context) []bool { - v, err := fs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = fs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{file.Label} - default: - err = fmt.Errorf("ent: FileSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (fs *FileSelect) BoolX(ctx context.Context) bool { - v, err := fs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (fs *FileSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := fs.sql.Query() diff --git a/entc/integration/ent/filetype_query.go b/entc/integration/ent/filetype_query.go index 82ad861245..9251ffd44d 100644 --- a/entc/integration/ent/filetype_query.go +++ b/entc/integration/ent/filetype_query.go @@ -334,7 +334,10 @@ func (ftq *FileTypeQuery) GroupBy(field string, fields ...string) *FileTypeGroup // func (ftq *FileTypeQuery) Select(fields ...string) *FileTypeSelect { ftq.fields = append(ftq.fields, fields...) - return &FileTypeSelect{FileTypeQuery: ftq} + sel := &FileTypeSelect{FileTypeQuery: ftq} + sel.typ, sel.label = "FileType", filetype.Label + sel.flds, sel.scan = &ftq.fields, sel.Scan + return sel } func (ftq *FileTypeQuery) prepareQuery(ctx context.Context) error { @@ -821,6 +824,7 @@ func (ftgb *FileTypeGroupBy) sqlQuery() *sql.Selector { // FileTypeSelect is the builder for selecting fields of FileType entities. type FileTypeSelect struct { *FileTypeQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -834,201 +838,6 @@ func (fts *FileTypeSelect) Scan(ctx context.Context, v interface{}) error { return fts.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (fts *FileTypeSelect) ScanX(ctx context.Context, v interface{}) { - if err := fts.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Strings(ctx context.Context) ([]string, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FileTypeSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (fts *FileTypeSelect) StringsX(ctx context.Context) []string { - v, err := fts.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = fts.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{filetype.Label} - default: - err = fmt.Errorf("ent: FileTypeSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (fts *FileTypeSelect) StringX(ctx context.Context) string { - v, err := fts.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Ints(ctx context.Context) ([]int, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FileTypeSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (fts *FileTypeSelect) IntsX(ctx context.Context) []int { - v, err := fts.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = fts.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{filetype.Label} - default: - err = fmt.Errorf("ent: FileTypeSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (fts *FileTypeSelect) IntX(ctx context.Context) int { - v, err := fts.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FileTypeSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (fts *FileTypeSelect) Float64sX(ctx context.Context) []float64 { - v, err := fts.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = fts.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{filetype.Label} - default: - err = fmt.Errorf("ent: FileTypeSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (fts *FileTypeSelect) Float64X(ctx context.Context) float64 { - v, err := fts.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Bools(ctx context.Context) ([]bool, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FileTypeSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (fts *FileTypeSelect) BoolsX(ctx context.Context) []bool { - v, err := fts.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = fts.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{filetype.Label} - default: - err = fmt.Errorf("ent: FileTypeSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (fts *FileTypeSelect) BoolX(ctx context.Context) bool { - v, err := fts.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (fts *FileTypeSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := fts.sql.Query() diff --git a/entc/integration/ent/goods_query.go b/entc/integration/ent/goods_query.go index a23e8c5bf6..4f94d69a8b 100644 --- a/entc/integration/ent/goods_query.go +++ b/entc/integration/ent/goods_query.go @@ -272,7 +272,10 @@ func (gq *GoodsQuery) GroupBy(field string, fields ...string) *GoodsGroupBy { // instead of selecting all fields in the entity. func (gq *GoodsQuery) Select(fields ...string) *GoodsSelect { gq.fields = append(gq.fields, fields...) - return &GoodsSelect{GoodsQuery: gq} + sel := &GoodsSelect{GoodsQuery: gq} + sel.typ, sel.label = "Goods", goods.Label + sel.flds, sel.scan = &gq.fields, sel.Scan + return sel } func (gq *GoodsQuery) prepareQuery(ctx context.Context) error { @@ -725,6 +728,7 @@ func (ggb *GoodsGroupBy) sqlQuery() *sql.Selector { // GoodsSelect is the builder for selecting fields of Goods entities. type GoodsSelect struct { *GoodsQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -738,201 +742,6 @@ func (gs *GoodsSelect) Scan(ctx context.Context, v interface{}) error { return gs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gs *GoodsSelect) ScanX(ctx context.Context, v interface{}) { - if err := gs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Strings(ctx context.Context) ([]string, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GoodsSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gs *GoodsSelect) StringsX(ctx context.Context) []string { - v, err := gs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{goods.Label} - default: - err = fmt.Errorf("ent: GoodsSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gs *GoodsSelect) StringX(ctx context.Context) string { - v, err := gs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Ints(ctx context.Context) ([]int, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GoodsSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gs *GoodsSelect) IntsX(ctx context.Context) []int { - v, err := gs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{goods.Label} - default: - err = fmt.Errorf("ent: GoodsSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gs *GoodsSelect) IntX(ctx context.Context) int { - v, err := gs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GoodsSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gs *GoodsSelect) Float64sX(ctx context.Context) []float64 { - v, err := gs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{goods.Label} - default: - err = fmt.Errorf("ent: GoodsSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gs *GoodsSelect) Float64X(ctx context.Context) float64 { - v, err := gs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GoodsSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gs *GoodsSelect) BoolsX(ctx context.Context) []bool { - v, err := gs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{goods.Label} - default: - err = fmt.Errorf("ent: GoodsSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gs *GoodsSelect) BoolX(ctx context.Context) bool { - v, err := gs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gs *GoodsSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := gs.sql.Query() diff --git a/entc/integration/ent/group_query.go b/entc/integration/ent/group_query.go index ae745beb7d..20a94c5c91 100644 --- a/entc/integration/ent/group_query.go +++ b/entc/integration/ent/group_query.go @@ -442,7 +442,10 @@ func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy { // func (gq *GroupQuery) Select(fields ...string) *GroupSelect { gq.fields = append(gq.fields, fields...) - return &GroupSelect{GroupQuery: gq} + sel := &GroupSelect{GroupQuery: gq} + sel.typ, sel.label = "Group", group.Label + sel.flds, sel.scan = &gq.fields, sel.Scan + return sel } func (gq *GroupQuery) prepareQuery(ctx context.Context) error { @@ -1062,6 +1065,7 @@ func (ggb *GroupGroupBy) sqlQuery() *sql.Selector { // GroupSelect is the builder for selecting fields of Group entities. type GroupSelect struct { *GroupQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -1075,201 +1079,6 @@ func (gs *GroupSelect) Scan(ctx context.Context, v interface{}) error { return gs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gs *GroupSelect) ScanX(ctx context.Context, v interface{}) { - if err := gs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Strings(ctx context.Context) ([]string, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gs *GroupSelect) StringsX(ctx context.Context) []string { - v, err := gs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gs *GroupSelect) StringX(ctx context.Context) string { - v, err := gs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Ints(ctx context.Context) ([]int, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gs *GroupSelect) IntsX(ctx context.Context) []int { - v, err := gs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gs *GroupSelect) IntX(ctx context.Context) int { - v, err := gs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gs *GroupSelect) Float64sX(ctx context.Context) []float64 { - v, err := gs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gs *GroupSelect) Float64X(ctx context.Context) float64 { - v, err := gs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gs *GroupSelect) BoolsX(ctx context.Context) []bool { - v, err := gs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gs *GroupSelect) BoolX(ctx context.Context) bool { - v, err := gs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gs *GroupSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := gs.sql.Query() diff --git a/entc/integration/ent/groupinfo_query.go b/entc/integration/ent/groupinfo_query.go index 22e5b97b10..b275ea02b4 100644 --- a/entc/integration/ent/groupinfo_query.go +++ b/entc/integration/ent/groupinfo_query.go @@ -334,7 +334,10 @@ func (giq *GroupInfoQuery) GroupBy(field string, fields ...string) *GroupInfoGro // func (giq *GroupInfoQuery) Select(fields ...string) *GroupInfoSelect { giq.fields = append(giq.fields, fields...) - return &GroupInfoSelect{GroupInfoQuery: giq} + sel := &GroupInfoSelect{GroupInfoQuery: giq} + sel.typ, sel.label = "GroupInfo", groupinfo.Label + sel.flds, sel.scan = &giq.fields, sel.Scan + return sel } func (giq *GroupInfoQuery) prepareQuery(ctx context.Context) error { @@ -821,6 +824,7 @@ func (gigb *GroupInfoGroupBy) sqlQuery() *sql.Selector { // GroupInfoSelect is the builder for selecting fields of GroupInfo entities. type GroupInfoSelect struct { *GroupInfoQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -834,201 +838,6 @@ func (gis *GroupInfoSelect) Scan(ctx context.Context, v interface{}) error { return gis.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gis *GroupInfoSelect) ScanX(ctx context.Context, v interface{}) { - if err := gis.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Strings(ctx context.Context) ([]string, error) { - if len(gis.fields) > 1 { - return nil, errors.New("ent: GroupInfoSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gis.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gis *GroupInfoSelect) StringsX(ctx context.Context) []string { - v, err := gis.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gis.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{groupinfo.Label} - default: - err = fmt.Errorf("ent: GroupInfoSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gis *GroupInfoSelect) StringX(ctx context.Context) string { - v, err := gis.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Ints(ctx context.Context) ([]int, error) { - if len(gis.fields) > 1 { - return nil, errors.New("ent: GroupInfoSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gis.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gis *GroupInfoSelect) IntsX(ctx context.Context) []int { - v, err := gis.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gis.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{groupinfo.Label} - default: - err = fmt.Errorf("ent: GroupInfoSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gis *GroupInfoSelect) IntX(ctx context.Context) int { - v, err := gis.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gis.fields) > 1 { - return nil, errors.New("ent: GroupInfoSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gis.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gis *GroupInfoSelect) Float64sX(ctx context.Context) []float64 { - v, err := gis.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gis.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{groupinfo.Label} - default: - err = fmt.Errorf("ent: GroupInfoSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gis *GroupInfoSelect) Float64X(ctx context.Context) float64 { - v, err := gis.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gis.fields) > 1 { - return nil, errors.New("ent: GroupInfoSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gis.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gis *GroupInfoSelect) BoolsX(ctx context.Context) []bool { - v, err := gis.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gis.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{groupinfo.Label} - default: - err = fmt.Errorf("ent: GroupInfoSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gis *GroupInfoSelect) BoolX(ctx context.Context) bool { - v, err := gis.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gis *GroupInfoSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := gis.sql.Query() diff --git a/entc/integration/ent/item_query.go b/entc/integration/ent/item_query.go index 3a7f97c4d1..e81b60feec 100644 --- a/entc/integration/ent/item_query.go +++ b/entc/integration/ent/item_query.go @@ -296,7 +296,10 @@ func (iq *ItemQuery) GroupBy(field string, fields ...string) *ItemGroupBy { // func (iq *ItemQuery) Select(fields ...string) *ItemSelect { iq.fields = append(iq.fields, fields...) - return &ItemSelect{ItemQuery: iq} + sel := &ItemSelect{ItemQuery: iq} + sel.typ, sel.label = "Item", item.Label + sel.flds, sel.scan = &iq.fields, sel.Scan + return sel } func (iq *ItemQuery) prepareQuery(ctx context.Context) error { @@ -749,6 +752,7 @@ func (igb *ItemGroupBy) sqlQuery() *sql.Selector { // ItemSelect is the builder for selecting fields of Item entities. type ItemSelect struct { *ItemQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -762,201 +766,6 @@ func (is *ItemSelect) Scan(ctx context.Context, v interface{}) error { return is.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (is *ItemSelect) ScanX(ctx context.Context, v interface{}) { - if err := is.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Strings(ctx context.Context) ([]string, error) { - if len(is.fields) > 1 { - return nil, errors.New("ent: ItemSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := is.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (is *ItemSelect) StringsX(ctx context.Context) []string { - v, err := is.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = is.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{item.Label} - default: - err = fmt.Errorf("ent: ItemSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (is *ItemSelect) StringX(ctx context.Context) string { - v, err := is.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Ints(ctx context.Context) ([]int, error) { - if len(is.fields) > 1 { - return nil, errors.New("ent: ItemSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := is.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (is *ItemSelect) IntsX(ctx context.Context) []int { - v, err := is.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = is.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{item.Label} - default: - err = fmt.Errorf("ent: ItemSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (is *ItemSelect) IntX(ctx context.Context) int { - v, err := is.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(is.fields) > 1 { - return nil, errors.New("ent: ItemSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := is.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (is *ItemSelect) Float64sX(ctx context.Context) []float64 { - v, err := is.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = is.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{item.Label} - default: - err = fmt.Errorf("ent: ItemSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (is *ItemSelect) Float64X(ctx context.Context) float64 { - v, err := is.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Bools(ctx context.Context) ([]bool, error) { - if len(is.fields) > 1 { - return nil, errors.New("ent: ItemSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := is.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (is *ItemSelect) BoolsX(ctx context.Context) []bool { - v, err := is.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = is.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{item.Label} - default: - err = fmt.Errorf("ent: ItemSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (is *ItemSelect) BoolX(ctx context.Context) bool { - v, err := is.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (is *ItemSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := is.sql.Query() diff --git a/entc/integration/ent/node_query.go b/entc/integration/ent/node_query.go index 4259ae939e..73c725dabd 100644 --- a/entc/integration/ent/node_query.go +++ b/entc/integration/ent/node_query.go @@ -369,7 +369,10 @@ func (nq *NodeQuery) GroupBy(field string, fields ...string) *NodeGroupBy { // func (nq *NodeQuery) Select(fields ...string) *NodeSelect { nq.fields = append(nq.fields, fields...) - return &NodeSelect{NodeQuery: nq} + sel := &NodeSelect{NodeQuery: nq} + sel.typ, sel.label = "Node", node.Label + sel.flds, sel.scan = &nq.fields, sel.Scan + return sel } func (nq *NodeQuery) prepareQuery(ctx context.Context) error { @@ -892,6 +895,7 @@ func (ngb *NodeGroupBy) sqlQuery() *sql.Selector { // NodeSelect is the builder for selecting fields of Node entities. type NodeSelect struct { *NodeQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -905,201 +909,6 @@ func (ns *NodeSelect) Scan(ctx context.Context, v interface{}) error { return ns.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ns *NodeSelect) ScanX(ctx context.Context, v interface{}) { - if err := ns.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Strings(ctx context.Context) ([]string, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ns *NodeSelect) StringsX(ctx context.Context) []string { - v, err := ns.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ns.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ns *NodeSelect) StringX(ctx context.Context) string { - v, err := ns.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Ints(ctx context.Context) ([]int, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ns *NodeSelect) IntsX(ctx context.Context) []int { - v, err := ns.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ns.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ns *NodeSelect) IntX(ctx context.Context) int { - v, err := ns.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ns *NodeSelect) Float64sX(ctx context.Context) []float64 { - v, err := ns.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ns.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ns *NodeSelect) Float64X(ctx context.Context) float64 { - v, err := ns.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ns *NodeSelect) BoolsX(ctx context.Context) []bool { - v, err := ns.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ns.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ns *NodeSelect) BoolX(ctx context.Context) bool { - v, err := ns.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ns *NodeSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ns.sql.Query() diff --git a/entc/integration/ent/pet_query.go b/entc/integration/ent/pet_query.go index 11a9406e4a..407e7dc735 100644 --- a/entc/integration/ent/pet_query.go +++ b/entc/integration/ent/pet_query.go @@ -369,7 +369,10 @@ func (pq *PetQuery) GroupBy(field string, fields ...string) *PetGroupBy { // func (pq *PetQuery) Select(fields ...string) *PetSelect { pq.fields = append(pq.fields, fields...) - return &PetSelect{PetQuery: pq} + sel := &PetSelect{PetQuery: pq} + sel.typ, sel.label = "Pet", pet.Label + sel.flds, sel.scan = &pq.fields, sel.Scan + return sel } func (pq *PetQuery) prepareQuery(ctx context.Context) error { @@ -893,6 +896,7 @@ func (pgb *PetGroupBy) sqlQuery() *sql.Selector { // PetSelect is the builder for selecting fields of Pet entities. type PetSelect struct { *PetQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -906,201 +910,6 @@ func (ps *PetSelect) Scan(ctx context.Context, v interface{}) error { return ps.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ps *PetSelect) ScanX(ctx context.Context, v interface{}) { - if err := ps.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Strings(ctx context.Context) ([]string, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ps *PetSelect) StringsX(ctx context.Context) []string { - v, err := ps.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ps.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ps *PetSelect) StringX(ctx context.Context) string { - v, err := ps.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Ints(ctx context.Context) ([]int, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ps *PetSelect) IntsX(ctx context.Context) []int { - v, err := ps.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ps.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ps *PetSelect) IntX(ctx context.Context) int { - v, err := ps.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ps *PetSelect) Float64sX(ctx context.Context) []float64 { - v, err := ps.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ps.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ps *PetSelect) Float64X(ctx context.Context) float64 { - v, err := ps.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ps *PetSelect) BoolsX(ctx context.Context) []bool { - v, err := ps.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ps.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ps *PetSelect) BoolX(ctx context.Context) bool { - v, err := ps.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ps *PetSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ps.sql.Query() diff --git a/entc/integration/ent/spec_query.go b/entc/integration/ent/spec_query.go index eacde981b6..3beb75b4d1 100644 --- a/entc/integration/ent/spec_query.go +++ b/entc/integration/ent/spec_query.go @@ -310,7 +310,10 @@ func (sq *SpecQuery) GroupBy(field string, fields ...string) *SpecGroupBy { // instead of selecting all fields in the entity. func (sq *SpecQuery) Select(fields ...string) *SpecSelect { sq.fields = append(sq.fields, fields...) - return &SpecSelect{SpecQuery: sq} + sel := &SpecSelect{SpecQuery: sq} + sel.typ, sel.label = "Spec", spec.Label + sel.flds, sel.scan = &sq.fields, sel.Scan + return sel } func (sq *SpecQuery) prepareQuery(ctx context.Context) error { @@ -833,6 +836,7 @@ func (sgb *SpecGroupBy) sqlQuery() *sql.Selector { // SpecSelect is the builder for selecting fields of Spec entities. type SpecSelect struct { *SpecQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -846,201 +850,6 @@ func (ss *SpecSelect) Scan(ctx context.Context, v interface{}) error { return ss.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ss *SpecSelect) ScanX(ctx context.Context, v interface{}) { - if err := ss.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Strings(ctx context.Context) ([]string, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: SpecSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ss *SpecSelect) StringsX(ctx context.Context) []string { - v, err := ss.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ss.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{spec.Label} - default: - err = fmt.Errorf("ent: SpecSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ss *SpecSelect) StringX(ctx context.Context) string { - v, err := ss.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Ints(ctx context.Context) ([]int, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: SpecSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ss *SpecSelect) IntsX(ctx context.Context) []int { - v, err := ss.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ss.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{spec.Label} - default: - err = fmt.Errorf("ent: SpecSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ss *SpecSelect) IntX(ctx context.Context) int { - v, err := ss.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: SpecSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ss *SpecSelect) Float64sX(ctx context.Context) []float64 { - v, err := ss.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ss.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{spec.Label} - default: - err = fmt.Errorf("ent: SpecSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ss *SpecSelect) Float64X(ctx context.Context) float64 { - v, err := ss.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: SpecSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ss *SpecSelect) BoolsX(ctx context.Context) []bool { - v, err := ss.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ss.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{spec.Label} - default: - err = fmt.Errorf("ent: SpecSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ss *SpecSelect) BoolX(ctx context.Context) bool { - v, err := ss.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ss *SpecSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ss.sql.Query() diff --git a/entc/integration/ent/task_query.go b/entc/integration/ent/task_query.go index c3d8fae0ee..a28165efc7 100644 --- a/entc/integration/ent/task_query.go +++ b/entc/integration/ent/task_query.go @@ -297,7 +297,10 @@ func (tq *TaskQuery) GroupBy(field string, fields ...string) *TaskGroupBy { // func (tq *TaskQuery) Select(fields ...string) *TaskSelect { tq.fields = append(tq.fields, fields...) - return &TaskSelect{TaskQuery: tq} + sel := &TaskSelect{TaskQuery: tq} + sel.typ, sel.label = "Task", enttask.Label + sel.flds, sel.scan = &tq.fields, sel.Scan + return sel } func (tq *TaskQuery) prepareQuery(ctx context.Context) error { @@ -750,6 +753,7 @@ func (tgb *TaskGroupBy) sqlQuery() *sql.Selector { // TaskSelect is the builder for selecting fields of Task entities. type TaskSelect struct { *TaskQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -763,201 +767,6 @@ func (ts *TaskSelect) Scan(ctx context.Context, v interface{}) error { return ts.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ts *TaskSelect) ScanX(ctx context.Context, v interface{}) { - if err := ts.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Strings(ctx context.Context) ([]string, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TaskSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ts *TaskSelect) StringsX(ctx context.Context) []string { - v, err := ts.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ts.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{enttask.Label} - default: - err = fmt.Errorf("ent: TaskSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ts *TaskSelect) StringX(ctx context.Context) string { - v, err := ts.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Ints(ctx context.Context) ([]int, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TaskSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ts *TaskSelect) IntsX(ctx context.Context) []int { - v, err := ts.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ts.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{enttask.Label} - default: - err = fmt.Errorf("ent: TaskSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ts *TaskSelect) IntX(ctx context.Context) int { - v, err := ts.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TaskSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ts *TaskSelect) Float64sX(ctx context.Context) []float64 { - v, err := ts.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ts.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{enttask.Label} - default: - err = fmt.Errorf("ent: TaskSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ts *TaskSelect) Float64X(ctx context.Context) float64 { - v, err := ts.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TaskSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ts *TaskSelect) BoolsX(ctx context.Context) []bool { - v, err := ts.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ts.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{enttask.Label} - default: - err = fmt.Errorf("ent: TaskSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ts *TaskSelect) BoolX(ctx context.Context) bool { - v, err := ts.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ts *TaskSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ts.sql.Query() diff --git a/entc/integration/ent/user_query.go b/entc/integration/ent/user_query.go index b2a39730e0..3c40358a48 100644 --- a/entc/integration/ent/user_query.go +++ b/entc/integration/ent/user_query.go @@ -688,7 +688,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -1624,6 +1627,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -1637,201 +1641,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/entc/integration/gremlin/ent/card_query.go b/entc/integration/gremlin/ent/card_query.go index 834a5c1c82..225f120ce6 100644 --- a/entc/integration/gremlin/ent/card_query.go +++ b/entc/integration/gremlin/ent/card_query.go @@ -352,7 +352,10 @@ func (cq *CardQuery) GroupBy(field string, fields ...string) *CardGroupBy { // func (cq *CardQuery) Select(fields ...string) *CardSelect { cq.fields = append(cq.fields, fields...) - return &CardSelect{CardQuery: cq} + sel := &CardSelect{CardQuery: cq} + sel.typ, sel.label = "Card", card.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CardQuery) prepareQuery(ctx context.Context) error { @@ -705,6 +708,7 @@ func (cgb *CardGroupBy) gremlinQuery() *dsl.Traversal { // CardSelect is the builder for selecting fields of Card entities. type CardSelect struct { *CardQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -718,201 +722,6 @@ func (cs *CardSelect) Scan(ctx context.Context, v interface{}) error { return cs.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CardSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CardSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CardSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CardSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CardSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CardSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CardSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CardSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CardSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CardSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/gremlin/ent/comment_query.go b/entc/integration/gremlin/ent/comment_query.go index 3b2f03d150..b476da9712 100644 --- a/entc/integration/gremlin/ent/comment_query.go +++ b/entc/integration/gremlin/ent/comment_query.go @@ -295,7 +295,10 @@ func (cq *CommentQuery) GroupBy(field string, fields ...string) *CommentGroupBy // func (cq *CommentQuery) Select(fields ...string) *CommentSelect { cq.fields = append(cq.fields, fields...) - return &CommentSelect{CommentQuery: cq} + sel := &CommentSelect{CommentQuery: cq} + sel.typ, sel.label = "Comment", comment.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CommentQuery) prepareQuery(ctx context.Context) error { @@ -648,6 +651,7 @@ func (cgb *CommentGroupBy) gremlinQuery() *dsl.Traversal { // CommentSelect is the builder for selecting fields of Comment entities. type CommentSelect struct { *CommentQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -661,201 +665,6 @@ func (cs *CommentSelect) Scan(ctx context.Context, v interface{}) error { return cs.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CommentSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CommentSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CommentSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{comment.Label} - default: - err = fmt.Errorf("ent: CommentSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CommentSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CommentSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CommentSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{comment.Label} - default: - err = fmt.Errorf("ent: CommentSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CommentSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CommentSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CommentSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{comment.Label} - default: - err = fmt.Errorf("ent: CommentSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CommentSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CommentSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CommentSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CommentSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{comment.Label} - default: - err = fmt.Errorf("ent: CommentSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CommentSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CommentSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/gremlin/ent/ent.go b/entc/integration/gremlin/ent/ent.go index 898d3bf423..ac77a90cfa 100644 --- a/entc/integration/gremlin/ent/ent.go +++ b/entc/integration/gremlin/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" "strconv" @@ -266,6 +267,208 @@ func IsConstraintError(err error) bool { return errors.As(err, &e) } +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} + // Code implements the dsl.Node interface. func (e ConstraintError) Code() (string, []interface{}) { return strconv.Quote(e.prefix() + e.msg), nil diff --git a/entc/integration/gremlin/ent/fieldtype_query.go b/entc/integration/gremlin/ent/fieldtype_query.go index 39ab1e739a..a15046fb42 100644 --- a/entc/integration/gremlin/ent/fieldtype_query.go +++ b/entc/integration/gremlin/ent/fieldtype_query.go @@ -295,7 +295,10 @@ func (ftq *FieldTypeQuery) GroupBy(field string, fields ...string) *FieldTypeGro // func (ftq *FieldTypeQuery) Select(fields ...string) *FieldTypeSelect { ftq.fields = append(ftq.fields, fields...) - return &FieldTypeSelect{FieldTypeQuery: ftq} + sel := &FieldTypeSelect{FieldTypeQuery: ftq} + sel.typ, sel.label = "FieldType", fieldtype.Label + sel.flds, sel.scan = &ftq.fields, sel.Scan + return sel } func (ftq *FieldTypeQuery) prepareQuery(ctx context.Context) error { @@ -648,6 +651,7 @@ func (ftgb *FieldTypeGroupBy) gremlinQuery() *dsl.Traversal { // FieldTypeSelect is the builder for selecting fields of FieldType entities. type FieldTypeSelect struct { *FieldTypeQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -661,201 +665,6 @@ func (fts *FieldTypeSelect) Scan(ctx context.Context, v interface{}) error { return fts.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (fts *FieldTypeSelect) ScanX(ctx context.Context, v interface{}) { - if err := fts.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Strings(ctx context.Context) ([]string, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FieldTypeSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (fts *FieldTypeSelect) StringsX(ctx context.Context) []string { - v, err := fts.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = fts.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{fieldtype.Label} - default: - err = fmt.Errorf("ent: FieldTypeSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (fts *FieldTypeSelect) StringX(ctx context.Context) string { - v, err := fts.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Ints(ctx context.Context) ([]int, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FieldTypeSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (fts *FieldTypeSelect) IntsX(ctx context.Context) []int { - v, err := fts.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = fts.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{fieldtype.Label} - default: - err = fmt.Errorf("ent: FieldTypeSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (fts *FieldTypeSelect) IntX(ctx context.Context) int { - v, err := fts.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FieldTypeSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (fts *FieldTypeSelect) Float64sX(ctx context.Context) []float64 { - v, err := fts.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = fts.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{fieldtype.Label} - default: - err = fmt.Errorf("ent: FieldTypeSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (fts *FieldTypeSelect) Float64X(ctx context.Context) float64 { - v, err := fts.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Bools(ctx context.Context) ([]bool, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FieldTypeSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (fts *FieldTypeSelect) BoolsX(ctx context.Context) []bool { - v, err := fts.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (fts *FieldTypeSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = fts.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{fieldtype.Label} - default: - err = fmt.Errorf("ent: FieldTypeSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (fts *FieldTypeSelect) BoolX(ctx context.Context) bool { - v, err := fts.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (fts *FieldTypeSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/gremlin/ent/file_query.go b/entc/integration/gremlin/ent/file_query.go index 8c35e695c8..8d2e746525 100644 --- a/entc/integration/gremlin/ent/file_query.go +++ b/entc/integration/gremlin/ent/file_query.go @@ -379,7 +379,10 @@ func (fq *FileQuery) GroupBy(field string, fields ...string) *FileGroupBy { // func (fq *FileQuery) Select(fields ...string) *FileSelect { fq.fields = append(fq.fields, fields...) - return &FileSelect{FileQuery: fq} + sel := &FileSelect{FileQuery: fq} + sel.typ, sel.label = "File", file.Label + sel.flds, sel.scan = &fq.fields, sel.Scan + return sel } func (fq *FileQuery) prepareQuery(ctx context.Context) error { @@ -732,6 +735,7 @@ func (fgb *FileGroupBy) gremlinQuery() *dsl.Traversal { // FileSelect is the builder for selecting fields of File entities. type FileSelect struct { *FileQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -745,201 +749,6 @@ func (fs *FileSelect) Scan(ctx context.Context, v interface{}) error { return fs.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (fs *FileSelect) ScanX(ctx context.Context, v interface{}) { - if err := fs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Strings(ctx context.Context) ([]string, error) { - if len(fs.fields) > 1 { - return nil, errors.New("ent: FileSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := fs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (fs *FileSelect) StringsX(ctx context.Context) []string { - v, err := fs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = fs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{file.Label} - default: - err = fmt.Errorf("ent: FileSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (fs *FileSelect) StringX(ctx context.Context) string { - v, err := fs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Ints(ctx context.Context) ([]int, error) { - if len(fs.fields) > 1 { - return nil, errors.New("ent: FileSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := fs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (fs *FileSelect) IntsX(ctx context.Context) []int { - v, err := fs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = fs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{file.Label} - default: - err = fmt.Errorf("ent: FileSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (fs *FileSelect) IntX(ctx context.Context) int { - v, err := fs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(fs.fields) > 1 { - return nil, errors.New("ent: FileSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := fs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (fs *FileSelect) Float64sX(ctx context.Context) []float64 { - v, err := fs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = fs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{file.Label} - default: - err = fmt.Errorf("ent: FileSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (fs *FileSelect) Float64X(ctx context.Context) float64 { - v, err := fs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Bools(ctx context.Context) ([]bool, error) { - if len(fs.fields) > 1 { - return nil, errors.New("ent: FileSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := fs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (fs *FileSelect) BoolsX(ctx context.Context) []bool { - v, err := fs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = fs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{file.Label} - default: - err = fmt.Errorf("ent: FileSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (fs *FileSelect) BoolX(ctx context.Context) bool { - v, err := fs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (fs *FileSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/gremlin/ent/filetype_query.go b/entc/integration/gremlin/ent/filetype_query.go index 52714645ff..b3f7c069ba 100644 --- a/entc/integration/gremlin/ent/filetype_query.go +++ b/entc/integration/gremlin/ent/filetype_query.go @@ -323,7 +323,10 @@ func (ftq *FileTypeQuery) GroupBy(field string, fields ...string) *FileTypeGroup // func (ftq *FileTypeQuery) Select(fields ...string) *FileTypeSelect { ftq.fields = append(ftq.fields, fields...) - return &FileTypeSelect{FileTypeQuery: ftq} + sel := &FileTypeSelect{FileTypeQuery: ftq} + sel.typ, sel.label = "FileType", filetype.Label + sel.flds, sel.scan = &ftq.fields, sel.Scan + return sel } func (ftq *FileTypeQuery) prepareQuery(ctx context.Context) error { @@ -676,6 +679,7 @@ func (ftgb *FileTypeGroupBy) gremlinQuery() *dsl.Traversal { // FileTypeSelect is the builder for selecting fields of FileType entities. type FileTypeSelect struct { *FileTypeQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -689,201 +693,6 @@ func (fts *FileTypeSelect) Scan(ctx context.Context, v interface{}) error { return fts.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (fts *FileTypeSelect) ScanX(ctx context.Context, v interface{}) { - if err := fts.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Strings(ctx context.Context) ([]string, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FileTypeSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (fts *FileTypeSelect) StringsX(ctx context.Context) []string { - v, err := fts.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = fts.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{filetype.Label} - default: - err = fmt.Errorf("ent: FileTypeSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (fts *FileTypeSelect) StringX(ctx context.Context) string { - v, err := fts.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Ints(ctx context.Context) ([]int, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FileTypeSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (fts *FileTypeSelect) IntsX(ctx context.Context) []int { - v, err := fts.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = fts.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{filetype.Label} - default: - err = fmt.Errorf("ent: FileTypeSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (fts *FileTypeSelect) IntX(ctx context.Context) int { - v, err := fts.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FileTypeSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (fts *FileTypeSelect) Float64sX(ctx context.Context) []float64 { - v, err := fts.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = fts.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{filetype.Label} - default: - err = fmt.Errorf("ent: FileTypeSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (fts *FileTypeSelect) Float64X(ctx context.Context) float64 { - v, err := fts.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Bools(ctx context.Context) ([]bool, error) { - if len(fts.fields) > 1 { - return nil, errors.New("ent: FileTypeSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := fts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (fts *FileTypeSelect) BoolsX(ctx context.Context) []bool { - v, err := fts.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (fts *FileTypeSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = fts.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{filetype.Label} - default: - err = fmt.Errorf("ent: FileTypeSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (fts *FileTypeSelect) BoolX(ctx context.Context) bool { - v, err := fts.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (fts *FileTypeSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/gremlin/ent/goods_query.go b/entc/integration/gremlin/ent/goods_query.go index c848a461b8..d91cce9d89 100644 --- a/entc/integration/gremlin/ent/goods_query.go +++ b/entc/integration/gremlin/ent/goods_query.go @@ -271,7 +271,10 @@ func (gq *GoodsQuery) GroupBy(field string, fields ...string) *GoodsGroupBy { // instead of selecting all fields in the entity. func (gq *GoodsQuery) Select(fields ...string) *GoodsSelect { gq.fields = append(gq.fields, fields...) - return &GoodsSelect{GoodsQuery: gq} + sel := &GoodsSelect{GoodsQuery: gq} + sel.typ, sel.label = "Goods", goods.Label + sel.flds, sel.scan = &gq.fields, sel.Scan + return sel } func (gq *GoodsQuery) prepareQuery(ctx context.Context) error { @@ -624,6 +627,7 @@ func (ggb *GoodsGroupBy) gremlinQuery() *dsl.Traversal { // GoodsSelect is the builder for selecting fields of Goods entities. type GoodsSelect struct { *GoodsQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -637,201 +641,6 @@ func (gs *GoodsSelect) Scan(ctx context.Context, v interface{}) error { return gs.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gs *GoodsSelect) ScanX(ctx context.Context, v interface{}) { - if err := gs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Strings(ctx context.Context) ([]string, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GoodsSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gs *GoodsSelect) StringsX(ctx context.Context) []string { - v, err := gs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{goods.Label} - default: - err = fmt.Errorf("ent: GoodsSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gs *GoodsSelect) StringX(ctx context.Context) string { - v, err := gs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Ints(ctx context.Context) ([]int, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GoodsSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gs *GoodsSelect) IntsX(ctx context.Context) []int { - v, err := gs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{goods.Label} - default: - err = fmt.Errorf("ent: GoodsSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gs *GoodsSelect) IntX(ctx context.Context) int { - v, err := gs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GoodsSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gs *GoodsSelect) Float64sX(ctx context.Context) []float64 { - v, err := gs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{goods.Label} - default: - err = fmt.Errorf("ent: GoodsSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gs *GoodsSelect) Float64X(ctx context.Context) float64 { - v, err := gs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GoodsSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gs *GoodsSelect) BoolsX(ctx context.Context) []bool { - v, err := gs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gs *GoodsSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{goods.Label} - default: - err = fmt.Errorf("ent: GoodsSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gs *GoodsSelect) BoolX(ctx context.Context) bool { - v, err := gs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gs *GoodsSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/gremlin/ent/group_query.go b/entc/integration/gremlin/ent/group_query.go index 9da557ae03..586373cb1a 100644 --- a/entc/integration/gremlin/ent/group_query.go +++ b/entc/integration/gremlin/ent/group_query.go @@ -405,7 +405,10 @@ func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy { // func (gq *GroupQuery) Select(fields ...string) *GroupSelect { gq.fields = append(gq.fields, fields...) - return &GroupSelect{GroupQuery: gq} + sel := &GroupSelect{GroupQuery: gq} + sel.typ, sel.label = "Group", group.Label + sel.flds, sel.scan = &gq.fields, sel.Scan + return sel } func (gq *GroupQuery) prepareQuery(ctx context.Context) error { @@ -758,6 +761,7 @@ func (ggb *GroupGroupBy) gremlinQuery() *dsl.Traversal { // GroupSelect is the builder for selecting fields of Group entities. type GroupSelect struct { *GroupQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -771,201 +775,6 @@ func (gs *GroupSelect) Scan(ctx context.Context, v interface{}) error { return gs.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gs *GroupSelect) ScanX(ctx context.Context, v interface{}) { - if err := gs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Strings(ctx context.Context) ([]string, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gs *GroupSelect) StringsX(ctx context.Context) []string { - v, err := gs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gs *GroupSelect) StringX(ctx context.Context) string { - v, err := gs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Ints(ctx context.Context) ([]int, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gs *GroupSelect) IntsX(ctx context.Context) []int { - v, err := gs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gs *GroupSelect) IntX(ctx context.Context) int { - v, err := gs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gs *GroupSelect) Float64sX(ctx context.Context) []float64 { - v, err := gs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gs *GroupSelect) Float64X(ctx context.Context) float64 { - v, err := gs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gs *GroupSelect) BoolsX(ctx context.Context) []bool { - v, err := gs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gs *GroupSelect) BoolX(ctx context.Context) bool { - v, err := gs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gs *GroupSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/gremlin/ent/groupinfo_query.go b/entc/integration/gremlin/ent/groupinfo_query.go index 927763ecbe..7c9a330324 100644 --- a/entc/integration/gremlin/ent/groupinfo_query.go +++ b/entc/integration/gremlin/ent/groupinfo_query.go @@ -324,7 +324,10 @@ func (giq *GroupInfoQuery) GroupBy(field string, fields ...string) *GroupInfoGro // func (giq *GroupInfoQuery) Select(fields ...string) *GroupInfoSelect { giq.fields = append(giq.fields, fields...) - return &GroupInfoSelect{GroupInfoQuery: giq} + sel := &GroupInfoSelect{GroupInfoQuery: giq} + sel.typ, sel.label = "GroupInfo", groupinfo.Label + sel.flds, sel.scan = &giq.fields, sel.Scan + return sel } func (giq *GroupInfoQuery) prepareQuery(ctx context.Context) error { @@ -677,6 +680,7 @@ func (gigb *GroupInfoGroupBy) gremlinQuery() *dsl.Traversal { // GroupInfoSelect is the builder for selecting fields of GroupInfo entities. type GroupInfoSelect struct { *GroupInfoQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -690,201 +694,6 @@ func (gis *GroupInfoSelect) Scan(ctx context.Context, v interface{}) error { return gis.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gis *GroupInfoSelect) ScanX(ctx context.Context, v interface{}) { - if err := gis.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Strings(ctx context.Context) ([]string, error) { - if len(gis.fields) > 1 { - return nil, errors.New("ent: GroupInfoSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gis.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gis *GroupInfoSelect) StringsX(ctx context.Context) []string { - v, err := gis.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gis.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{groupinfo.Label} - default: - err = fmt.Errorf("ent: GroupInfoSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gis *GroupInfoSelect) StringX(ctx context.Context) string { - v, err := gis.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Ints(ctx context.Context) ([]int, error) { - if len(gis.fields) > 1 { - return nil, errors.New("ent: GroupInfoSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gis.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gis *GroupInfoSelect) IntsX(ctx context.Context) []int { - v, err := gis.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gis.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{groupinfo.Label} - default: - err = fmt.Errorf("ent: GroupInfoSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gis *GroupInfoSelect) IntX(ctx context.Context) int { - v, err := gis.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gis.fields) > 1 { - return nil, errors.New("ent: GroupInfoSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gis.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gis *GroupInfoSelect) Float64sX(ctx context.Context) []float64 { - v, err := gis.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gis.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{groupinfo.Label} - default: - err = fmt.Errorf("ent: GroupInfoSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gis *GroupInfoSelect) Float64X(ctx context.Context) float64 { - v, err := gis.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gis.fields) > 1 { - return nil, errors.New("ent: GroupInfoSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gis.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gis *GroupInfoSelect) BoolsX(ctx context.Context) []bool { - v, err := gis.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gis *GroupInfoSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gis.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{groupinfo.Label} - default: - err = fmt.Errorf("ent: GroupInfoSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gis *GroupInfoSelect) BoolX(ctx context.Context) bool { - v, err := gis.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gis *GroupInfoSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/gremlin/ent/item_query.go b/entc/integration/gremlin/ent/item_query.go index 16eb160ae1..e6fd0ced2d 100644 --- a/entc/integration/gremlin/ent/item_query.go +++ b/entc/integration/gremlin/ent/item_query.go @@ -295,7 +295,10 @@ func (iq *ItemQuery) GroupBy(field string, fields ...string) *ItemGroupBy { // func (iq *ItemQuery) Select(fields ...string) *ItemSelect { iq.fields = append(iq.fields, fields...) - return &ItemSelect{ItemQuery: iq} + sel := &ItemSelect{ItemQuery: iq} + sel.typ, sel.label = "Item", item.Label + sel.flds, sel.scan = &iq.fields, sel.Scan + return sel } func (iq *ItemQuery) prepareQuery(ctx context.Context) error { @@ -648,6 +651,7 @@ func (igb *ItemGroupBy) gremlinQuery() *dsl.Traversal { // ItemSelect is the builder for selecting fields of Item entities. type ItemSelect struct { *ItemQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -661,201 +665,6 @@ func (is *ItemSelect) Scan(ctx context.Context, v interface{}) error { return is.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (is *ItemSelect) ScanX(ctx context.Context, v interface{}) { - if err := is.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Strings(ctx context.Context) ([]string, error) { - if len(is.fields) > 1 { - return nil, errors.New("ent: ItemSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := is.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (is *ItemSelect) StringsX(ctx context.Context) []string { - v, err := is.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = is.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{item.Label} - default: - err = fmt.Errorf("ent: ItemSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (is *ItemSelect) StringX(ctx context.Context) string { - v, err := is.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Ints(ctx context.Context) ([]int, error) { - if len(is.fields) > 1 { - return nil, errors.New("ent: ItemSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := is.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (is *ItemSelect) IntsX(ctx context.Context) []int { - v, err := is.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = is.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{item.Label} - default: - err = fmt.Errorf("ent: ItemSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (is *ItemSelect) IntX(ctx context.Context) int { - v, err := is.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(is.fields) > 1 { - return nil, errors.New("ent: ItemSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := is.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (is *ItemSelect) Float64sX(ctx context.Context) []float64 { - v, err := is.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = is.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{item.Label} - default: - err = fmt.Errorf("ent: ItemSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (is *ItemSelect) Float64X(ctx context.Context) float64 { - v, err := is.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Bools(ctx context.Context) ([]bool, error) { - if len(is.fields) > 1 { - return nil, errors.New("ent: ItemSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := is.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (is *ItemSelect) BoolsX(ctx context.Context) []bool { - v, err := is.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (is *ItemSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = is.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{item.Label} - default: - err = fmt.Errorf("ent: ItemSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (is *ItemSelect) BoolX(ctx context.Context) bool { - v, err := is.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (is *ItemSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/gremlin/ent/node_query.go b/entc/integration/gremlin/ent/node_query.go index ffd957f1b8..e5db8e369f 100644 --- a/entc/integration/gremlin/ent/node_query.go +++ b/entc/integration/gremlin/ent/node_query.go @@ -350,7 +350,10 @@ func (nq *NodeQuery) GroupBy(field string, fields ...string) *NodeGroupBy { // func (nq *NodeQuery) Select(fields ...string) *NodeSelect { nq.fields = append(nq.fields, fields...) - return &NodeSelect{NodeQuery: nq} + sel := &NodeSelect{NodeQuery: nq} + sel.typ, sel.label = "Node", node.Label + sel.flds, sel.scan = &nq.fields, sel.Scan + return sel } func (nq *NodeQuery) prepareQuery(ctx context.Context) error { @@ -703,6 +706,7 @@ func (ngb *NodeGroupBy) gremlinQuery() *dsl.Traversal { // NodeSelect is the builder for selecting fields of Node entities. type NodeSelect struct { *NodeQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -716,201 +720,6 @@ func (ns *NodeSelect) Scan(ctx context.Context, v interface{}) error { return ns.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ns *NodeSelect) ScanX(ctx context.Context, v interface{}) { - if err := ns.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Strings(ctx context.Context) ([]string, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ns *NodeSelect) StringsX(ctx context.Context) []string { - v, err := ns.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ns.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ns *NodeSelect) StringX(ctx context.Context) string { - v, err := ns.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Ints(ctx context.Context) ([]int, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ns *NodeSelect) IntsX(ctx context.Context) []int { - v, err := ns.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ns.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ns *NodeSelect) IntX(ctx context.Context) int { - v, err := ns.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ns *NodeSelect) Float64sX(ctx context.Context) []float64 { - v, err := ns.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ns.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ns *NodeSelect) Float64X(ctx context.Context) float64 { - v, err := ns.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ns *NodeSelect) BoolsX(ctx context.Context) []bool { - v, err := ns.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ns.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ns *NodeSelect) BoolX(ctx context.Context) bool { - v, err := ns.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ns *NodeSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/gremlin/ent/pet_query.go b/entc/integration/gremlin/ent/pet_query.go index b31a49c434..bed97f583d 100644 --- a/entc/integration/gremlin/ent/pet_query.go +++ b/entc/integration/gremlin/ent/pet_query.go @@ -351,7 +351,10 @@ func (pq *PetQuery) GroupBy(field string, fields ...string) *PetGroupBy { // func (pq *PetQuery) Select(fields ...string) *PetSelect { pq.fields = append(pq.fields, fields...) - return &PetSelect{PetQuery: pq} + sel := &PetSelect{PetQuery: pq} + sel.typ, sel.label = "Pet", pet.Label + sel.flds, sel.scan = &pq.fields, sel.Scan + return sel } func (pq *PetQuery) prepareQuery(ctx context.Context) error { @@ -704,6 +707,7 @@ func (pgb *PetGroupBy) gremlinQuery() *dsl.Traversal { // PetSelect is the builder for selecting fields of Pet entities. type PetSelect struct { *PetQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -717,201 +721,6 @@ func (ps *PetSelect) Scan(ctx context.Context, v interface{}) error { return ps.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ps *PetSelect) ScanX(ctx context.Context, v interface{}) { - if err := ps.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Strings(ctx context.Context) ([]string, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ps *PetSelect) StringsX(ctx context.Context) []string { - v, err := ps.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ps.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ps *PetSelect) StringX(ctx context.Context) string { - v, err := ps.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Ints(ctx context.Context) ([]int, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ps *PetSelect) IntsX(ctx context.Context) []int { - v, err := ps.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ps.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ps *PetSelect) IntX(ctx context.Context) int { - v, err := ps.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ps *PetSelect) Float64sX(ctx context.Context) []float64 { - v, err := ps.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ps.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ps *PetSelect) Float64X(ctx context.Context) float64 { - v, err := ps.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ps *PetSelect) BoolsX(ctx context.Context) []bool { - v, err := ps.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ps.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ps *PetSelect) BoolX(ctx context.Context) bool { - v, err := ps.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ps *PetSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/gremlin/ent/spec_query.go b/entc/integration/gremlin/ent/spec_query.go index 94878a532e..16070ba371 100644 --- a/entc/integration/gremlin/ent/spec_query.go +++ b/entc/integration/gremlin/ent/spec_query.go @@ -299,7 +299,10 @@ func (sq *SpecQuery) GroupBy(field string, fields ...string) *SpecGroupBy { // instead of selecting all fields in the entity. func (sq *SpecQuery) Select(fields ...string) *SpecSelect { sq.fields = append(sq.fields, fields...) - return &SpecSelect{SpecQuery: sq} + sel := &SpecSelect{SpecQuery: sq} + sel.typ, sel.label = "Spec", spec.Label + sel.flds, sel.scan = &sq.fields, sel.Scan + return sel } func (sq *SpecQuery) prepareQuery(ctx context.Context) error { @@ -652,6 +655,7 @@ func (sgb *SpecGroupBy) gremlinQuery() *dsl.Traversal { // SpecSelect is the builder for selecting fields of Spec entities. type SpecSelect struct { *SpecQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -665,201 +669,6 @@ func (ss *SpecSelect) Scan(ctx context.Context, v interface{}) error { return ss.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ss *SpecSelect) ScanX(ctx context.Context, v interface{}) { - if err := ss.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Strings(ctx context.Context) ([]string, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: SpecSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ss *SpecSelect) StringsX(ctx context.Context) []string { - v, err := ss.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ss.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{spec.Label} - default: - err = fmt.Errorf("ent: SpecSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ss *SpecSelect) StringX(ctx context.Context) string { - v, err := ss.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Ints(ctx context.Context) ([]int, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: SpecSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ss *SpecSelect) IntsX(ctx context.Context) []int { - v, err := ss.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ss.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{spec.Label} - default: - err = fmt.Errorf("ent: SpecSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ss *SpecSelect) IntX(ctx context.Context) int { - v, err := ss.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: SpecSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ss *SpecSelect) Float64sX(ctx context.Context) []float64 { - v, err := ss.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ss.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{spec.Label} - default: - err = fmt.Errorf("ent: SpecSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ss *SpecSelect) Float64X(ctx context.Context) float64 { - v, err := ss.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: SpecSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ss *SpecSelect) BoolsX(ctx context.Context) []bool { - v, err := ss.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ss *SpecSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ss.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{spec.Label} - default: - err = fmt.Errorf("ent: SpecSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ss *SpecSelect) BoolX(ctx context.Context) bool { - v, err := ss.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ss *SpecSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/gremlin/ent/task_query.go b/entc/integration/gremlin/ent/task_query.go index 270576c72d..39a4c70f1d 100644 --- a/entc/integration/gremlin/ent/task_query.go +++ b/entc/integration/gremlin/ent/task_query.go @@ -296,7 +296,10 @@ func (tq *TaskQuery) GroupBy(field string, fields ...string) *TaskGroupBy { // func (tq *TaskQuery) Select(fields ...string) *TaskSelect { tq.fields = append(tq.fields, fields...) - return &TaskSelect{TaskQuery: tq} + sel := &TaskSelect{TaskQuery: tq} + sel.typ, sel.label = "Task", enttask.Label + sel.flds, sel.scan = &tq.fields, sel.Scan + return sel } func (tq *TaskQuery) prepareQuery(ctx context.Context) error { @@ -649,6 +652,7 @@ func (tgb *TaskGroupBy) gremlinQuery() *dsl.Traversal { // TaskSelect is the builder for selecting fields of Task entities. type TaskSelect struct { *TaskQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -662,201 +666,6 @@ func (ts *TaskSelect) Scan(ctx context.Context, v interface{}) error { return ts.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ts *TaskSelect) ScanX(ctx context.Context, v interface{}) { - if err := ts.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Strings(ctx context.Context) ([]string, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TaskSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ts *TaskSelect) StringsX(ctx context.Context) []string { - v, err := ts.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ts.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{enttask.Label} - default: - err = fmt.Errorf("ent: TaskSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ts *TaskSelect) StringX(ctx context.Context) string { - v, err := ts.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Ints(ctx context.Context) ([]int, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TaskSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ts *TaskSelect) IntsX(ctx context.Context) []int { - v, err := ts.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ts.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{enttask.Label} - default: - err = fmt.Errorf("ent: TaskSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ts *TaskSelect) IntX(ctx context.Context) int { - v, err := ts.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TaskSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ts *TaskSelect) Float64sX(ctx context.Context) []float64 { - v, err := ts.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ts.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{enttask.Label} - default: - err = fmt.Errorf("ent: TaskSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ts *TaskSelect) Float64X(ctx context.Context) float64 { - v, err := ts.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TaskSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ts *TaskSelect) BoolsX(ctx context.Context) []bool { - v, err := ts.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ts.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{enttask.Label} - default: - err = fmt.Errorf("ent: TaskSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ts *TaskSelect) BoolX(ctx context.Context) bool { - v, err := ts.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ts *TaskSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/gremlin/ent/user_query.go b/entc/integration/gremlin/ent/user_query.go index 9467ce43ac..8051015cb3 100644 --- a/entc/integration/gremlin/ent/user_query.go +++ b/entc/integration/gremlin/ent/user_query.go @@ -593,7 +593,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -946,6 +949,7 @@ func (ugb *UserGroupBy) gremlinQuery() *dsl.Traversal { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). gremlin *dsl.Traversal } @@ -959,201 +963,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.gremlinScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) gremlinScan(ctx context.Context, v interface{}) error { var ( traversal *dsl.Traversal diff --git a/entc/integration/hooks/ent/card_query.go b/entc/integration/hooks/ent/card_query.go index ae9ae0f556..efc59491b9 100644 --- a/entc/integration/hooks/ent/card_query.go +++ b/entc/integration/hooks/ent/card_query.go @@ -332,7 +332,10 @@ func (cq *CardQuery) GroupBy(field string, fields ...string) *CardGroupBy { // func (cq *CardQuery) Select(fields ...string) *CardSelect { cq.fields = append(cq.fields, fields...) - return &CardSelect{CardQuery: cq} + sel := &CardSelect{CardQuery: cq} + sel.typ, sel.label = "Card", card.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CardQuery) prepareQuery(ctx context.Context) error { @@ -785,6 +788,7 @@ func (cgb *CardGroupBy) sqlQuery() *sql.Selector { // CardSelect is the builder for selecting fields of Card entities. type CardSelect struct { *CardQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -798,201 +802,6 @@ func (cs *CardSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CardSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CardSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CardSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CardSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CardSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CardSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CardSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CardSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CardSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CardSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/entc/integration/hooks/ent/ent.go b/entc/integration/hooks/ent/ent.go index 07a4bad5f1..2df7d92aab 100644 --- a/entc/integration/hooks/ent/ent.go +++ b/entc/integration/hooks/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -263,3 +264,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/hooks/ent/user_query.go b/entc/integration/hooks/ent/user_query.go index 59fa9ee0f6..516531ff2c 100644 --- a/entc/integration/hooks/ent/user_query.go +++ b/entc/integration/hooks/ent/user_query.go @@ -403,7 +403,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -952,6 +955,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -965,201 +969,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/entc/integration/idtype/ent/ent.go b/entc/integration/idtype/ent/ent.go index 3950f9d260..7e0d89394c 100644 --- a/entc/integration/idtype/ent/ent.go +++ b/entc/integration/idtype/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -261,3 +262,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/idtype/ent/user_query.go b/entc/integration/idtype/ent/user_query.go index 4454caa9bd..fe5e550e75 100644 --- a/entc/integration/idtype/ent/user_query.go +++ b/entc/integration/idtype/ent/user_query.go @@ -402,7 +402,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -987,6 +990,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -1000,201 +1004,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/entc/integration/json/ent/ent.go b/entc/integration/json/ent/ent.go index 4676bf9b6f..6aa23653ca 100644 --- a/entc/integration/json/ent/ent.go +++ b/entc/integration/json/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -261,3 +262,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/json/ent/user_query.go b/entc/integration/json/ent/user_query.go index c08f917552..32d77cf461 100644 --- a/entc/integration/json/ent/user_query.go +++ b/entc/integration/json/ent/user_query.go @@ -294,7 +294,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -706,6 +709,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -719,201 +723,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/entc/integration/migrate/entv1/car_query.go b/entc/integration/migrate/entv1/car_query.go index 481b4160aa..9fbf0818d8 100644 --- a/entc/integration/migrate/entv1/car_query.go +++ b/entc/integration/migrate/entv1/car_query.go @@ -308,7 +308,10 @@ func (cq *CarQuery) GroupBy(field string, fields ...string) *CarGroupBy { // instead of selecting all fields in the entity. func (cq *CarQuery) Select(fields ...string) *CarSelect { cq.fields = append(cq.fields, fields...) - return &CarSelect{CarQuery: cq} + sel := &CarSelect{CarQuery: cq} + sel.typ, sel.label = "Car", car.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CarQuery) prepareQuery(ctx context.Context) error { @@ -761,6 +764,7 @@ func (cgb *CarGroupBy) sqlQuery() *sql.Selector { // CarSelect is the builder for selecting fields of Car entities. type CarSelect struct { *CarQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -774,201 +778,6 @@ func (cs *CarSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CarSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv1: CarSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CarSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("entv1: CarSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CarSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv1: CarSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CarSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("entv1: CarSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CarSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv1: CarSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CarSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("entv1: CarSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CarSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv1: CarSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CarSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("entv1: CarSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CarSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CarSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/entc/integration/migrate/entv1/conversion_query.go b/entc/integration/migrate/entv1/conversion_query.go index badfa9d93e..9e97a8d911 100644 --- a/entc/integration/migrate/entv1/conversion_query.go +++ b/entc/integration/migrate/entv1/conversion_query.go @@ -294,7 +294,10 @@ func (cq *ConversionQuery) GroupBy(field string, fields ...string) *ConversionGr // func (cq *ConversionQuery) Select(fields ...string) *ConversionSelect { cq.fields = append(cq.fields, fields...) - return &ConversionSelect{ConversionQuery: cq} + sel := &ConversionSelect{ConversionQuery: cq} + sel.typ, sel.label = "Conversion", conversion.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *ConversionQuery) prepareQuery(ctx context.Context) error { @@ -706,6 +709,7 @@ func (cgb *ConversionGroupBy) sqlQuery() *sql.Selector { // ConversionSelect is the builder for selecting fields of Conversion entities. type ConversionSelect struct { *ConversionQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -719,201 +723,6 @@ func (cs *ConversionSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *ConversionSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv1: ConversionSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *ConversionSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{conversion.Label} - default: - err = fmt.Errorf("entv1: ConversionSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *ConversionSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv1: ConversionSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *ConversionSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{conversion.Label} - default: - err = fmt.Errorf("entv1: ConversionSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *ConversionSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv1: ConversionSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *ConversionSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{conversion.Label} - default: - err = fmt.Errorf("entv1: ConversionSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *ConversionSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv1: ConversionSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *ConversionSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{conversion.Label} - default: - err = fmt.Errorf("entv1: ConversionSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *ConversionSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *ConversionSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/entc/integration/migrate/entv1/customtype_query.go b/entc/integration/migrate/entv1/customtype_query.go index 5bb6909fc3..1be26f5188 100644 --- a/entc/integration/migrate/entv1/customtype_query.go +++ b/entc/integration/migrate/entv1/customtype_query.go @@ -294,7 +294,10 @@ func (ctq *CustomTypeQuery) GroupBy(field string, fields ...string) *CustomTypeG // func (ctq *CustomTypeQuery) Select(fields ...string) *CustomTypeSelect { ctq.fields = append(ctq.fields, fields...) - return &CustomTypeSelect{CustomTypeQuery: ctq} + sel := &CustomTypeSelect{CustomTypeQuery: ctq} + sel.typ, sel.label = "CustomType", customtype.Label + sel.flds, sel.scan = &ctq.fields, sel.Scan + return sel } func (ctq *CustomTypeQuery) prepareQuery(ctx context.Context) error { @@ -706,6 +709,7 @@ func (ctgb *CustomTypeGroupBy) sqlQuery() *sql.Selector { // CustomTypeSelect is the builder for selecting fields of CustomType entities. type CustomTypeSelect struct { *CustomTypeQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -719,201 +723,6 @@ func (cts *CustomTypeSelect) Scan(ctx context.Context, v interface{}) error { return cts.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cts *CustomTypeSelect) ScanX(ctx context.Context, v interface{}) { - if err := cts.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Strings(ctx context.Context) ([]string, error) { - if len(cts.fields) > 1 { - return nil, errors.New("entv1: CustomTypeSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cts *CustomTypeSelect) StringsX(ctx context.Context) []string { - v, err := cts.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cts.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{customtype.Label} - default: - err = fmt.Errorf("entv1: CustomTypeSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cts *CustomTypeSelect) StringX(ctx context.Context) string { - v, err := cts.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Ints(ctx context.Context) ([]int, error) { - if len(cts.fields) > 1 { - return nil, errors.New("entv1: CustomTypeSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cts *CustomTypeSelect) IntsX(ctx context.Context) []int { - v, err := cts.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cts.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{customtype.Label} - default: - err = fmt.Errorf("entv1: CustomTypeSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cts *CustomTypeSelect) IntX(ctx context.Context) int { - v, err := cts.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cts.fields) > 1 { - return nil, errors.New("entv1: CustomTypeSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cts *CustomTypeSelect) Float64sX(ctx context.Context) []float64 { - v, err := cts.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cts.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{customtype.Label} - default: - err = fmt.Errorf("entv1: CustomTypeSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cts *CustomTypeSelect) Float64X(ctx context.Context) float64 { - v, err := cts.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cts.fields) > 1 { - return nil, errors.New("entv1: CustomTypeSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cts *CustomTypeSelect) BoolsX(ctx context.Context) []bool { - v, err := cts.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cts.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{customtype.Label} - default: - err = fmt.Errorf("entv1: CustomTypeSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cts *CustomTypeSelect) BoolX(ctx context.Context) bool { - v, err := cts.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cts *CustomTypeSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cts.sql.Query() diff --git a/entc/integration/migrate/entv1/ent.go b/entc/integration/migrate/entv1/ent.go index a06a4b7046..7d4e7600c0 100644 --- a/entc/integration/migrate/entv1/ent.go +++ b/entc/integration/migrate/entv1/ent.go @@ -7,6 +7,7 @@ package entv1 import ( + "context" "errors" "fmt" @@ -267,3 +268,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("entv1: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("entv1: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("entv1: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("entv1: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("entv1: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("entv1: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("entv1: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("entv1: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/migrate/entv1/user_query.go b/entc/integration/migrate/entv1/user_query.go index 6eec60adf8..d251d92663 100644 --- a/entc/integration/migrate/entv1/user_query.go +++ b/entc/integration/migrate/entv1/user_query.go @@ -438,7 +438,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -980,6 +983,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -993,201 +997,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("entv1: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("entv1: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("entv1: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("entv1: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("entv1: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("entv1: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("entv1: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("entv1: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/entc/integration/migrate/entv2/car_query.go b/entc/integration/migrate/entv2/car_query.go index 96e30b523e..26f6f2962b 100644 --- a/entc/integration/migrate/entv2/car_query.go +++ b/entc/integration/migrate/entv2/car_query.go @@ -308,7 +308,10 @@ func (cq *CarQuery) GroupBy(field string, fields ...string) *CarGroupBy { // instead of selecting all fields in the entity. func (cq *CarQuery) Select(fields ...string) *CarSelect { cq.fields = append(cq.fields, fields...) - return &CarSelect{CarQuery: cq} + sel := &CarSelect{CarQuery: cq} + sel.typ, sel.label = "Car", car.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CarQuery) prepareQuery(ctx context.Context) error { @@ -761,6 +764,7 @@ func (cgb *CarGroupBy) sqlQuery() *sql.Selector { // CarSelect is the builder for selecting fields of Car entities. type CarSelect struct { *CarQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -774,201 +778,6 @@ func (cs *CarSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CarSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv2: CarSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CarSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("entv2: CarSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CarSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv2: CarSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CarSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("entv2: CarSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CarSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv2: CarSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CarSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("entv2: CarSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CarSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv2: CarSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CarSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("entv2: CarSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CarSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CarSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/entc/integration/migrate/entv2/conversion_query.go b/entc/integration/migrate/entv2/conversion_query.go index ae32a954c9..c4e3975661 100644 --- a/entc/integration/migrate/entv2/conversion_query.go +++ b/entc/integration/migrate/entv2/conversion_query.go @@ -294,7 +294,10 @@ func (cq *ConversionQuery) GroupBy(field string, fields ...string) *ConversionGr // func (cq *ConversionQuery) Select(fields ...string) *ConversionSelect { cq.fields = append(cq.fields, fields...) - return &ConversionSelect{ConversionQuery: cq} + sel := &ConversionSelect{ConversionQuery: cq} + sel.typ, sel.label = "Conversion", conversion.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *ConversionQuery) prepareQuery(ctx context.Context) error { @@ -706,6 +709,7 @@ func (cgb *ConversionGroupBy) sqlQuery() *sql.Selector { // ConversionSelect is the builder for selecting fields of Conversion entities. type ConversionSelect struct { *ConversionQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -719,201 +723,6 @@ func (cs *ConversionSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *ConversionSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv2: ConversionSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *ConversionSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{conversion.Label} - default: - err = fmt.Errorf("entv2: ConversionSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *ConversionSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv2: ConversionSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *ConversionSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{conversion.Label} - default: - err = fmt.Errorf("entv2: ConversionSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *ConversionSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv2: ConversionSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *ConversionSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{conversion.Label} - default: - err = fmt.Errorf("entv2: ConversionSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *ConversionSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("entv2: ConversionSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *ConversionSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *ConversionSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{conversion.Label} - default: - err = fmt.Errorf("entv2: ConversionSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *ConversionSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *ConversionSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/entc/integration/migrate/entv2/customtype_query.go b/entc/integration/migrate/entv2/customtype_query.go index 20e2b7b701..06b69b6739 100644 --- a/entc/integration/migrate/entv2/customtype_query.go +++ b/entc/integration/migrate/entv2/customtype_query.go @@ -294,7 +294,10 @@ func (ctq *CustomTypeQuery) GroupBy(field string, fields ...string) *CustomTypeG // func (ctq *CustomTypeQuery) Select(fields ...string) *CustomTypeSelect { ctq.fields = append(ctq.fields, fields...) - return &CustomTypeSelect{CustomTypeQuery: ctq} + sel := &CustomTypeSelect{CustomTypeQuery: ctq} + sel.typ, sel.label = "CustomType", customtype.Label + sel.flds, sel.scan = &ctq.fields, sel.Scan + return sel } func (ctq *CustomTypeQuery) prepareQuery(ctx context.Context) error { @@ -706,6 +709,7 @@ func (ctgb *CustomTypeGroupBy) sqlQuery() *sql.Selector { // CustomTypeSelect is the builder for selecting fields of CustomType entities. type CustomTypeSelect struct { *CustomTypeQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -719,201 +723,6 @@ func (cts *CustomTypeSelect) Scan(ctx context.Context, v interface{}) error { return cts.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cts *CustomTypeSelect) ScanX(ctx context.Context, v interface{}) { - if err := cts.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Strings(ctx context.Context) ([]string, error) { - if len(cts.fields) > 1 { - return nil, errors.New("entv2: CustomTypeSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cts *CustomTypeSelect) StringsX(ctx context.Context) []string { - v, err := cts.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cts.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{customtype.Label} - default: - err = fmt.Errorf("entv2: CustomTypeSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cts *CustomTypeSelect) StringX(ctx context.Context) string { - v, err := cts.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Ints(ctx context.Context) ([]int, error) { - if len(cts.fields) > 1 { - return nil, errors.New("entv2: CustomTypeSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cts *CustomTypeSelect) IntsX(ctx context.Context) []int { - v, err := cts.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cts.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{customtype.Label} - default: - err = fmt.Errorf("entv2: CustomTypeSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cts *CustomTypeSelect) IntX(ctx context.Context) int { - v, err := cts.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cts.fields) > 1 { - return nil, errors.New("entv2: CustomTypeSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cts *CustomTypeSelect) Float64sX(ctx context.Context) []float64 { - v, err := cts.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cts.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{customtype.Label} - default: - err = fmt.Errorf("entv2: CustomTypeSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cts *CustomTypeSelect) Float64X(ctx context.Context) float64 { - v, err := cts.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cts.fields) > 1 { - return nil, errors.New("entv2: CustomTypeSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cts *CustomTypeSelect) BoolsX(ctx context.Context) []bool { - v, err := cts.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cts *CustomTypeSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cts.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{customtype.Label} - default: - err = fmt.Errorf("entv2: CustomTypeSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cts *CustomTypeSelect) BoolX(ctx context.Context) bool { - v, err := cts.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cts *CustomTypeSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cts.sql.Query() diff --git a/entc/integration/migrate/entv2/ent.go b/entc/integration/migrate/entv2/ent.go index 8e187284e2..7ddf519b3f 100644 --- a/entc/integration/migrate/entv2/ent.go +++ b/entc/integration/migrate/entv2/ent.go @@ -7,6 +7,7 @@ package entv2 import ( + "context" "errors" "fmt" @@ -273,3 +274,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("entv2: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("entv2: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("entv2: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("entv2: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("entv2: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("entv2: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("entv2: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("entv2: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/migrate/entv2/group_query.go b/entc/integration/migrate/entv2/group_query.go index 771d9b3a69..9ccd751243 100644 --- a/entc/integration/migrate/entv2/group_query.go +++ b/entc/integration/migrate/entv2/group_query.go @@ -270,7 +270,10 @@ func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy { // instead of selecting all fields in the entity. func (gq *GroupQuery) Select(fields ...string) *GroupSelect { gq.fields = append(gq.fields, fields...) - return &GroupSelect{GroupQuery: gq} + sel := &GroupSelect{GroupQuery: gq} + sel.typ, sel.label = "Group", group.Label + sel.flds, sel.scan = &gq.fields, sel.Scan + return sel } func (gq *GroupQuery) prepareQuery(ctx context.Context) error { @@ -682,6 +685,7 @@ func (ggb *GroupGroupBy) sqlQuery() *sql.Selector { // GroupSelect is the builder for selecting fields of Group entities. type GroupSelect struct { *GroupQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -695,201 +699,6 @@ func (gs *GroupSelect) Scan(ctx context.Context, v interface{}) error { return gs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gs *GroupSelect) ScanX(ctx context.Context, v interface{}) { - if err := gs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Strings(ctx context.Context) ([]string, error) { - if len(gs.fields) > 1 { - return nil, errors.New("entv2: GroupSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gs *GroupSelect) StringsX(ctx context.Context) []string { - v, err := gs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("entv2: GroupSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gs *GroupSelect) StringX(ctx context.Context) string { - v, err := gs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Ints(ctx context.Context) ([]int, error) { - if len(gs.fields) > 1 { - return nil, errors.New("entv2: GroupSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gs *GroupSelect) IntsX(ctx context.Context) []int { - v, err := gs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("entv2: GroupSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gs *GroupSelect) IntX(ctx context.Context) int { - v, err := gs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gs.fields) > 1 { - return nil, errors.New("entv2: GroupSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gs *GroupSelect) Float64sX(ctx context.Context) []float64 { - v, err := gs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("entv2: GroupSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gs *GroupSelect) Float64X(ctx context.Context) float64 { - v, err := gs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gs.fields) > 1 { - return nil, errors.New("entv2: GroupSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gs *GroupSelect) BoolsX(ctx context.Context) []bool { - v, err := gs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("entv2: GroupSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gs *GroupSelect) BoolX(ctx context.Context) bool { - v, err := gs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gs *GroupSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := gs.sql.Query() diff --git a/entc/integration/migrate/entv2/media_query.go b/entc/integration/migrate/entv2/media_query.go index 21d9b75c1a..e4b5c4a12e 100644 --- a/entc/integration/migrate/entv2/media_query.go +++ b/entc/integration/migrate/entv2/media_query.go @@ -294,7 +294,10 @@ func (mq *MediaQuery) GroupBy(field string, fields ...string) *MediaGroupBy { // func (mq *MediaQuery) Select(fields ...string) *MediaSelect { mq.fields = append(mq.fields, fields...) - return &MediaSelect{MediaQuery: mq} + sel := &MediaSelect{MediaQuery: mq} + sel.typ, sel.label = "Media", media.Label + sel.flds, sel.scan = &mq.fields, sel.Scan + return sel } func (mq *MediaQuery) prepareQuery(ctx context.Context) error { @@ -706,6 +709,7 @@ func (mgb *MediaGroupBy) sqlQuery() *sql.Selector { // MediaSelect is the builder for selecting fields of Media entities. type MediaSelect struct { *MediaQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -719,201 +723,6 @@ func (ms *MediaSelect) Scan(ctx context.Context, v interface{}) error { return ms.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ms *MediaSelect) ScanX(ctx context.Context, v interface{}) { - if err := ms.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ms *MediaSelect) Strings(ctx context.Context) ([]string, error) { - if len(ms.fields) > 1 { - return nil, errors.New("entv2: MediaSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ms.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ms *MediaSelect) StringsX(ctx context.Context) []string { - v, err := ms.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ms *MediaSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ms.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{media.Label} - default: - err = fmt.Errorf("entv2: MediaSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ms *MediaSelect) StringX(ctx context.Context) string { - v, err := ms.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ms *MediaSelect) Ints(ctx context.Context) ([]int, error) { - if len(ms.fields) > 1 { - return nil, errors.New("entv2: MediaSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ms.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ms *MediaSelect) IntsX(ctx context.Context) []int { - v, err := ms.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ms *MediaSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ms.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{media.Label} - default: - err = fmt.Errorf("entv2: MediaSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ms *MediaSelect) IntX(ctx context.Context) int { - v, err := ms.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ms *MediaSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ms.fields) > 1 { - return nil, errors.New("entv2: MediaSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ms.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ms *MediaSelect) Float64sX(ctx context.Context) []float64 { - v, err := ms.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ms *MediaSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ms.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{media.Label} - default: - err = fmt.Errorf("entv2: MediaSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ms *MediaSelect) Float64X(ctx context.Context) float64 { - v, err := ms.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ms *MediaSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ms.fields) > 1 { - return nil, errors.New("entv2: MediaSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ms.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ms *MediaSelect) BoolsX(ctx context.Context) []bool { - v, err := ms.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ms *MediaSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ms.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{media.Label} - default: - err = fmt.Errorf("entv2: MediaSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ms *MediaSelect) BoolX(ctx context.Context) bool { - v, err := ms.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ms *MediaSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ms.sql.Query() diff --git a/entc/integration/migrate/entv2/pet_query.go b/entc/integration/migrate/entv2/pet_query.go index ba6b5f571e..5ea6c7b7c4 100644 --- a/entc/integration/migrate/entv2/pet_query.go +++ b/entc/integration/migrate/entv2/pet_query.go @@ -308,7 +308,10 @@ func (pq *PetQuery) GroupBy(field string, fields ...string) *PetGroupBy { // instead of selecting all fields in the entity. func (pq *PetQuery) Select(fields ...string) *PetSelect { pq.fields = append(pq.fields, fields...) - return &PetSelect{PetQuery: pq} + sel := &PetSelect{PetQuery: pq} + sel.typ, sel.label = "Pet", pet.Label + sel.flds, sel.scan = &pq.fields, sel.Scan + return sel } func (pq *PetQuery) prepareQuery(ctx context.Context) error { @@ -761,6 +764,7 @@ func (pgb *PetGroupBy) sqlQuery() *sql.Selector { // PetSelect is the builder for selecting fields of Pet entities. type PetSelect struct { *PetQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -774,201 +778,6 @@ func (ps *PetSelect) Scan(ctx context.Context, v interface{}) error { return ps.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ps *PetSelect) ScanX(ctx context.Context, v interface{}) { - if err := ps.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Strings(ctx context.Context) ([]string, error) { - if len(ps.fields) > 1 { - return nil, errors.New("entv2: PetSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ps *PetSelect) StringsX(ctx context.Context) []string { - v, err := ps.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ps.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("entv2: PetSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ps *PetSelect) StringX(ctx context.Context) string { - v, err := ps.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Ints(ctx context.Context) ([]int, error) { - if len(ps.fields) > 1 { - return nil, errors.New("entv2: PetSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ps *PetSelect) IntsX(ctx context.Context) []int { - v, err := ps.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ps.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("entv2: PetSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ps *PetSelect) IntX(ctx context.Context) int { - v, err := ps.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ps.fields) > 1 { - return nil, errors.New("entv2: PetSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ps *PetSelect) Float64sX(ctx context.Context) []float64 { - v, err := ps.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ps.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("entv2: PetSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ps *PetSelect) Float64X(ctx context.Context) float64 { - v, err := ps.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ps.fields) > 1 { - return nil, errors.New("entv2: PetSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ps *PetSelect) BoolsX(ctx context.Context) []bool { - v, err := ps.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ps.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("entv2: PetSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ps *PetSelect) BoolX(ctx context.Context) bool { - v, err := ps.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ps *PetSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ps.sql.Query() diff --git a/entc/integration/migrate/entv2/user_query.go b/entc/integration/migrate/entv2/user_query.go index de0203e940..5e4d27fe51 100644 --- a/entc/integration/migrate/entv2/user_query.go +++ b/entc/integration/migrate/entv2/user_query.go @@ -403,7 +403,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -944,6 +947,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -957,201 +961,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("entv2: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("entv2: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("entv2: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("entv2: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("entv2: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("entv2: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("entv2: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("entv2: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/entc/integration/migrate/versioned/car_query.go b/entc/integration/migrate/versioned/car_query.go index 86837a98bb..74a5098e5d 100644 --- a/entc/integration/migrate/versioned/car_query.go +++ b/entc/integration/migrate/versioned/car_query.go @@ -308,7 +308,10 @@ func (cq *CarQuery) GroupBy(field string, fields ...string) *CarGroupBy { // instead of selecting all fields in the entity. func (cq *CarQuery) Select(fields ...string) *CarSelect { cq.fields = append(cq.fields, fields...) - return &CarSelect{CarQuery: cq} + sel := &CarSelect{CarQuery: cq} + sel.typ, sel.label = "Car", car.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CarQuery) prepareQuery(ctx context.Context) error { @@ -761,6 +764,7 @@ func (cgb *CarGroupBy) sqlQuery() *sql.Selector { // CarSelect is the builder for selecting fields of Car entities. type CarSelect struct { *CarQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -774,201 +778,6 @@ func (cs *CarSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CarSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("versioned: CarSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CarSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("versioned: CarSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CarSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("versioned: CarSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CarSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("versioned: CarSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CarSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("versioned: CarSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CarSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("versioned: CarSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CarSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("versioned: CarSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CarSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("versioned: CarSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CarSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CarSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/entc/integration/migrate/versioned/ent.go b/entc/integration/migrate/versioned/ent.go index d4ee5e8971..4992ee7f96 100644 --- a/entc/integration/migrate/versioned/ent.go +++ b/entc/integration/migrate/versioned/ent.go @@ -7,6 +7,7 @@ package versioned import ( + "context" "errors" "fmt" @@ -263,3 +264,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("versioned: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("versioned: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("versioned: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("versioned: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("versioned: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("versioned: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("versioned: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("versioned: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/migrate/versioned/user_query.go b/entc/integration/migrate/versioned/user_query.go index 4c29b5e1e1..437d2a9e1c 100644 --- a/entc/integration/migrate/versioned/user_query.go +++ b/entc/integration/migrate/versioned/user_query.go @@ -438,7 +438,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -980,6 +983,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -993,201 +997,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("versioned: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("versioned: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("versioned: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("versioned: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("versioned: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("versioned: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("versioned: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("versioned: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/entc/integration/multischema/ent/ent.go b/entc/integration/multischema/ent/ent.go index f8dcfc357a..336f189d6d 100644 --- a/entc/integration/multischema/ent/ent.go +++ b/entc/integration/multischema/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -265,3 +266,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/multischema/ent/group_query.go b/entc/integration/multischema/ent/group_query.go index d3bacd872f..0ba7a1e4bb 100644 --- a/entc/integration/multischema/ent/group_query.go +++ b/entc/integration/multischema/ent/group_query.go @@ -337,7 +337,10 @@ func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy { // func (gq *GroupQuery) Select(fields ...string) *GroupSelect { gq.fields = append(gq.fields, fields...) - return &GroupSelect{GroupQuery: gq} + sel := &GroupSelect{GroupQuery: gq} + sel.typ, sel.label = "Group", group.Label + sel.flds, sel.scan = &gq.fields, sel.Scan + return sel } func (gq *GroupQuery) prepareQuery(ctx context.Context) error { @@ -842,6 +845,7 @@ func (ggb *GroupGroupBy) sqlQuery() *sql.Selector { // GroupSelect is the builder for selecting fields of Group entities. type GroupSelect struct { *GroupQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -855,201 +859,6 @@ func (gs *GroupSelect) Scan(ctx context.Context, v interface{}) error { return gs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gs *GroupSelect) ScanX(ctx context.Context, v interface{}) { - if err := gs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Strings(ctx context.Context) ([]string, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gs *GroupSelect) StringsX(ctx context.Context) []string { - v, err := gs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gs *GroupSelect) StringX(ctx context.Context) string { - v, err := gs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Ints(ctx context.Context) ([]int, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gs *GroupSelect) IntsX(ctx context.Context) []int { - v, err := gs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gs *GroupSelect) IntX(ctx context.Context) int { - v, err := gs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gs *GroupSelect) Float64sX(ctx context.Context) []float64 { - v, err := gs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gs *GroupSelect) Float64X(ctx context.Context) float64 { - v, err := gs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gs *GroupSelect) BoolsX(ctx context.Context) []bool { - v, err := gs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gs *GroupSelect) BoolX(ctx context.Context) bool { - v, err := gs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gs *GroupSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := gs.sql.Query() diff --git a/entc/integration/multischema/ent/pet_query.go b/entc/integration/multischema/ent/pet_query.go index ca62f3e85e..903828bacf 100644 --- a/entc/integration/multischema/ent/pet_query.go +++ b/entc/integration/multischema/ent/pet_query.go @@ -336,7 +336,10 @@ func (pq *PetQuery) GroupBy(field string, fields ...string) *PetGroupBy { // func (pq *PetQuery) Select(fields ...string) *PetSelect { pq.fields = append(pq.fields, fields...) - return &PetSelect{PetQuery: pq} + sel := &PetSelect{PetQuery: pq} + sel.typ, sel.label = "Pet", pet.Label + sel.flds, sel.scan = &pq.fields, sel.Scan + return sel } func (pq *PetQuery) prepareQuery(ctx context.Context) error { @@ -801,6 +804,7 @@ func (pgb *PetGroupBy) sqlQuery() *sql.Selector { // PetSelect is the builder for selecting fields of Pet entities. type PetSelect struct { *PetQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -814,201 +818,6 @@ func (ps *PetSelect) Scan(ctx context.Context, v interface{}) error { return ps.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ps *PetSelect) ScanX(ctx context.Context, v interface{}) { - if err := ps.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Strings(ctx context.Context) ([]string, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ps *PetSelect) StringsX(ctx context.Context) []string { - v, err := ps.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ps.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ps *PetSelect) StringX(ctx context.Context) string { - v, err := ps.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Ints(ctx context.Context) ([]int, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ps *PetSelect) IntsX(ctx context.Context) []int { - v, err := ps.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ps.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ps *PetSelect) IntX(ctx context.Context) int { - v, err := ps.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ps *PetSelect) Float64sX(ctx context.Context) []float64 { - v, err := ps.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ps.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ps *PetSelect) Float64X(ctx context.Context) float64 { - v, err := ps.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ps *PetSelect) BoolsX(ctx context.Context) []bool { - v, err := ps.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ps.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ps *PetSelect) BoolX(ctx context.Context) bool { - v, err := ps.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ps *PetSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ps.sql.Query() diff --git a/entc/integration/multischema/ent/user_query.go b/entc/integration/multischema/ent/user_query.go index 2f417ae671..f0b619f8e1 100644 --- a/entc/integration/multischema/ent/user_query.go +++ b/entc/integration/multischema/ent/user_query.go @@ -376,7 +376,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -907,6 +910,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -920,201 +924,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/entc/integration/privacy/ent/ent.go b/entc/integration/privacy/ent/ent.go index 5d7378ca85..61e6197095 100644 --- a/entc/integration/privacy/ent/ent.go +++ b/entc/integration/privacy/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -265,3 +266,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/privacy/ent/task_query.go b/entc/integration/privacy/ent/task_query.go index 7271968cdd..2e5b5eab2b 100644 --- a/entc/integration/privacy/ent/task_query.go +++ b/entc/integration/privacy/ent/task_query.go @@ -369,7 +369,10 @@ func (tq *TaskQuery) GroupBy(field string, fields ...string) *TaskGroupBy { // func (tq *TaskQuery) Select(fields ...string) *TaskSelect { tq.fields = append(tq.fields, fields...) - return &TaskSelect{TaskQuery: tq} + sel := &TaskSelect{TaskQuery: tq} + sel.typ, sel.label = "Task", task.Label + sel.flds, sel.scan = &tq.fields, sel.Scan + return sel } func (tq *TaskQuery) prepareQuery(ctx context.Context) error { @@ -894,6 +897,7 @@ func (tgb *TaskGroupBy) sqlQuery() *sql.Selector { // TaskSelect is the builder for selecting fields of Task entities. type TaskSelect struct { *TaskQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -907,201 +911,6 @@ func (ts *TaskSelect) Scan(ctx context.Context, v interface{}) error { return ts.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ts *TaskSelect) ScanX(ctx context.Context, v interface{}) { - if err := ts.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Strings(ctx context.Context) ([]string, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TaskSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ts *TaskSelect) StringsX(ctx context.Context) []string { - v, err := ts.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ts.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{task.Label} - default: - err = fmt.Errorf("ent: TaskSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ts *TaskSelect) StringX(ctx context.Context) string { - v, err := ts.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Ints(ctx context.Context) ([]int, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TaskSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ts *TaskSelect) IntsX(ctx context.Context) []int { - v, err := ts.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ts.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{task.Label} - default: - err = fmt.Errorf("ent: TaskSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ts *TaskSelect) IntX(ctx context.Context) int { - v, err := ts.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TaskSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ts *TaskSelect) Float64sX(ctx context.Context) []float64 { - v, err := ts.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ts.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{task.Label} - default: - err = fmt.Errorf("ent: TaskSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ts *TaskSelect) Float64X(ctx context.Context) float64 { - v, err := ts.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TaskSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ts *TaskSelect) BoolsX(ctx context.Context) []bool { - v, err := ts.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ts *TaskSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ts.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{task.Label} - default: - err = fmt.Errorf("ent: TaskSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ts *TaskSelect) BoolX(ctx context.Context) bool { - v, err := ts.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ts *TaskSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ts.sql.Query() diff --git a/entc/integration/privacy/ent/team_query.go b/entc/integration/privacy/ent/team_query.go index 0b9d346d95..5a7627d8d2 100644 --- a/entc/integration/privacy/ent/team_query.go +++ b/entc/integration/privacy/ent/team_query.go @@ -368,7 +368,10 @@ func (tq *TeamQuery) GroupBy(field string, fields ...string) *TeamGroupBy { // func (tq *TeamQuery) Select(fields ...string) *TeamSelect { tq.fields = append(tq.fields, fields...) - return &TeamSelect{TeamQuery: tq} + sel := &TeamSelect{TeamQuery: tq} + sel.typ, sel.label = "Team", team.Label + sel.flds, sel.scan = &tq.fields, sel.Scan + return sel } func (tq *TeamQuery) prepareQuery(ctx context.Context) error { @@ -922,6 +925,7 @@ func (tgb *TeamGroupBy) sqlQuery() *sql.Selector { // TeamSelect is the builder for selecting fields of Team entities. type TeamSelect struct { *TeamQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -935,201 +939,6 @@ func (ts *TeamSelect) Scan(ctx context.Context, v interface{}) error { return ts.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ts *TeamSelect) ScanX(ctx context.Context, v interface{}) { - if err := ts.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ts *TeamSelect) Strings(ctx context.Context) ([]string, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TeamSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ts *TeamSelect) StringsX(ctx context.Context) []string { - v, err := ts.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ts *TeamSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ts.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{team.Label} - default: - err = fmt.Errorf("ent: TeamSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ts *TeamSelect) StringX(ctx context.Context) string { - v, err := ts.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ts *TeamSelect) Ints(ctx context.Context) ([]int, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TeamSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ts *TeamSelect) IntsX(ctx context.Context) []int { - v, err := ts.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ts *TeamSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ts.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{team.Label} - default: - err = fmt.Errorf("ent: TeamSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ts *TeamSelect) IntX(ctx context.Context) int { - v, err := ts.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ts *TeamSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TeamSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ts *TeamSelect) Float64sX(ctx context.Context) []float64 { - v, err := ts.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ts *TeamSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ts.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{team.Label} - default: - err = fmt.Errorf("ent: TeamSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ts *TeamSelect) Float64X(ctx context.Context) float64 { - v, err := ts.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ts *TeamSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TeamSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ts *TeamSelect) BoolsX(ctx context.Context) []bool { - v, err := ts.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ts *TeamSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ts.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{team.Label} - default: - err = fmt.Errorf("ent: TeamSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ts *TeamSelect) BoolX(ctx context.Context) bool { - v, err := ts.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ts *TeamSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ts.sql.Query() diff --git a/entc/integration/privacy/ent/user_query.go b/entc/integration/privacy/ent/user_query.go index 2bb6a03a63..fff58d41ea 100644 --- a/entc/integration/privacy/ent/user_query.go +++ b/entc/integration/privacy/ent/user_query.go @@ -368,7 +368,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -886,6 +889,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -899,201 +903,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/entc/integration/template/ent/ent.go b/entc/integration/template/ent/ent.go index 8964b5f7d1..8f858ef708 100644 --- a/entc/integration/template/ent/ent.go +++ b/entc/integration/template/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -265,3 +266,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/entc/integration/template/ent/group_query.go b/entc/integration/template/ent/group_query.go index 3130977a20..ae2c0297c8 100644 --- a/entc/integration/template/ent/group_query.go +++ b/entc/integration/template/ent/group_query.go @@ -297,7 +297,10 @@ func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy { // func (gq *GroupQuery) Select(fields ...string) *GroupSelect { gq.fields = append(gq.fields, fields...) - return &GroupSelect{GroupQuery: gq} + sel := &GroupSelect{GroupQuery: gq} + sel.typ, sel.label = "Group", group.Label + sel.flds, sel.scan = &gq.fields, sel.Scan + return sel } func (gq *GroupQuery) prepareQuery(ctx context.Context) error { @@ -723,6 +726,7 @@ func (ggb *GroupGroupBy) sqlQuery() *sql.Selector { // GroupSelect is the builder for selecting fields of Group entities. type GroupSelect struct { *GroupQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -736,201 +740,6 @@ func (gs *GroupSelect) Scan(ctx context.Context, v interface{}) error { return gs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gs *GroupSelect) ScanX(ctx context.Context, v interface{}) { - if err := gs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Strings(ctx context.Context) ([]string, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gs *GroupSelect) StringsX(ctx context.Context) []string { - v, err := gs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gs *GroupSelect) StringX(ctx context.Context) string { - v, err := gs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Ints(ctx context.Context) ([]int, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gs *GroupSelect) IntsX(ctx context.Context) []int { - v, err := gs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gs *GroupSelect) IntX(ctx context.Context) int { - v, err := gs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gs *GroupSelect) Float64sX(ctx context.Context) []float64 { - v, err := gs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gs *GroupSelect) Float64X(ctx context.Context) float64 { - v, err := gs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gs *GroupSelect) BoolsX(ctx context.Context) []bool { - v, err := gs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gs *GroupSelect) BoolX(ctx context.Context) bool { - v, err := gs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gs *GroupSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := gs.sql.Query() diff --git a/entc/integration/template/ent/pet_query.go b/entc/integration/template/ent/pet_query.go index 241249cb1e..1522db429a 100644 --- a/entc/integration/template/ent/pet_query.go +++ b/entc/integration/template/ent/pet_query.go @@ -335,7 +335,10 @@ func (pq *PetQuery) GroupBy(field string, fields ...string) *PetGroupBy { // func (pq *PetQuery) Select(fields ...string) *PetSelect { pq.fields = append(pq.fields, fields...) - return &PetSelect{PetQuery: pq} + sel := &PetSelect{PetQuery: pq} + sel.typ, sel.label = "Pet", pet.Label + sel.flds, sel.scan = &pq.fields, sel.Scan + return sel } func (pq *PetQuery) prepareQuery(ctx context.Context) error { @@ -802,6 +805,7 @@ func (pgb *PetGroupBy) sqlQuery() *sql.Selector { // PetSelect is the builder for selecting fields of Pet entities. type PetSelect struct { *PetQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -815,201 +819,6 @@ func (ps *PetSelect) Scan(ctx context.Context, v interface{}) error { return ps.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ps *PetSelect) ScanX(ctx context.Context, v interface{}) { - if err := ps.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Strings(ctx context.Context) ([]string, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ps *PetSelect) StringsX(ctx context.Context) []string { - v, err := ps.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ps.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ps *PetSelect) StringX(ctx context.Context) string { - v, err := ps.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Ints(ctx context.Context) ([]int, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ps *PetSelect) IntsX(ctx context.Context) []int { - v, err := ps.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ps.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ps *PetSelect) IntX(ctx context.Context) int { - v, err := ps.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ps *PetSelect) Float64sX(ctx context.Context) []float64 { - v, err := ps.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ps.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ps *PetSelect) Float64X(ctx context.Context) float64 { - v, err := ps.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ps *PetSelect) BoolsX(ctx context.Context) []bool { - v, err := ps.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ps.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ps *PetSelect) BoolX(ctx context.Context) bool { - v, err := ps.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ps *PetSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ps.sql.Query() diff --git a/entc/integration/template/ent/user_query.go b/entc/integration/template/ent/user_query.go index bc87204910..05f94b1d4d 100644 --- a/entc/integration/template/ent/user_query.go +++ b/entc/integration/template/ent/user_query.go @@ -370,7 +370,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -896,6 +899,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -909,201 +913,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/examples/edgeindex/ent/city_query.go b/examples/edgeindex/ent/city_query.go index 4d5bc8ca32..a2ab2f3c90 100644 --- a/examples/edgeindex/ent/city_query.go +++ b/examples/edgeindex/ent/city_query.go @@ -332,7 +332,10 @@ func (cq *CityQuery) GroupBy(field string, fields ...string) *CityGroupBy { // func (cq *CityQuery) Select(fields ...string) *CitySelect { cq.fields = append(cq.fields, fields...) - return &CitySelect{CityQuery: cq} + sel := &CitySelect{CityQuery: cq} + sel.typ, sel.label = "City", city.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CityQuery) prepareQuery(ctx context.Context) error { @@ -778,6 +781,7 @@ func (cgb *CityGroupBy) sqlQuery() *sql.Selector { // CitySelect is the builder for selecting fields of City entities. type CitySelect struct { *CityQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -791,201 +795,6 @@ func (cs *CitySelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CitySelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CitySelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CitySelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CitySelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CitySelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{city.Label} - default: - err = fmt.Errorf("ent: CitySelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CitySelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CitySelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CitySelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CitySelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CitySelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{city.Label} - default: - err = fmt.Errorf("ent: CitySelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CitySelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CitySelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CitySelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CitySelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CitySelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{city.Label} - default: - err = fmt.Errorf("ent: CitySelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CitySelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CitySelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CitySelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CitySelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CitySelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{city.Label} - default: - err = fmt.Errorf("ent: CitySelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CitySelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CitySelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/examples/edgeindex/ent/ent.go b/examples/edgeindex/ent/ent.go index 2e6c794e52..a931e3b3a5 100644 --- a/examples/edgeindex/ent/ent.go +++ b/examples/edgeindex/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -263,3 +264,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/edgeindex/ent/street_query.go b/examples/edgeindex/ent/street_query.go index b34f688040..0bfd46a3ff 100644 --- a/examples/edgeindex/ent/street_query.go +++ b/examples/edgeindex/ent/street_query.go @@ -332,7 +332,10 @@ func (sq *StreetQuery) GroupBy(field string, fields ...string) *StreetGroupBy { // func (sq *StreetQuery) Select(fields ...string) *StreetSelect { sq.fields = append(sq.fields, fields...) - return &StreetSelect{StreetQuery: sq} + sel := &StreetSelect{StreetQuery: sq} + sel.typ, sel.label = "Street", street.Label + sel.flds, sel.scan = &sq.fields, sel.Scan + return sel } func (sq *StreetQuery) prepareQuery(ctx context.Context) error { @@ -785,6 +788,7 @@ func (sgb *StreetGroupBy) sqlQuery() *sql.Selector { // StreetSelect is the builder for selecting fields of Street entities. type StreetSelect struct { *StreetQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -798,201 +802,6 @@ func (ss *StreetSelect) Scan(ctx context.Context, v interface{}) error { return ss.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ss *StreetSelect) ScanX(ctx context.Context, v interface{}) { - if err := ss.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ss *StreetSelect) Strings(ctx context.Context) ([]string, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: StreetSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ss *StreetSelect) StringsX(ctx context.Context) []string { - v, err := ss.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ss *StreetSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ss.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{street.Label} - default: - err = fmt.Errorf("ent: StreetSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ss *StreetSelect) StringX(ctx context.Context) string { - v, err := ss.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ss *StreetSelect) Ints(ctx context.Context) ([]int, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: StreetSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ss *StreetSelect) IntsX(ctx context.Context) []int { - v, err := ss.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ss *StreetSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ss.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{street.Label} - default: - err = fmt.Errorf("ent: StreetSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ss *StreetSelect) IntX(ctx context.Context) int { - v, err := ss.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ss *StreetSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: StreetSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ss *StreetSelect) Float64sX(ctx context.Context) []float64 { - v, err := ss.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ss *StreetSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ss.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{street.Label} - default: - err = fmt.Errorf("ent: StreetSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ss *StreetSelect) Float64X(ctx context.Context) float64 { - v, err := ss.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ss *StreetSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ss.fields) > 1 { - return nil, errors.New("ent: StreetSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ss.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ss *StreetSelect) BoolsX(ctx context.Context) []bool { - v, err := ss.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ss *StreetSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ss.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{street.Label} - default: - err = fmt.Errorf("ent: StreetSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ss *StreetSelect) BoolX(ctx context.Context) bool { - v, err := ss.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ss *StreetSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ss.sql.Query() diff --git a/examples/entcpkg/ent/ent.go b/examples/entcpkg/ent/ent.go index b3c29681e3..fe919008f7 100644 --- a/examples/entcpkg/ent/ent.go +++ b/examples/entcpkg/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -261,3 +262,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/entcpkg/ent/user_query.go b/examples/entcpkg/ent/user_query.go index 5dc82fbc11..456b91fdbb 100644 --- a/examples/entcpkg/ent/user_query.go +++ b/examples/entcpkg/ent/user_query.go @@ -294,7 +294,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -706,6 +709,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -719,201 +723,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/examples/fs/ent/ent.go b/examples/fs/ent/ent.go index baeaad64ad..e1aa7eddf8 100644 --- a/examples/fs/ent/ent.go +++ b/examples/fs/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -261,3 +262,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/fs/ent/file_query.go b/examples/fs/ent/file_query.go index f094e00c60..e86702dd98 100644 --- a/examples/fs/ent/file_query.go +++ b/examples/fs/ent/file_query.go @@ -366,7 +366,10 @@ func (fq *FileQuery) GroupBy(field string, fields ...string) *FileGroupBy { // func (fq *FileQuery) Select(fields ...string) *FileSelect { fq.fields = append(fq.fields, fields...) - return &FileSelect{FileQuery: fq} + sel := &FileSelect{FileQuery: fq} + sel.typ, sel.label = "File", file.Label + sel.flds, sel.scan = &fq.fields, sel.Scan + return sel } func (fq *FileQuery) prepareQuery(ctx context.Context) error { @@ -835,6 +838,7 @@ func (fgb *FileGroupBy) sqlQuery() *sql.Selector { // FileSelect is the builder for selecting fields of File entities. type FileSelect struct { *FileQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -848,201 +852,6 @@ func (fs *FileSelect) Scan(ctx context.Context, v interface{}) error { return fs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (fs *FileSelect) ScanX(ctx context.Context, v interface{}) { - if err := fs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Strings(ctx context.Context) ([]string, error) { - if len(fs.fields) > 1 { - return nil, errors.New("ent: FileSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := fs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (fs *FileSelect) StringsX(ctx context.Context) []string { - v, err := fs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = fs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{file.Label} - default: - err = fmt.Errorf("ent: FileSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (fs *FileSelect) StringX(ctx context.Context) string { - v, err := fs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Ints(ctx context.Context) ([]int, error) { - if len(fs.fields) > 1 { - return nil, errors.New("ent: FileSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := fs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (fs *FileSelect) IntsX(ctx context.Context) []int { - v, err := fs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = fs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{file.Label} - default: - err = fmt.Errorf("ent: FileSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (fs *FileSelect) IntX(ctx context.Context) int { - v, err := fs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(fs.fields) > 1 { - return nil, errors.New("ent: FileSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := fs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (fs *FileSelect) Float64sX(ctx context.Context) []float64 { - v, err := fs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = fs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{file.Label} - default: - err = fmt.Errorf("ent: FileSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (fs *FileSelect) Float64X(ctx context.Context) float64 { - v, err := fs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Bools(ctx context.Context) ([]bool, error) { - if len(fs.fields) > 1 { - return nil, errors.New("ent: FileSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := fs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (fs *FileSelect) BoolsX(ctx context.Context) []bool { - v, err := fs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (fs *FileSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = fs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{file.Label} - default: - err = fmt.Errorf("ent: FileSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (fs *FileSelect) BoolX(ctx context.Context) bool { - v, err := fs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (fs *FileSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := fs.sql.Query() diff --git a/examples/m2m2types/ent/ent.go b/examples/m2m2types/ent/ent.go index a93e0e39ae..8186e538f9 100644 --- a/examples/m2m2types/ent/ent.go +++ b/examples/m2m2types/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -263,3 +264,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/m2m2types/ent/group_query.go b/examples/m2m2types/ent/group_query.go index 9deee58742..ea22fa93c3 100644 --- a/examples/m2m2types/ent/group_query.go +++ b/examples/m2m2types/ent/group_query.go @@ -332,7 +332,10 @@ func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy { // func (gq *GroupQuery) Select(fields ...string) *GroupSelect { gq.fields = append(gq.fields, fields...) - return &GroupSelect{GroupQuery: gq} + sel := &GroupSelect{GroupQuery: gq} + sel.typ, sel.label = "Group", group.Label + sel.flds, sel.scan = &gq.fields, sel.Scan + return sel } func (gq *GroupQuery) prepareQuery(ctx context.Context) error { @@ -814,6 +817,7 @@ func (ggb *GroupGroupBy) sqlQuery() *sql.Selector { // GroupSelect is the builder for selecting fields of Group entities. type GroupSelect struct { *GroupQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -827,201 +831,6 @@ func (gs *GroupSelect) Scan(ctx context.Context, v interface{}) error { return gs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gs *GroupSelect) ScanX(ctx context.Context, v interface{}) { - if err := gs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Strings(ctx context.Context) ([]string, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gs *GroupSelect) StringsX(ctx context.Context) []string { - v, err := gs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gs *GroupSelect) StringX(ctx context.Context) string { - v, err := gs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Ints(ctx context.Context) ([]int, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gs *GroupSelect) IntsX(ctx context.Context) []int { - v, err := gs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gs *GroupSelect) IntX(ctx context.Context) int { - v, err := gs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gs *GroupSelect) Float64sX(ctx context.Context) []float64 { - v, err := gs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gs *GroupSelect) Float64X(ctx context.Context) float64 { - v, err := gs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gs *GroupSelect) BoolsX(ctx context.Context) []bool { - v, err := gs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gs *GroupSelect) BoolX(ctx context.Context) bool { - v, err := gs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gs *GroupSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := gs.sql.Query() diff --git a/examples/m2m2types/ent/user_query.go b/examples/m2m2types/ent/user_query.go index 3bc8b65498..08efa0bb8f 100644 --- a/examples/m2m2types/ent/user_query.go +++ b/examples/m2m2types/ent/user_query.go @@ -332,7 +332,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -814,6 +817,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -827,201 +831,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/examples/m2mbidi/ent/ent.go b/examples/m2mbidi/ent/ent.go index e7341cbd71..20c09a7c0a 100644 --- a/examples/m2mbidi/ent/ent.go +++ b/examples/m2mbidi/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -261,3 +262,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/m2mbidi/ent/user_query.go b/examples/m2mbidi/ent/user_query.go index 1a685d4f7a..588d7e67d9 100644 --- a/examples/m2mbidi/ent/user_query.go +++ b/examples/m2mbidi/ent/user_query.go @@ -331,7 +331,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -813,6 +816,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -826,201 +830,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/examples/m2mrecur/ent/ent.go b/examples/m2mrecur/ent/ent.go index 68b174dc46..4721e1cb4e 100644 --- a/examples/m2mrecur/ent/ent.go +++ b/examples/m2mrecur/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -261,3 +262,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/m2mrecur/ent/user_query.go b/examples/m2mrecur/ent/user_query.go index de6a52cd00..693a485672 100644 --- a/examples/m2mrecur/ent/user_query.go +++ b/examples/m2mrecur/ent/user_query.go @@ -366,7 +366,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -914,6 +917,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -927,201 +931,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/examples/o2m2types/ent/ent.go b/examples/o2m2types/ent/ent.go index e56a9a251a..e40be542c2 100644 --- a/examples/o2m2types/ent/ent.go +++ b/examples/o2m2types/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -263,3 +264,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/o2m2types/ent/pet_query.go b/examples/o2m2types/ent/pet_query.go index 7c87a83d16..af705d4cb1 100644 --- a/examples/o2m2types/ent/pet_query.go +++ b/examples/o2m2types/ent/pet_query.go @@ -332,7 +332,10 @@ func (pq *PetQuery) GroupBy(field string, fields ...string) *PetGroupBy { // func (pq *PetQuery) Select(fields ...string) *PetSelect { pq.fields = append(pq.fields, fields...) - return &PetSelect{PetQuery: pq} + sel := &PetSelect{PetQuery: pq} + sel.typ, sel.label = "Pet", pet.Label + sel.flds, sel.scan = &pq.fields, sel.Scan + return sel } func (pq *PetQuery) prepareQuery(ctx context.Context) error { @@ -785,6 +788,7 @@ func (pgb *PetGroupBy) sqlQuery() *sql.Selector { // PetSelect is the builder for selecting fields of Pet entities. type PetSelect struct { *PetQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -798,201 +802,6 @@ func (ps *PetSelect) Scan(ctx context.Context, v interface{}) error { return ps.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ps *PetSelect) ScanX(ctx context.Context, v interface{}) { - if err := ps.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Strings(ctx context.Context) ([]string, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ps *PetSelect) StringsX(ctx context.Context) []string { - v, err := ps.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ps.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ps *PetSelect) StringX(ctx context.Context) string { - v, err := ps.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Ints(ctx context.Context) ([]int, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ps *PetSelect) IntsX(ctx context.Context) []int { - v, err := ps.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ps.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ps *PetSelect) IntX(ctx context.Context) int { - v, err := ps.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ps *PetSelect) Float64sX(ctx context.Context) []float64 { - v, err := ps.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ps.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ps *PetSelect) Float64X(ctx context.Context) float64 { - v, err := ps.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ps *PetSelect) BoolsX(ctx context.Context) []bool { - v, err := ps.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ps.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ps *PetSelect) BoolX(ctx context.Context) bool { - v, err := ps.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ps *PetSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ps.sql.Query() diff --git a/examples/o2m2types/ent/user_query.go b/examples/o2m2types/ent/user_query.go index feee4c8241..3ef5b2fdf0 100644 --- a/examples/o2m2types/ent/user_query.go +++ b/examples/o2m2types/ent/user_query.go @@ -332,7 +332,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -778,6 +781,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -791,201 +795,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/examples/o2mrecur/ent/ent.go b/examples/o2mrecur/ent/ent.go index 9e654a0a72..92229b7750 100644 --- a/examples/o2mrecur/ent/ent.go +++ b/examples/o2mrecur/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -261,3 +262,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/o2mrecur/ent/node_query.go b/examples/o2mrecur/ent/node_query.go index ef6830b732..4588eaec4b 100644 --- a/examples/o2mrecur/ent/node_query.go +++ b/examples/o2mrecur/ent/node_query.go @@ -367,7 +367,10 @@ func (nq *NodeQuery) GroupBy(field string, fields ...string) *NodeGroupBy { // func (nq *NodeQuery) Select(fields ...string) *NodeSelect { nq.fields = append(nq.fields, fields...) - return &NodeSelect{NodeQuery: nq} + sel := &NodeSelect{NodeQuery: nq} + sel.typ, sel.label = "Node", node.Label + sel.flds, sel.scan = &nq.fields, sel.Scan + return sel } func (nq *NodeQuery) prepareQuery(ctx context.Context) error { @@ -850,6 +853,7 @@ func (ngb *NodeGroupBy) sqlQuery() *sql.Selector { // NodeSelect is the builder for selecting fields of Node entities. type NodeSelect struct { *NodeQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -863,201 +867,6 @@ func (ns *NodeSelect) Scan(ctx context.Context, v interface{}) error { return ns.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ns *NodeSelect) ScanX(ctx context.Context, v interface{}) { - if err := ns.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Strings(ctx context.Context) ([]string, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ns *NodeSelect) StringsX(ctx context.Context) []string { - v, err := ns.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ns.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ns *NodeSelect) StringX(ctx context.Context) string { - v, err := ns.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Ints(ctx context.Context) ([]int, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ns *NodeSelect) IntsX(ctx context.Context) []int { - v, err := ns.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ns.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ns *NodeSelect) IntX(ctx context.Context) int { - v, err := ns.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ns *NodeSelect) Float64sX(ctx context.Context) []float64 { - v, err := ns.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ns.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ns *NodeSelect) Float64X(ctx context.Context) float64 { - v, err := ns.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ns *NodeSelect) BoolsX(ctx context.Context) []bool { - v, err := ns.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ns.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ns *NodeSelect) BoolX(ctx context.Context) bool { - v, err := ns.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ns *NodeSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ns.sql.Query() diff --git a/examples/o2o2types/ent/card_query.go b/examples/o2o2types/ent/card_query.go index 17dac84923..83ee8721f6 100644 --- a/examples/o2o2types/ent/card_query.go +++ b/examples/o2o2types/ent/card_query.go @@ -332,7 +332,10 @@ func (cq *CardQuery) GroupBy(field string, fields ...string) *CardGroupBy { // func (cq *CardQuery) Select(fields ...string) *CardSelect { cq.fields = append(cq.fields, fields...) - return &CardSelect{CardQuery: cq} + sel := &CardSelect{CardQuery: cq} + sel.typ, sel.label = "Card", card.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CardQuery) prepareQuery(ctx context.Context) error { @@ -785,6 +788,7 @@ func (cgb *CardGroupBy) sqlQuery() *sql.Selector { // CardSelect is the builder for selecting fields of Card entities. type CardSelect struct { *CardQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -798,201 +802,6 @@ func (cs *CardSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CardSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CardSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CardSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CardSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CardSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CardSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CardSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CardSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CardSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CardSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{card.Label} - default: - err = fmt.Errorf("ent: CardSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CardSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CardSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/examples/o2o2types/ent/ent.go b/examples/o2o2types/ent/ent.go index 591b52d960..f34df25ed8 100644 --- a/examples/o2o2types/ent/ent.go +++ b/examples/o2o2types/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -263,3 +264,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/o2o2types/ent/user_query.go b/examples/o2o2types/ent/user_query.go index 1ccec47938..11c3bd3103 100644 --- a/examples/o2o2types/ent/user_query.go +++ b/examples/o2o2types/ent/user_query.go @@ -332,7 +332,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -777,6 +780,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -790,201 +794,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/examples/o2obidi/ent/ent.go b/examples/o2obidi/ent/ent.go index 3fc487293a..f9b6a96baa 100644 --- a/examples/o2obidi/ent/ent.go +++ b/examples/o2obidi/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -261,3 +262,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/o2obidi/ent/user_query.go b/examples/o2obidi/ent/user_query.go index e6727979c0..3bb0e4ba6c 100644 --- a/examples/o2obidi/ent/user_query.go +++ b/examples/o2obidi/ent/user_query.go @@ -331,7 +331,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -784,6 +787,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -797,201 +801,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/examples/o2orecur/ent/ent.go b/examples/o2orecur/ent/ent.go index a603b04fc6..45947b74b1 100644 --- a/examples/o2orecur/ent/ent.go +++ b/examples/o2orecur/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -261,3 +262,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/o2orecur/ent/node_query.go b/examples/o2orecur/ent/node_query.go index 830bcc9927..02f88fcd69 100644 --- a/examples/o2orecur/ent/node_query.go +++ b/examples/o2orecur/ent/node_query.go @@ -367,7 +367,10 @@ func (nq *NodeQuery) GroupBy(field string, fields ...string) *NodeGroupBy { // func (nq *NodeQuery) Select(fields ...string) *NodeSelect { nq.fields = append(nq.fields, fields...) - return &NodeSelect{NodeQuery: nq} + sel := &NodeSelect{NodeQuery: nq} + sel.typ, sel.label = "Node", node.Label + sel.flds, sel.scan = &nq.fields, sel.Scan + return sel } func (nq *NodeQuery) prepareQuery(ctx context.Context) error { @@ -849,6 +852,7 @@ func (ngb *NodeGroupBy) sqlQuery() *sql.Selector { // NodeSelect is the builder for selecting fields of Node entities. type NodeSelect struct { *NodeQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -862,201 +866,6 @@ func (ns *NodeSelect) Scan(ctx context.Context, v interface{}) error { return ns.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ns *NodeSelect) ScanX(ctx context.Context, v interface{}) { - if err := ns.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Strings(ctx context.Context) ([]string, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ns *NodeSelect) StringsX(ctx context.Context) []string { - v, err := ns.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ns.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ns *NodeSelect) StringX(ctx context.Context) string { - v, err := ns.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Ints(ctx context.Context) ([]int, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ns *NodeSelect) IntsX(ctx context.Context) []int { - v, err := ns.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ns.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ns *NodeSelect) IntX(ctx context.Context) int { - v, err := ns.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ns *NodeSelect) Float64sX(ctx context.Context) []float64 { - v, err := ns.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ns.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ns *NodeSelect) Float64X(ctx context.Context) float64 { - v, err := ns.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ns.fields) > 1 { - return nil, errors.New("ent: NodeSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ns.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ns *NodeSelect) BoolsX(ctx context.Context) []bool { - v, err := ns.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ns *NodeSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ns.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{node.Label} - default: - err = fmt.Errorf("ent: NodeSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ns *NodeSelect) BoolX(ctx context.Context) bool { - v, err := ns.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ns *NodeSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ns.sql.Query() diff --git a/examples/privacyadmin/ent/ent.go b/examples/privacyadmin/ent/ent.go index 23b732a380..1dc6630690 100644 --- a/examples/privacyadmin/ent/ent.go +++ b/examples/privacyadmin/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -261,3 +262,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/privacyadmin/ent/user_query.go b/examples/privacyadmin/ent/user_query.go index 7f943a2f68..843e266320 100644 --- a/examples/privacyadmin/ent/user_query.go +++ b/examples/privacyadmin/ent/user_query.go @@ -294,7 +294,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -712,6 +715,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -725,201 +729,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/examples/privacytenant/ent/ent.go b/examples/privacytenant/ent/ent.go index 372bdc24a2..a005289b4f 100644 --- a/examples/privacytenant/ent/ent.go +++ b/examples/privacytenant/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -265,3 +266,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/privacytenant/ent/group_query.go b/examples/privacytenant/ent/group_query.go index c43495acfb..efef3d39fc 100644 --- a/examples/privacytenant/ent/group_query.go +++ b/examples/privacytenant/ent/group_query.go @@ -369,7 +369,10 @@ func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy { // func (gq *GroupQuery) Select(fields ...string) *GroupSelect { gq.fields = append(gq.fields, fields...) - return &GroupSelect{GroupQuery: gq} + sel := &GroupSelect{GroupQuery: gq} + sel.typ, sel.label = "Group", group.Label + sel.flds, sel.scan = &gq.fields, sel.Scan + return sel } func (gq *GroupQuery) prepareQuery(ctx context.Context) error { @@ -894,6 +897,7 @@ func (ggb *GroupGroupBy) sqlQuery() *sql.Selector { // GroupSelect is the builder for selecting fields of Group entities. type GroupSelect struct { *GroupQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -907,201 +911,6 @@ func (gs *GroupSelect) Scan(ctx context.Context, v interface{}) error { return gs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gs *GroupSelect) ScanX(ctx context.Context, v interface{}) { - if err := gs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Strings(ctx context.Context) ([]string, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gs *GroupSelect) StringsX(ctx context.Context) []string { - v, err := gs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gs *GroupSelect) StringX(ctx context.Context) string { - v, err := gs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Ints(ctx context.Context) ([]int, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gs *GroupSelect) IntsX(ctx context.Context) []int { - v, err := gs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gs *GroupSelect) IntX(ctx context.Context) int { - v, err := gs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gs *GroupSelect) Float64sX(ctx context.Context) []float64 { - v, err := gs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gs *GroupSelect) Float64X(ctx context.Context) float64 { - v, err := gs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gs *GroupSelect) BoolsX(ctx context.Context) []bool { - v, err := gs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gs *GroupSelect) BoolX(ctx context.Context) bool { - v, err := gs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gs *GroupSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := gs.sql.Query() diff --git a/examples/privacytenant/ent/tenant_query.go b/examples/privacytenant/ent/tenant_query.go index e126b36174..dd08e2f260 100644 --- a/examples/privacytenant/ent/tenant_query.go +++ b/examples/privacytenant/ent/tenant_query.go @@ -294,7 +294,10 @@ func (tq *TenantQuery) GroupBy(field string, fields ...string) *TenantGroupBy { // func (tq *TenantQuery) Select(fields ...string) *TenantSelect { tq.fields = append(tq.fields, fields...) - return &TenantSelect{TenantQuery: tq} + sel := &TenantSelect{TenantQuery: tq} + sel.typ, sel.label = "Tenant", tenant.Label + sel.flds, sel.scan = &tq.fields, sel.Scan + return sel } func (tq *TenantQuery) prepareQuery(ctx context.Context) error { @@ -712,6 +715,7 @@ func (tgb *TenantGroupBy) sqlQuery() *sql.Selector { // TenantSelect is the builder for selecting fields of Tenant entities. type TenantSelect struct { *TenantQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -725,201 +729,6 @@ func (ts *TenantSelect) Scan(ctx context.Context, v interface{}) error { return ts.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ts *TenantSelect) ScanX(ctx context.Context, v interface{}) { - if err := ts.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ts *TenantSelect) Strings(ctx context.Context) ([]string, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TenantSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ts *TenantSelect) StringsX(ctx context.Context) []string { - v, err := ts.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ts *TenantSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ts.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{tenant.Label} - default: - err = fmt.Errorf("ent: TenantSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ts *TenantSelect) StringX(ctx context.Context) string { - v, err := ts.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ts *TenantSelect) Ints(ctx context.Context) ([]int, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TenantSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ts *TenantSelect) IntsX(ctx context.Context) []int { - v, err := ts.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ts *TenantSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ts.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{tenant.Label} - default: - err = fmt.Errorf("ent: TenantSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ts *TenantSelect) IntX(ctx context.Context) int { - v, err := ts.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ts *TenantSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TenantSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ts *TenantSelect) Float64sX(ctx context.Context) []float64 { - v, err := ts.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ts *TenantSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ts.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{tenant.Label} - default: - err = fmt.Errorf("ent: TenantSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ts *TenantSelect) Float64X(ctx context.Context) float64 { - v, err := ts.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ts *TenantSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ts.fields) > 1 { - return nil, errors.New("ent: TenantSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ts.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ts *TenantSelect) BoolsX(ctx context.Context) []bool { - v, err := ts.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ts *TenantSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ts.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{tenant.Label} - default: - err = fmt.Errorf("ent: TenantSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ts *TenantSelect) BoolX(ctx context.Context) bool { - v, err := ts.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ts *TenantSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ts.sql.Query() diff --git a/examples/privacytenant/ent/user_query.go b/examples/privacytenant/ent/user_query.go index aeed75f735..14d6a918db 100644 --- a/examples/privacytenant/ent/user_query.go +++ b/examples/privacytenant/ent/user_query.go @@ -369,7 +369,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -894,6 +897,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -907,201 +911,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/examples/start/ent/car_query.go b/examples/start/ent/car_query.go index 743d8b75c4..38b7d79dd0 100644 --- a/examples/start/ent/car_query.go +++ b/examples/start/ent/car_query.go @@ -332,7 +332,10 @@ func (cq *CarQuery) GroupBy(field string, fields ...string) *CarGroupBy { // func (cq *CarQuery) Select(fields ...string) *CarSelect { cq.fields = append(cq.fields, fields...) - return &CarSelect{CarQuery: cq} + sel := &CarSelect{CarQuery: cq} + sel.typ, sel.label = "Car", car.Label + sel.flds, sel.scan = &cq.fields, sel.Scan + return sel } func (cq *CarQuery) prepareQuery(ctx context.Context) error { @@ -785,6 +788,7 @@ func (cgb *CarGroupBy) sqlQuery() *sql.Selector { // CarSelect is the builder for selecting fields of Car entities. type CarSelect struct { *CarQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -798,201 +802,6 @@ func (cs *CarSelect) Scan(ctx context.Context, v interface{}) error { return cs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (cs *CarSelect) ScanX(ctx context.Context, v interface{}) { - if err := cs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Strings(ctx context.Context) ([]string, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CarSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (cs *CarSelect) StringsX(ctx context.Context) []string { - v, err := cs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = cs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("ent: CarSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (cs *CarSelect) StringX(ctx context.Context) string { - v, err := cs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Ints(ctx context.Context) ([]int, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CarSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (cs *CarSelect) IntsX(ctx context.Context) []int { - v, err := cs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = cs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("ent: CarSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (cs *CarSelect) IntX(ctx context.Context) int { - v, err := cs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CarSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (cs *CarSelect) Float64sX(ctx context.Context) []float64 { - v, err := cs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = cs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("ent: CarSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (cs *CarSelect) Float64X(ctx context.Context) float64 { - v, err := cs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Bools(ctx context.Context) ([]bool, error) { - if len(cs.fields) > 1 { - return nil, errors.New("ent: CarSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := cs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (cs *CarSelect) BoolsX(ctx context.Context) []bool { - v, err := cs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (cs *CarSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = cs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{car.Label} - default: - err = fmt.Errorf("ent: CarSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (cs *CarSelect) BoolX(ctx context.Context) bool { - v, err := cs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (cs *CarSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := cs.sql.Query() diff --git a/examples/start/ent/ent.go b/examples/start/ent/ent.go index ebf4dd1f93..23e8f3a775 100644 --- a/examples/start/ent/ent.go +++ b/examples/start/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -265,3 +266,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/start/ent/group_query.go b/examples/start/ent/group_query.go index ff45f0c9c3..0abe093833 100644 --- a/examples/start/ent/group_query.go +++ b/examples/start/ent/group_query.go @@ -332,7 +332,10 @@ func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy { // func (gq *GroupQuery) Select(fields ...string) *GroupSelect { gq.fields = append(gq.fields, fields...) - return &GroupSelect{GroupQuery: gq} + sel := &GroupSelect{GroupQuery: gq} + sel.typ, sel.label = "Group", group.Label + sel.flds, sel.scan = &gq.fields, sel.Scan + return sel } func (gq *GroupQuery) prepareQuery(ctx context.Context) error { @@ -814,6 +817,7 @@ func (ggb *GroupGroupBy) sqlQuery() *sql.Selector { // GroupSelect is the builder for selecting fields of Group entities. type GroupSelect struct { *GroupQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -827,201 +831,6 @@ func (gs *GroupSelect) Scan(ctx context.Context, v interface{}) error { return gs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gs *GroupSelect) ScanX(ctx context.Context, v interface{}) { - if err := gs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Strings(ctx context.Context) ([]string, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gs *GroupSelect) StringsX(ctx context.Context) []string { - v, err := gs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gs *GroupSelect) StringX(ctx context.Context) string { - v, err := gs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Ints(ctx context.Context) ([]int, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gs *GroupSelect) IntsX(ctx context.Context) []int { - v, err := gs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gs *GroupSelect) IntX(ctx context.Context) int { - v, err := gs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gs *GroupSelect) Float64sX(ctx context.Context) []float64 { - v, err := gs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gs *GroupSelect) Float64X(ctx context.Context) float64 { - v, err := gs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gs *GroupSelect) BoolsX(ctx context.Context) []bool { - v, err := gs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gs *GroupSelect) BoolX(ctx context.Context) bool { - v, err := gs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gs *GroupSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := gs.sql.Query() diff --git a/examples/start/ent/user_query.go b/examples/start/ent/user_query.go index 15bd651a74..4bdb6af2b0 100644 --- a/examples/start/ent/user_query.go +++ b/examples/start/ent/user_query.go @@ -368,7 +368,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -880,6 +883,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -893,201 +897,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/examples/traversal/ent/ent.go b/examples/traversal/ent/ent.go index 38f0865038..d4bdf3a4b4 100644 --- a/examples/traversal/ent/ent.go +++ b/examples/traversal/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -265,3 +266,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/traversal/ent/group_query.go b/examples/traversal/ent/group_query.go index 26d2ebdf36..040c5c2f32 100644 --- a/examples/traversal/ent/group_query.go +++ b/examples/traversal/ent/group_query.go @@ -368,7 +368,10 @@ func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy { // func (gq *GroupQuery) Select(fields ...string) *GroupSelect { gq.fields = append(gq.fields, fields...) - return &GroupSelect{GroupQuery: gq} + sel := &GroupSelect{GroupQuery: gq} + sel.typ, sel.label = "Group", group.Label + sel.flds, sel.scan = &gq.fields, sel.Scan + return sel } func (gq *GroupQuery) prepareQuery(ctx context.Context) error { @@ -887,6 +890,7 @@ func (ggb *GroupGroupBy) sqlQuery() *sql.Selector { // GroupSelect is the builder for selecting fields of Group entities. type GroupSelect struct { *GroupQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -900,201 +904,6 @@ func (gs *GroupSelect) Scan(ctx context.Context, v interface{}) error { return gs.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (gs *GroupSelect) ScanX(ctx context.Context, v interface{}) { - if err := gs.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Strings(ctx context.Context) ([]string, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (gs *GroupSelect) StringsX(ctx context.Context) []string { - v, err := gs.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = gs.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (gs *GroupSelect) StringX(ctx context.Context) string { - v, err := gs.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Ints(ctx context.Context) ([]int, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (gs *GroupSelect) IntsX(ctx context.Context) []int { - v, err := gs.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = gs.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (gs *GroupSelect) IntX(ctx context.Context) int { - v, err := gs.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (gs *GroupSelect) Float64sX(ctx context.Context) []float64 { - v, err := gs.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = gs.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (gs *GroupSelect) Float64X(ctx context.Context) float64 { - v, err := gs.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bools(ctx context.Context) ([]bool, error) { - if len(gs.fields) > 1 { - return nil, errors.New("ent: GroupSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := gs.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (gs *GroupSelect) BoolsX(ctx context.Context) []bool { - v, err := gs.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (gs *GroupSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = gs.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{group.Label} - default: - err = fmt.Errorf("ent: GroupSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (gs *GroupSelect) BoolX(ctx context.Context) bool { - v, err := gs.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (gs *GroupSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := gs.sql.Query() diff --git a/examples/traversal/ent/pet_query.go b/examples/traversal/ent/pet_query.go index 8897a21453..4be070b843 100644 --- a/examples/traversal/ent/pet_query.go +++ b/examples/traversal/ent/pet_query.go @@ -368,7 +368,10 @@ func (pq *PetQuery) GroupBy(field string, fields ...string) *PetGroupBy { // func (pq *PetQuery) Select(fields ...string) *PetSelect { pq.fields = append(pq.fields, fields...) - return &PetSelect{PetQuery: pq} + sel := &PetSelect{PetQuery: pq} + sel.typ, sel.label = "Pet", pet.Label + sel.flds, sel.scan = &pq.fields, sel.Scan + return sel } func (pq *PetQuery) prepareQuery(ctx context.Context) error { @@ -887,6 +890,7 @@ func (pgb *PetGroupBy) sqlQuery() *sql.Selector { // PetSelect is the builder for selecting fields of Pet entities. type PetSelect struct { *PetQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -900,201 +904,6 @@ func (ps *PetSelect) Scan(ctx context.Context, v interface{}) error { return ps.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (ps *PetSelect) ScanX(ctx context.Context, v interface{}) { - if err := ps.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Strings(ctx context.Context) ([]string, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ps *PetSelect) StringsX(ctx context.Context) []string { - v, err := ps.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ps.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ps *PetSelect) StringX(ctx context.Context) string { - v, err := ps.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Ints(ctx context.Context) ([]int, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ps *PetSelect) IntsX(ctx context.Context) []int { - v, err := ps.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ps.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ps *PetSelect) IntX(ctx context.Context) int { - v, err := ps.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ps *PetSelect) Float64sX(ctx context.Context) []float64 { - v, err := ps.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ps.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ps *PetSelect) Float64X(ctx context.Context) float64 { - v, err := ps.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bools(ctx context.Context) ([]bool, error) { - if len(ps.fields) > 1 { - return nil, errors.New("ent: PetSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := ps.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ps *PetSelect) BoolsX(ctx context.Context) []bool { - v, err := ps.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (ps *PetSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ps.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{pet.Label} - default: - err = fmt.Errorf("ent: PetSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ps *PetSelect) BoolX(ctx context.Context) bool { - v, err := ps.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (ps *PetSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := ps.sql.Query() diff --git a/examples/traversal/ent/user_query.go b/examples/traversal/ent/user_query.go index 48ecb49ff2..77bdba0511 100644 --- a/examples/traversal/ent/user_query.go +++ b/examples/traversal/ent/user_query.go @@ -438,7 +438,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -1046,6 +1049,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -1059,201 +1063,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query() diff --git a/examples/version/ent/ent.go b/examples/version/ent/ent.go index 1685d06740..3573a1e2c0 100644 --- a/examples/version/ent/ent.go +++ b/examples/version/ent/ent.go @@ -7,6 +7,7 @@ package ent import ( + "context" "errors" "fmt" @@ -261,3 +262,205 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select builder. +type selector struct { + label, typ string + flds *[]string + scan func(context.Context, interface{}) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v interface{}) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Strings is not achievable when selecting more than 1 field", s.typ) + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Strings returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Ints is not achievable when selecting more than 1 field", s.typ) + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Ints returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Float64s is not achievable when selecting more than 1 field", s.typ) + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Float64s returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, fmt.Errorf("ent: %sSelect.Bools is not achievable when selecting more than 1 field", s.typ) + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: %sSelect.Bools returned %d results when one was expected", s.typ, len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} diff --git a/examples/version/ent/user_query.go b/examples/version/ent/user_query.go index ba7c844553..3464ea11b4 100644 --- a/examples/version/ent/user_query.go +++ b/examples/version/ent/user_query.go @@ -294,7 +294,10 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // func (uq *UserQuery) Select(fields ...string) *UserSelect { uq.fields = append(uq.fields, fields...) - return &UserSelect{UserQuery: uq} + sel := &UserSelect{UserQuery: uq} + sel.typ, sel.label = "User", user.Label + sel.flds, sel.scan = &uq.fields, sel.Scan + return sel } func (uq *UserQuery) prepareQuery(ctx context.Context) error { @@ -706,6 +709,7 @@ func (ugb *UserGroupBy) sqlQuery() *sql.Selector { // UserSelect is the builder for selecting fields of User entities. type UserSelect struct { *UserQuery + selector // intermediate query (i.e. traversal path). sql *sql.Selector } @@ -719,201 +723,6 @@ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error { return us.sqlScan(ctx, v) } -// ScanX is like Scan, but panics if an error occurs. -func (us *UserSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UserSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UserSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UserSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UserSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UserSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UserSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UserSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UserSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UserSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{user.Label} - default: - err = fmt.Errorf("ent: UserSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UserSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - func (us *UserSelect) sqlScan(ctx context.Context, v interface{}) error { rows := &sql.Rows{} query, args := us.sql.Query()