1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
{{/*
Copyright 2019-present Facebook Inc. All rights reserved.
This source code is licensed under the Apache 2.0 license found
in the LICENSE file in the root directory of this source tree.
*/}}
{{ define "delete" }}
{{ $pkg := base $.Config.Package }}
{{ template "header" $ }}
{{ template "import" $ }}
import (
"{{ $.Config.Package }}/{{ $.Package }}"
)
{{ $builder := $.DeleteName }}
{{ $receiver := receiver $builder }}
{{ $mutation := print $receiver ".mutation" }}
// {{ $builder }} is the builder for deleting a {{ $.Name }} entity.
type {{ $builder }} struct {
config
hooks []Hook
mutation *{{ $.MutationName }}
}
// Where adds a new predicate to the {{ $builder }} builder.
func ({{ $receiver }} *{{ $builder }}) Where(ps ...predicate.{{ $.Name }}) *{{ $builder }} {
{{ $mutation }}.predicates = append({{ $mutation }}.predicates, ps...)
return {{ $receiver }}
}
// Exec executes the deletion query and returns how many vertices were deleted.
func ({{ $receiver}} *{{ $builder }}) Exec(ctx context.Context) (int, error) {
var (
err error
affected int
)
if len({{ $receiver }}.hooks) == 0 {
affected, err = {{ $receiver }}.{{ $.Storage }}Exec(ctx)
} else {
var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
mutation, ok := m.(*{{ $.MutationName }})
if !ok {
return nil, fmt.Errorf("unexpected mutation type %T", m)
}
{{ $mutation }} = mutation
affected, err = {{ $receiver }}.{{ $.Storage }}Exec(ctx)
mutation.done = true
return affected, err
})
for i := len({{ $receiver }}.hooks) - 1; i >= 0; i-- {
mut = {{ $receiver }}.hooks[i](mut)
}
if _, err := mut.Mutate(ctx, {{ $mutation }}); err != nil {
return 0, err
}
}
return affected, err
}
// ExecX is like Exec, but panics if an error occurs.
func ({{ $receiver }} *{{ $builder }}) ExecX(ctx context.Context) int {
n, err := {{ $receiver }}.Exec(ctx)
if err != nil {
panic(err)
}
return n
}
{{ with extend $ "Builder" $builder }}
{{ $tmpl := printf "dialect/%s/delete" $.Storage }}
{{ xtemplate $tmpl . }}
{{ end }}
{{ $onebuilder := $.DeleteOneName }}
{{ $oneReceiver := receiver $onebuilder }}
// {{ $onebuilder }} is the builder for deleting a single {{ $.Name }} entity.
type {{ $onebuilder }} struct {
{{ $receiver }} *{{ $builder }}
}
// Exec executes the deletion query.
func ({{ $oneReceiver }} *{{ $onebuilder }}) Exec(ctx context.Context) error {
n, err := {{ $oneReceiver }}.{{ $receiver }}.Exec(ctx)
switch {
case err != nil:
return err
case n == 0:
return &NotFoundError{ {{ $.Package }}.Label}
default:
return nil
}
}
// ExecX is like Exec, but panics if an error occurs.
func ({{ $oneReceiver }} *{{ $onebuilder }}) ExecX(ctx context.Context) {
{{ $oneReceiver }}.{{ $receiver }}.ExecX(ctx)
}
{{ end }}
|
