From 83d006343715d28fa0b0e5736e3f3ba46b42bed2 Mon Sep 17 00:00:00 2001 From: Ariel Mashraki Date: Mon, 16 Sep 2019 08:45:45 -0700 Subject: [PATCH] entc/gen: returns affected rows in delete Summary: Pull Request resolved: https://github.com/facebookexternal/fbc/pull/1455 Reviewed By: alexsn Differential Revision: D17396880 fbshipit-source-id: 3a3a9849b816777bd0ef94cf55b2291705a37df6 --- dialect/gremlin/graph/dsl/__/dsl.go | 3 + entc/gen/internal/bindata.go | 94 +++++++++---------- entc/gen/template/builder/delete.tmpl | 24 +++-- entc/gen/template/dialect/gremlin/delete.tmpl | 9 +- entc/gen/template/dialect/sql/delete.tmpl | 11 ++- entc/integration/ent/card_delete.go | 45 ++++++--- entc/integration/ent/comment_delete.go | 45 ++++++--- entc/integration/ent/fieldtype_delete.go | 45 ++++++--- entc/integration/ent/file_delete.go | 45 ++++++--- entc/integration/ent/filetype_delete.go | 45 ++++++--- entc/integration/ent/group_delete.go | 45 ++++++--- entc/integration/ent/groupinfo_delete.go | 45 ++++++--- entc/integration/ent/node_delete.go | 45 ++++++--- entc/integration/ent/pet_delete.go | 45 ++++++--- entc/integration/ent/user_delete.go | 45 ++++++--- entc/integration/integration_test.go | 23 +++++ entc/integration/migrate/entv1/user_delete.go | 33 +++++-- .../integration/migrate/entv2/group_delete.go | 33 +++++-- entc/integration/migrate/entv2/pet_delete.go | 33 +++++-- entc/integration/migrate/entv2/user_delete.go | 33 +++++-- entc/integration/template/ent/group_delete.go | 33 +++++-- entc/integration/template/ent/pet_delete.go | 33 +++++-- entc/integration/template/ent/user_delete.go | 33 +++++-- entc/load/internal/bindata.go | 10 +- examples/edgeindex/ent/city_delete.go | 33 +++++-- examples/edgeindex/ent/city_query.go | 14 --- examples/edgeindex/ent/city_update.go | 10 +- examples/edgeindex/ent/client.go | 28 ++++++ examples/edgeindex/ent/street_delete.go | 33 +++++-- examples/edgeindex/ent/street_query.go | 14 --- examples/edgeindex/ent/street_update.go | 10 +- examples/m2m2types/ent/client.go | 28 ++++++ examples/m2m2types/ent/group_delete.go | 33 +++++-- examples/m2m2types/ent/group_query.go | 14 --- examples/m2m2types/ent/group_update.go | 10 +- examples/m2m2types/ent/user_delete.go | 33 +++++-- examples/m2m2types/ent/user_query.go | 14 --- examples/m2m2types/ent/user_update.go | 43 +++++++-- examples/m2mbidi/ent/client.go | 14 +++ examples/m2mbidi/ent/user_delete.go | 33 +++++-- examples/m2mbidi/ent/user_query.go | 14 --- examples/m2mbidi/ent/user_update.go | 43 +++++++-- examples/m2mrecur/ent/client.go | 14 +++ examples/m2mrecur/ent/user_delete.go | 33 +++++-- examples/m2mrecur/ent/user_query.go | 14 --- examples/m2mrecur/ent/user_update.go | 43 +++++++-- examples/o2m2types/ent/client.go | 28 ++++++ examples/o2m2types/ent/pet_delete.go | 33 +++++-- examples/o2m2types/ent/pet_query.go | 14 --- examples/o2m2types/ent/pet_update.go | 10 +- examples/o2m2types/ent/user_delete.go | 33 +++++-- examples/o2m2types/ent/user_query.go | 14 --- examples/o2m2types/ent/user_update.go | 43 +++++++-- examples/o2mrecur/ent/client.go | 14 +++ examples/o2mrecur/ent/node_delete.go | 33 +++++-- examples/o2mrecur/ent/node_query.go | 14 --- examples/o2mrecur/ent/node_update.go | 33 ++++++- examples/o2o2types/ent/card_delete.go | 33 +++++-- examples/o2o2types/ent/card_query.go | 14 --- examples/o2o2types/ent/card_update.go | 20 ++-- examples/o2o2types/ent/client.go | 28 ++++++ examples/o2o2types/ent/user_delete.go | 33 +++++-- examples/o2o2types/ent/user_query.go | 14 --- examples/o2o2types/ent/user_update.go | 43 +++++++-- examples/o2obidi/ent/client.go | 14 +++ examples/o2obidi/ent/user_delete.go | 33 +++++-- examples/o2obidi/ent/user_query.go | 14 --- examples/o2obidi/ent/user_update.go | 43 +++++++-- examples/o2orecur/ent/client.go | 14 +++ examples/o2orecur/ent/node_delete.go | 33 +++++-- examples/o2orecur/ent/node_query.go | 14 --- examples/o2orecur/ent/node_update.go | 33 ++++++- examples/traversal/ent/client.go | 42 +++++++++ examples/traversal/ent/group_delete.go | 33 +++++-- examples/traversal/ent/group_query.go | 14 --- examples/traversal/ent/group_update.go | 10 +- examples/traversal/ent/pet_delete.go | 33 +++++-- examples/traversal/ent/pet_query.go | 14 --- examples/traversal/ent/pet_update.go | 10 +- examples/traversal/ent/user_delete.go | 33 +++++-- examples/traversal/ent/user_query.go | 14 --- examples/traversal/ent/user_update.go | 43 +++++++-- 82 files changed, 1566 insertions(+), 712 deletions(-) diff --git a/dialect/gremlin/graph/dsl/__/dsl.go b/dialect/gremlin/graph/dsl/__/dsl.go index f2beef62e..da8413591 100644 --- a/dialect/gremlin/graph/dsl/__/dsl.go +++ b/dialect/gremlin/graph/dsl/__/dsl.go @@ -66,6 +66,9 @@ func OtherV() *dsl.Traversal { return New().OtherV() } // Count is the api for calling __.Count(). func Count() *dsl.Traversal { return New().Count() } +// Drop is the api for calling __.Drop(). +func Drop() *dsl.Traversal { return New().Drop() } + // Fold is the api for calling __.Fold(). func Fold() *dsl.Traversal { return New().Fold() } diff --git a/entc/gen/internal/bindata.go b/entc/gen/internal/bindata.go index 350421f22..9de1290d0 100644 --- a/entc/gen/internal/bindata.go +++ b/entc/gen/internal/bindata.go @@ -58,7 +58,7 @@ import ( func bindataRead(data []byte, name string) ([]byte, error) { gz, err := gzip.NewReader(bytes.NewBuffer(data)) if err != nil { - return nil, fmt.Errorf("Read %q: %v", name, err) + return nil, fmt.Errorf("read %q: %v", name, err) } var buf bytes.Buffer @@ -66,7 +66,7 @@ func bindataRead(data []byte, name string) ([]byte, error) { clErr := gz.Close() if err != nil { - return nil, fmt.Errorf("Read %q: %v", name, err) + return nil, fmt.Errorf("read %q: %v", name, err) } if clErr != nil { return nil, err @@ -102,7 +102,7 @@ func (fi bindataFileInfo) Mode() os.FileMode { return fi.mode } -// Mode return file modify time +// ModTime return file modify time func (fi bindataFileInfo) ModTime() time.Time { return fi.modTime } @@ -132,7 +132,7 @@ func templateBaseTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/base.tmpl", size: 5217, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/base.tmpl", size: 5217, mode: os.FileMode(420), modTime: time.Unix(1567330572, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -152,12 +152,12 @@ func templateBuilderCreateTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/builder/create.tmpl", size: 3041, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/builder/create.tmpl", size: 3041, mode: os.FileMode(420), modTime: time.Unix(1567330666, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _templateBuilderDeleteTmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x54\x51\x6b\xe4\x36\x18\x7c\xb6\x7e\xc5\xd4\x6c\xc1\x3e\x12\x6d\xee\xde\x9a\x92\x87\x6b\x2e\x85\x83\x92\x96\x5e\xa1\x81\x52\x8a\x22\x7d\xf6\xaa\x71\x24\x57\x92\x2f\xbb\x18\xff\xf7\x22\x7b\xed\xb5\xf7\xb2\xdc\x52\xfa\xb4\x5e\x49\xdf\x68\xe6\x1b\x7d\xd3\xb6\xeb\x37\xec\xd6\xd6\x3b\xa7\xcb\x4d\xc0\xbb\xab\xb7\xdf\x5d\xd6\x8e\x3c\x99\x80\x1f\x85\xa4\x47\x6b\x9f\xf0\xd1\x48\x8e\xf7\x55\x85\xfe\x90\x47\xdc\x77\x9f\x49\x71\xf6\xdb\x46\x7b\x78\xdb\x38\x49\x90\x56\x11\xb4\x47\xa5\x25\x19\x4f\x0a\x8d\x51\xe4\x10\x36\x84\xf7\xb5\x90\x1b\xc2\x3b\x7e\x35\xee\xa2\xb0\x8d\x51\x4c\x9b\x7e\xff\xa7\x8f\xb7\x77\xf7\x9f\xee\x50\xe8\x8a\xb0\x5f\x73\xd6\x06\x28\xed\x48\x06\xeb\x76\xb0\x05\xc2\xec\xb2\xe0\x88\x38\x7b\xb3\xee\x3a\xc6\xda\x16\x8a\x0a\x6d\x08\xa9\xa2\x8a\x02\xa5\xe8\xba\xb8\xba\xaa\x9f\x4a\x5c\xdf\xe0\x51\x78\xc2\x8a\xdf\x5a\x53\xe8\x92\xff\x22\xe4\x93\x28\x09\xfb\xd2\x40\xcf\x75\x25\x02\x21\xdd\x90\x50\xe4\x52\xac\xbe\xdc\xd2\xcf\xb5\x75\x61\xb6\xb5\x7a\x6c\x74\x15\xe5\x5d\xdf\xa0\x76\xda\x04\x64\xb5\xf0\x52\x54\x58\xf1\x7b\xf1\x4c\x39\xd2\x0f\x4b\x2e\x8e\x24\xe9\xcf\x43\xc5\xf4\x3d\xc1\x74\x1d\x5b\xaf\x31\x07\xee\xba\xd8\xcc\xd8\x89\x71\xa5\xb0\x0e\xbd\x40\x6d\x4a\x88\x78\x78\x71\x65\xac\x20\x13\x74\xd8\x71\x16\x76\x35\x1d\xa3\xf9\xe0\x1a\x19\xd0\xb2\x44\xf6\x8d\x60\x49\xed\x48\x69\x29\x02\x79\xfc\xf1\xe7\xf4\x87\xc7\xba\x11\x91\x75\x8c\x45\x66\xbf\x6f\xc8\x11\x84\x52\x1e\x02\x86\x5e\x30\x1d\xef\x69\xcd\x68\x72\x56\x34\x46\x22\x9b\x6b\xee\x3a\xbc\x59\xb2\xc9\x07\xc4\xac\xf6\xe0\x9c\xbf\x7e\x77\x7e\x5c\x14\xb9\x2f\x61\xf9\x4c\xc2\x0d\x44\x5d\x93\x51\xd9\xc9\x23\x17\xa8\x3d\xe7\x3c\x67\x89\xa3\xd0\x38\x83\x85\x2f\x83\xd8\xf5\x1a\x77\x5b\x92\xa0\x2d\xc9\x26\xc2\x46\x69\x43\xd7\xad\xc1\x3f\x0d\xb9\xdd\xb9\x0a\x23\x4e\x26\xc3\x16\xd2\x9a\x40\xdb\x10\x1f\x60\xfc\xcd\x41\xce\x59\x37\xa8\xb9\x84\x2e\x50\x06\x64\x15\x19\xac\xf8\xa7\x60\x9d\x28\x29\xc7\x5b\x5c\x76\x1d\x4b\x12\xff\xa2\x83\xdc\x1c\x33\xe5\xca\xc5\x2f\xfe\x41\x8b\x8a\x64\xc8\xf2\x08\xd6\xa3\x39\x61\x4a\xc2\xea\xaf\x0b\xac\xfc\x80\x15\x1f\xdc\x04\x8c\x1e\x54\xc6\x81\x68\x5b\xfc\x6d\xb5\x99\xce\x8d\x60\x1e\xe9\x05\xe2\xb3\xbd\x66\x49\x72\xa2\x53\xbd\x4f\x7e\x82\x1c\x95\xe6\x7b\x12\x64\xd4\x70\x91\xa2\x42\x34\x55\x98\x23\xf5\xda\x3d\xbf\xa7\x97\x2c\x1d\x67\xb4\xeb\xae\xd1\x18\xdf\xd4\x71\xca\x48\x41\x0d\x4c\xd2\x88\xd7\x0d\x5d\xa2\xca\xd3\xbe\x25\xa7\x29\x69\xa3\x68\x3b\x13\x7b\xb5\xe4\x36\xa3\x76\x70\xfa\x61\xc8\xac\x27\xea\xff\x5d\xe0\xb1\x09\xa8\x85\xd1\xd2\x47\x67\xc4\x9e\x30\xac\x94\x8d\xf3\xaf\x59\x8f\x53\xde\x3f\xbc\x6e\x7e\xcb\x12\x5d\x44\xd4\x68\xcc\xb1\x88\x89\xed\xf7\xfd\x89\x6f\x6e\x60\x74\xd5\x9b\xdb\x73\xca\xc8\xb9\x9c\x25\x3d\xff\x73\xdd\x6e\x5b\xbc\xe8\xb0\x01\x6d\x43\x14\xbf\x42\xfa\xc3\x40\x34\x5d\xc4\x4f\xd2\x8f\x56\x78\xae\xab\x29\xd3\x0a\xa4\x7b\x27\xd6\xdf\xfa\xf5\x98\xad\x33\xdf\x87\xa2\xed\x94\x93\x43\x39\x1f\xaf\xdd\xf7\xfa\xf0\xd5\x07\xa1\x35\xf4\x45\x78\x4e\x44\xd2\x9f\xcd\x21\x32\xad\xa1\x5f\x5f\x4d\xcd\x19\x44\x37\x38\x79\x04\xfc\xd5\xf0\xf4\xda\x94\xd5\x10\x91\xa7\xc3\x73\x09\x78\xc8\xcf\xaf\xb8\xff\x1f\x62\x64\xae\x74\x04\x5c\xdc\x7e\x56\x9a\xcc\x06\x63\x09\xc8\x4f\x3e\xb3\xff\x63\x10\xce\x24\x7f\x7a\x1c\xce\x24\xfc\x30\x31\x3e\xbc\xa8\x7f\x03\x00\x00\xff\xff\x15\xa5\xdb\x9e\xc0\x08\x00\x00") +var _templateBuilderDeleteTmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x56\x41\x6f\xe3\x36\x17\x3c\x9b\xbf\x62\x3e\xc1\x5f\x61\x07\x09\x9d\xdd\x5b\x03\xf8\xb0\xcd\x66\x81\x05\x16\x69\xd1\x2d\xd0\x00\x45\x51\x30\xe4\x93\xcd\x46\x21\x55\x92\x8a\x6d\x08\xfa\xef\x05\x45\x49\x96\x92\x78\x37\x87\x9e\x22\x89\xe4\x70\xde\xbc\x79\x13\xd7\xf5\xea\x8c\x5d\xdb\xf2\xe0\xf4\x66\x1b\xf0\xfe\xf2\xdd\x8f\x17\xa5\x23\x4f\x26\xe0\x93\x90\x74\x6f\xed\x03\x3e\x1b\xc9\xf1\xa1\x28\xd0\x6e\xf2\x88\xeb\xee\x89\x14\x67\xbf\x6d\xb5\x87\xb7\x95\x93\x04\x69\x15\x41\x7b\x14\x5a\x92\xf1\xa4\x50\x19\x45\x0e\x61\x4b\xf8\x50\x0a\xb9\x25\xbc\xe7\x97\xfd\x2a\x72\x5b\x19\xc5\xb4\x69\xd7\xbf\x7c\xbe\xbe\xb9\xfd\x7a\x83\x5c\x17\x84\xee\x9b\xb3\x36\x40\x69\x47\x32\x58\x77\x80\xcd\x11\x46\x97\x05\x47\xc4\xd9\xd9\xaa\x69\x18\xab\x6b\x28\xca\xb5\x21\x64\x8a\x0a\x0a\x94\xa1\x69\xe2\xd7\x79\xf9\xb0\xc1\xd5\x1a\xf7\xc2\x13\xe6\xfc\xda\x9a\x5c\x6f\xf8\x2f\x42\x3e\x88\x0d\xa1\x3b\x1a\xe8\xb1\x2c\x44\x20\x64\x5b\x12\x8a\x5c\x86\xf9\xcb\x25\xfd\x58\x5a\x17\x46\x4b\xf3\xfb\x4a\x17\xb1\xbc\xab\x35\x4a\xa7\x4d\xc0\xa2\x14\x5e\x8a\x02\x73\x7e\x2b\x1e\x69\x89\xec\xe3\x94\x8b\x23\x49\xfa\x29\x9d\x18\x9e\x07\x98\xa6\x61\xab\x15\xc6\xc0\x4d\x13\xc5\x8c\x4a\xf4\x5f\x72\xeb\xd0\x16\xa8\xcd\x06\x22\x6e\x9e\x5c\x19\x4f\x90\x09\x3a\x1c\x38\x0b\x87\x92\x9e\xa3\xf9\xe0\x2a\x19\x50\xb3\x99\x6c\x85\x60\xb3\xd2\x91\xd2\x52\x04\xf2\xf8\xe3\xcf\xe1\x85\xc7\x73\x3d\x22\x6b\x18\x8b\xcc\x7e\xdf\x92\x23\x08\xa5\x3c\x04\x0c\xed\x30\x6c\x47\xb0\x2d\xcb\x24\x7d\x4f\x96\xb3\xbc\x32\x12\x8b\x71\xe5\x4d\x83\xb3\x29\xa7\x65\xc2\x5d\x94\x1e\x9c\xf3\xd7\x19\x2c\x9f\x1f\x8a\x15\x4c\x61\xf9\xa8\x90\x35\x44\x59\x92\x51\x8b\x93\x5b\xce\x51\x7a\xce\xf9\x92\xcd\x1c\x85\xca\x19\x4c\xba\x93\x4a\x5e\xad\x70\xb3\x27\x09\xda\x93\xac\x22\xec\x50\xa1\xb6\x06\xff\x54\xe4\x0e\x10\x46\x21\x21\x78\x6c\xed\x0e\x8f\xc2\x1c\xf0\x44\x2e\x68\x49\x1e\xbb\xa8\x57\xd2\x44\xbd\x55\x8c\x78\xe5\x42\x86\x3d\xa4\x35\x81\xf6\x21\x3a\x36\xfe\x5d\x62\xa1\x4d\x38\x07\x39\x67\xdd\x32\xd5\x7f\x01\x9d\x63\x13\xb0\x28\xc8\x60\xce\xbf\x06\xeb\xc4\x86\x96\x78\x87\x8b\xa6\x61\xb3\x99\xdf\xe9\x20\xb7\xcf\x6b\xe3\xca\xc5\x27\xfe\x51\x8b\x82\x64\x58\xb4\x60\x2d\x9a\x13\x66\x43\x98\xff\x75\x8e\xb9\x4f\x58\xd1\xa8\x03\x30\x5a\x50\x19\x07\xa9\xae\xf1\xb7\xd5\x66\xd8\xd7\x83\x79\x64\xe7\x88\x76\xbf\x62\xb3\xd9\x09\x6d\xdb\xce\xfa\x01\xb2\x2f\x78\xd9\x91\x20\xa3\xd2\x45\x8a\x72\x51\x15\x61\x8c\x74\xd9\xd5\xef\xf9\x2d\xed\x16\x59\x3f\xde\x4d\x73\x85\xca\xf8\xaa\x8c\x03\x4a\x0a\x2a\x91\xc9\x22\x64\x93\x84\xa2\xc2\x53\xa7\xca\x69\x56\xda\x28\xda\x8f\xea\xbd\x9c\xd2\x1b\xb1\x3b\xda\xe3\x2e\xc5\xdd\x03\xb5\x6f\xe7\xb8\xaf\x02\x4a\x61\xb4\xf4\xb1\x39\xc2\x24\xc2\xb0\x52\x56\xce\xbf\x66\x02\x9c\x72\xc1\xdd\xeb\x36\x88\x39\x53\xb3\x99\x69\xa5\x88\xfd\x79\x5e\xc8\x88\xb1\xce\xdb\x4d\xff\x5b\xc3\xe8\xa2\x6d\x73\x4b\x6d\x41\xce\x2d\x59\x94\xa6\xd3\xc2\xb0\x36\xd1\xde\xe6\x80\xba\xc6\x4e\x87\x2d\x68\x1f\xa2\x1a\x73\x64\x3f\x25\xe6\xd9\x24\xca\x66\xed\x80\x86\xc7\xb2\x18\xf2\x31\x47\xd6\xb5\x66\xf5\x7f\xbf\xea\x73\x7a\xe4\x85\x74\x68\x3f\x64\x6e\x3a\xce\xfb\x6b\x3b\xf1\x8f\x4f\x6d\xa8\x5a\x43\x2f\x82\x78\x20\x92\xfd\x6c\x8e\xf1\x6b\x0d\xfd\xfa\x6a\x02\x8f\x20\x9a\xd4\xda\x67\xc0\xdf\x0d\x62\xaf\xcd\xa6\x48\x71\x7b\x3a\x88\xa7\x80\xc7\x2c\xfe\x8e\x1d\xde\x18\x46\x63\x73\x8d\x2b\xed\x01\x27\xb7\x7f\x2b\x68\x92\x63\x5f\x78\x6c\x8a\xc9\xbf\x61\xbb\x3e\x77\x58\x0a\x8b\xa3\x05\xaf\x8e\xe3\x47\xce\x75\xcb\x06\xeb\x35\x2e\x47\x4b\x3f\xdc\x38\x77\x6b\xc3\xa7\xf8\xeb\xa0\x4e\x92\x1e\xff\x5f\xf3\x2f\xe2\x9e\x8a\x86\x8d\xe3\xa1\x77\xb1\x2e\xa2\xa9\xff\x83\xd9\x7c\xa3\x7c\x27\x26\xb4\xeb\xe8\x1b\xf4\xba\x4b\x82\x25\x23\x77\x9e\xfe\x37\x00\x00\xff\xff\x24\x2d\x08\xf6\x8e\x09\x00\x00") func templateBuilderDeleteTmplBytes() ([]byte, error) { return bindataRead( @@ -172,7 +172,7 @@ func templateBuilderDeleteTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/builder/delete.tmpl", size: 2240, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/builder/delete.tmpl", size: 2446, mode: os.FileMode(420), modTime: time.Unix(1568645716, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -192,7 +192,7 @@ func templateBuilderQueryTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/builder/query.tmpl", size: 16113, mode: os.FileMode(420), modTime: time.Unix(1568643142, 0)} + info := bindataFileInfo{name: "template/builder/query.tmpl", size: 16113, mode: os.FileMode(420), modTime: time.Unix(1568645715, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -212,7 +212,7 @@ func templateBuilderSetterTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/builder/setter.tmpl", size: 4126, mode: os.FileMode(420), modTime: time.Unix(1568557285, 0)} + info := bindataFileInfo{name: "template/builder/setter.tmpl", size: 4126, mode: os.FileMode(420), modTime: time.Unix(1568541190, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -232,7 +232,7 @@ func templateBuilderUpdateTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/builder/update.tmpl", size: 8088, mode: os.FileMode(420), modTime: time.Unix(1568557285, 0)} + info := bindataFileInfo{name: "template/builder/update.tmpl", size: 8088, mode: os.FileMode(420), modTime: time.Unix(1568541142, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -252,7 +252,7 @@ func templateClientTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/client.tmpl", size: 5477, mode: os.FileMode(420), modTime: time.Unix(1568643142, 0)} + info := bindataFileInfo{name: "template/client.tmpl", size: 5477, mode: os.FileMode(420), modTime: time.Unix(1568645715, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -272,7 +272,7 @@ func templateConfigTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/config.tmpl", size: 1254, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/config.tmpl", size: 1254, mode: os.FileMode(420), modTime: time.Unix(1567330565, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -292,7 +292,7 @@ func templateContextTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/context.tmpl", size: 719, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/context.tmpl", size: 719, mode: os.FileMode(420), modTime: time.Unix(1567330561, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -312,7 +312,7 @@ func templateDialectGremlinByTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/gremlin/by.tmpl", size: 1875, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/gremlin/by.tmpl", size: 1875, mode: os.FileMode(420), modTime: time.Unix(1567330626, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -332,7 +332,7 @@ func templateDialectGremlinCreateTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/gremlin/create.tmpl", size: 2763, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/gremlin/create.tmpl", size: 2763, mode: os.FileMode(420), modTime: time.Unix(1567330629, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -352,12 +352,12 @@ func templateDialectGremlinDecodeTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/gremlin/decode.tmpl", size: 2120, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/gremlin/decode.tmpl", size: 2120, mode: os.FileMode(420), modTime: time.Unix(1567330632, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _templateDialectGremlinDeleteTmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x91\x51\x6b\xdb\x3c\x14\x86\xaf\xad\x5f\x71\x28\xe5\xc3\x0e\xf9\x94\xae\x77\x1b\xec\xa2\xcb\x32\x56\x28\x63\x5b\xcb\x6e\x87\x22\xbd\x76\x44\x35\xc9\x3b\x92\x43\x82\xd1\x7f\x1f\x72\xdd\x90\xad\x63\x57\x16\x3a\xcf\x39\xe7\x79\xad\x71\x5c\x2d\xc4\x3a\xf4\x47\xb6\xdd\x2e\xd1\xf5\xd5\xab\xd7\xff\xf7\x8c\x08\x9f\xe8\x83\xd2\xd8\x86\xf0\x48\xb7\x5e\x4b\xba\x71\x8e\x26\x28\x52\xa9\xf3\x1e\x46\x8a\x87\x9d\x8d\x14\xc3\xc0\x1a\xa4\x83\x01\xd9\x48\xce\x6a\xf8\x08\x43\x83\x37\x60\x4a\x3b\xd0\x4d\xaf\xf4\x0e\x74\x2d\xaf\x9e\xab\xd4\x86\xc1\x1b\x61\xfd\x54\xbf\xbb\x5d\x6f\x3e\xdd\x6f\xa8\xb5\x0e\x34\xdf\x71\x08\x89\x8c\x65\xe8\x14\xf8\x48\xa1\xa5\x74\xb6\x2c\x31\x20\xc5\x62\x95\xb3\x10\xe3\x48\x06\xad\xf5\xa0\x0b\x63\x95\x83\x4e\xab\x8e\xf1\xc3\x59\xbf\x32\x70\x48\xb8\xa0\x9c\x0b\x75\xb9\x1d\xac\x2b\x4e\x6f\xde\x52\xaf\xa2\x56\x8e\x2e\xe5\xbd\x0e\x3d\xe4\xbb\xb9\x32\x83\x0c\x0d\xbb\x7f\x22\x4f\xe7\x53\x7b\x59\xda\x0e\x5e\x53\x7d\xce\xe6\x4c\x8b\xf3\x25\x39\x37\x34\x7b\x6c\x0e\xd0\xb5\x4e\x07\xd2\xc1\x27\x1c\x92\x5c\x3f\x7d\x1b\x02\x73\x60\x1a\x45\xc5\x88\x65\xd9\x7f\x73\x87\xfc\x8a\xd8\x07\x1f\x31\x66\x51\xfd\x1c\xc0\xc7\x25\x6d\xad\x37\xd6\x77\x13\xf7\x9b\x64\xce\x72\x6e\xab\x1b\xf9\xa5\xc0\x75\x53\x26\xa6\x81\xfd\x0b\xd2\x70\x39\xc9\x67\xa5\x25\xfd\x31\x7d\x59\x9e\xb7\x11\x59\xfc\x2d\x23\xfd\x23\x64\xdd\xd0\xc2\x44\x27\x1f\x58\xed\xc1\x51\xb9\x12\x2b\x15\xd9\x4e\x7e\xab\x1b\xf9\x51\xc5\x3b\xb5\x85\x9b\x06\xca\xcf\x4a\x3f\xaa\x0e\xc5\x68\xba\x6d\x44\xd5\x06\xa6\xef\x4b\xea\xa7\x9f\xae\x7c\x87\x17\xee\x3d\xc3\x58\xad\x12\x62\x99\x5d\xf5\x75\x6a\x44\x95\x4f\x51\x93\x7c\xcf\xa1\xaf\x8b\xfc\x38\x12\xbc\xa1\x9c\x7f\x05\x00\x00\xff\xff\x84\x70\xf5\x99\xe1\x02\x00\x00") +var _templateDialectGremlinDeleteTmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x91\x41\x6f\x13\x31\x10\x85\xcf\xeb\x5f\x31\x54\x15\xb2\xa3\xc5\x29\xbd\x01\xea\xa1\x84\x20\x22\x55\x08\x9a\x8a\x6b\xe4\xd8\xb3\x1b\xab\xc6\x5e\xc6\xde\x28\xd1\xca\xff\x1d\x79\xbb\xa9\x02\x54\x9c\x6c\xcd\x7c\xe3\xf7\x9e\x67\x18\xe6\x33\xb6\x08\xdd\x91\x6c\xbb\x4b\x70\x7d\xf5\xf6\xdd\x9b\x8e\x30\xa2\x4f\xf0\x59\x69\xdc\x86\xf0\x08\x2b\xaf\x25\xdc\x3a\x07\x23\x14\xa1\xf4\x69\x8f\x46\xb2\x87\x9d\x8d\x10\x43\x4f\x1a\x41\x07\x83\x60\x23\x38\xab\xd1\x47\x34\xd0\x7b\x83\x04\x69\x87\x70\xdb\x29\xbd\x43\xb8\x96\x57\xa7\x2e\x34\xa1\xf7\x86\x59\x3f\xf6\xef\x56\x8b\xe5\xd7\xf5\x12\x1a\xeb\x10\xa6\x1a\x85\x90\xc0\x58\x42\x9d\x02\x1d\x21\x34\x90\xce\xc4\x12\x21\x4a\x36\x9b\xe7\xcc\xd8\x30\x80\xc1\xc6\x7a\x84\x0b\x63\x95\x43\x9d\xe6\x2d\xe1\x4f\x67\xfd\xdc\xa0\xc3\x84\x17\x90\x73\xa1\x2e\xb7\xbd\x75\xc5\xd3\xfb\x1b\xe8\x54\xd4\xca\xc1\xa5\x5c\xeb\xd0\xa1\xfc\x38\x75\x26\x90\x50\xa3\xdd\x3f\x91\xcf\xf7\xe7\xf1\x22\xda\xf4\x5e\x03\x3f\x67\x73\x86\xd9\xb9\x48\xce\x02\x26\x1f\xcb\x03\x6a\xae\xd3\x01\x74\xf0\x09\x0f\x49\x2e\x9e\x4e\x01\xdc\xfa\x54\x03\x12\x05\x12\x30\xb0\x8a\x30\x16\xcd\xd7\xd3\xa0\xbc\xc7\xd8\x05\x1f\x71\xc8\xac\xfa\xd5\x23\x1d\x6b\xd8\x5a\x6f\xac\x6f\x47\xee\x0f\xaf\x39\xcb\x69\x8c\x0b\xf9\xbd\xc0\x5c\xb0\xca\x36\xe5\xf9\x97\x60\x43\xe5\x26\x4f\xe6\x6a\xf8\x4b\xa0\x2e\x8b\x16\x1f\xc6\xf1\x57\x37\xe0\xad\x2b\x0e\x2b\xc2\xd4\x93\x87\xab\xd1\x36\xab\x32\x3b\x55\x08\xa3\xbc\x47\x65\x56\x3e\x71\xc1\x32\x7b\xe9\x93\xe0\x3f\xbf\xc4\x05\xcc\x4c\x74\xf2\x81\xd4\x1e\x29\xaa\x51\x2e\x15\xe7\xad\xfc\xc1\x85\xfc\xa2\xe2\x9d\xda\xa2\x1b\x1f\x94\xdf\x94\x7e\x54\x2d\x96\x20\x63\x55\xb0\xaa\x09\x04\x9b\x1a\xba\x71\x6b\xca\xb7\xf8\x4f\xe4\x8e\xd0\x58\xad\x12\xc6\x31\x4a\xc7\x93\x38\x4f\x90\xe4\xda\x1a\x5c\x36\x0d\xea\xc4\x37\x1b\xf9\x89\x42\xc7\x85\x90\x8b\xd0\x4f\x99\x86\x01\xd0\x1b\xc8\xf9\x77\x00\x00\x00\xff\xff\xfa\x87\x8a\x9c\x39\x03\x00\x00") func templateDialectGremlinDeleteTmplBytes() ([]byte, error) { return bindataRead( @@ -372,7 +372,7 @@ func templateDialectGremlinDeleteTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/gremlin/delete.tmpl", size: 737, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/gremlin/delete.tmpl", size: 825, mode: os.FileMode(420), modTime: time.Unix(1568645716, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -392,7 +392,7 @@ func templateDialectGremlinErrorsTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/gremlin/errors.tmpl", size: 1804, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/gremlin/errors.tmpl", size: 1804, mode: os.FileMode(420), modTime: time.Unix(1567330638, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -412,7 +412,7 @@ func templateDialectGremlinGroupTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/gremlin/group.tmpl", size: 1347, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/gremlin/group.tmpl", size: 1347, mode: os.FileMode(420), modTime: time.Unix(1567526275, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -432,7 +432,7 @@ func templateDialectGremlinMetaTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/gremlin/meta.tmpl", size: 704, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/gremlin/meta.tmpl", size: 704, mode: os.FileMode(420), modTime: time.Unix(1567330643, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -452,7 +452,7 @@ func templateDialectGremlinPredicateTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/gremlin/predicate.tmpl", size: 3313, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/gremlin/predicate.tmpl", size: 3313, mode: os.FileMode(420), modTime: time.Unix(1567330647, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -472,7 +472,7 @@ func templateDialectGremlinQueryTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/gremlin/query.tmpl", size: 3929, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/gremlin/query.tmpl", size: 3929, mode: os.FileMode(420), modTime: time.Unix(1567330650, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -492,7 +492,7 @@ func templateDialectGremlinSelectTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/gremlin/select.tmpl", size: 1078, mode: os.FileMode(420), modTime: time.Unix(1567611994, 0)} + info := bindataFileInfo{name: "template/dialect/gremlin/select.tmpl", size: 1078, mode: os.FileMode(420), modTime: time.Unix(1567600027, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -512,7 +512,7 @@ func templateDialectGremlinUpdateTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/gremlin/update.tmpl", size: 6095, mode: os.FileMode(420), modTime: time.Unix(1568557285, 0)} + info := bindataFileInfo{name: "template/dialect/gremlin/update.tmpl", size: 6095, mode: os.FileMode(420), modTime: time.Unix(1568542264, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -532,7 +532,7 @@ func templateDialectSqlByTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/sql/by.tmpl", size: 949, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/sql/by.tmpl", size: 949, mode: os.FileMode(420), modTime: time.Unix(1567330589, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -552,7 +552,7 @@ func templateDialectSqlCreateTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/sql/create.tmpl", size: 6262, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/sql/create.tmpl", size: 6262, mode: os.FileMode(420), modTime: time.Unix(1567330593, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -572,12 +572,12 @@ func templateDialectSqlDecodeTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/sql/decode.tmpl", size: 2016, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/sql/decode.tmpl", size: 2016, mode: os.FileMode(420), modTime: time.Unix(1567330596, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _templateDialectSqlDeleteTmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x74\x91\x4f\x8b\xdb\x30\x14\xc4\xcf\xd6\xa7\x18\x96\xa5\xd8\x21\x55\xb6\x7b\x6b\xa1\x87\x6d\x9a\x85\x85\x52\xda\x66\xef\x45\x91\x9e\x13\x11\x55\x72\x9e\xe4\x90\x60\xf4\xdd\x8b\x9c\x3f\xa4\x94\x3d\x59\x9e\x19\x6b\x7e\xef\x79\x18\x66\x13\x31\x0f\xdd\x91\xed\x7a\x93\xf0\xf8\xf0\xe1\xe3\xfb\x8e\x29\x92\x4f\x78\x56\x9a\x56\x21\x6c\xf1\xe2\xb5\xc4\x93\x73\x18\x43\x11\xc5\xe7\x3d\x19\x29\x5e\x37\x36\x22\x86\x9e\x35\x41\x07\x43\xb0\x11\xce\x6a\xf2\x91\x0c\x7a\x6f\x88\x91\x36\x84\xa7\x4e\xe9\x0d\xe1\x51\x3e\x5c\x5c\xb4\xa1\xf7\x46\x58\x3f\xfa\xdf\x5e\xe6\x8b\xef\xcb\x05\x5a\xeb\x08\x67\x8d\x43\x48\x30\x96\x49\xa7\xc0\x47\x84\x16\xe9\xa6\x2c\x31\x91\x14\x93\x59\xce\x42\x0c\x03\x0c\xb5\xd6\x13\xee\x8c\x55\x8e\x74\x9a\xc5\x9d\x9b\x19\x72\x94\xe8\x0e\x39\x97\xc4\xfd\xaa\xb7\xae\xf0\x7c\xfa\x8c\x4e\x45\xad\x1c\xee\xe5\x52\x87\x8e\xe4\x97\xb3\x73\x0e\x32\x69\xb2\xfb\x53\xf2\x7a\xbe\x7e\x5e\x0a\xdb\xde\x6b\xd4\xb7\xd9\x9c\x31\xb9\x2d\xc9\xb9\x41\xdc\xb9\xc5\x81\x74\xad\xd3\x01\x3a\xf8\x44\x87\x24\xe7\xa7\x67\x03\x62\x0e\x8c\x41\x54\x7b\xc5\x65\x9f\x25\x2d\x7f\x51\xec\x5d\x12\x55\x24\x37\x4e\x5d\x08\x8a\xbe\x1c\xdf\xeb\x46\x3e\x73\xf8\x53\x17\xe5\x55\xad\x1c\x8d\x04\xf2\x87\xd2\x5b\xb5\x26\xe4\x7c\x52\x9b\x46\x54\x6d\x60\xfc\x9e\xa2\x1b\x47\x50\x7e\x4d\xf8\x67\xb0\x9c\x65\xc7\x64\xac\x56\x89\x62\x81\xa8\xba\xfa\xd2\xd9\x88\x2a\x8b\x6a\xd7\x13\x1f\xa7\x50\xbc\x8e\x17\x88\xaf\xe3\x3a\xdf\xe8\x1c\xc9\xce\x98\xd7\x9b\xe4\xcf\x72\x4b\xdd\x88\x8a\x29\xf5\xec\xff\x83\x30\x5c\x4e\xf2\xb2\xa5\x29\x6e\x6a\xa7\x78\xc7\x14\x1b\x71\xfa\xbf\xe4\x0d\x72\xfe\x1b\x00\x00\xff\xff\xa5\x96\xc0\x06\xad\x02\x00\x00") +var _templateDialectSqlDeleteTmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x92\x41\x6f\x13\x31\x10\x85\xcf\xeb\x5f\x31\x54\x15\x5a\x47\x8b\x13\x7a\x03\xd4\x43\x08\xa9\x54\x09\x21\x68\x7a\x47\x8e\x3d\x9b\x58\x35\xf6\x66\xec\x0d\x89\x22\xff\x77\x64\x67\x37\x0a\x48\xf4\x14\x67\xe6\xcd\x7b\xdf\x8c\xf6\x74\x9a\x4e\xd8\xc2\x77\x47\x32\x9b\x6d\x84\xbb\xd9\xfb\x0f\xef\x3a\xc2\x80\x2e\xc2\x83\x54\xb8\xf6\xfe\x05\x1e\x9d\x12\x30\xb7\x16\x8a\x28\x40\xee\xd3\x1e\xb5\x60\xcf\x5b\x13\x20\xf8\x9e\x14\x82\xf2\x1a\xc1\x04\xb0\x46\xa1\x0b\xa8\xa1\x77\x1a\x09\xe2\x16\x61\xde\x49\xb5\x45\xb8\x13\xb3\xb1\x0b\xad\xef\x9d\x66\xc6\x95\xfe\xd7\xc7\xc5\xf2\xdb\x6a\x09\xad\xb1\x08\x43\x8d\xbc\x8f\xa0\x0d\xa1\x8a\x9e\x8e\xe0\x5b\x88\x57\x61\x91\x10\x05\x9b\x4c\x53\x62\xec\x74\x02\x8d\xad\x71\x08\x37\xda\x48\x8b\x2a\x4e\xc3\xce\x4e\x35\x5a\x8c\x78\x03\x29\x65\xc5\xed\xba\x37\x36\xf3\x7c\xbc\x87\x4e\x06\x25\x2d\xdc\x8a\x95\xf2\x1d\x8a\xcf\x43\x67\x10\x12\x2a\x34\xfb\xb3\xf2\xf2\xbe\x8c\xe7\xc0\xb6\x77\x0a\xea\x6b\x6d\x4a\x30\xb9\x0e\x49\x89\x43\xd8\xd9\xe5\x01\x55\xad\xe2\x01\x94\x77\x11\x0f\x51\x2c\xce\xbf\x1c\x6a\xe3\x62\x03\x48\xe4\x89\xc3\x89\x55\x7b\x49\xf9\xac\x79\x48\x3c\x61\xe8\x6d\x64\x55\x40\x5b\x96\xcf\x20\xb9\xbe\x2a\xff\x6b\x2e\x1e\xc8\xff\xaa\x73\xe5\x59\xae\x2d\x16\x10\xf1\x5d\xaa\x17\xb9\x41\x48\xe9\x5c\xe5\x9c\x55\xad\x27\xf8\xd9\x40\x57\x36\x91\x6e\x83\xf0\xd7\x7e\x29\x89\x8e\x50\x1b\x25\x23\x86\x0c\x51\x75\xf5\x98\xc9\x59\x95\x58\xb5\xeb\x91\x8e\x0d\x48\xda\x84\x11\xe2\x4b\xb9\xea\x7f\x32\x0b\xd9\x80\x79\x71\x12\x3f\xb2\x4b\xcd\x59\x65\xda\xbc\x71\x76\xfa\x97\x43\x53\x7e\x89\xf1\x5e\x0d\x5c\x25\x37\xf0\x96\x30\xf0\x4f\x65\xf6\xcd\x3d\x38\x63\x0b\x2c\x61\xec\xc9\xc1\xac\x9c\xb1\xe0\xca\xb6\x45\x15\x51\x37\x63\x0c\x61\x10\x4f\xfe\x77\x98\x0f\x8d\x2b\x88\x57\x8d\x86\x8a\x71\xb1\x1e\x3d\x79\x93\xf5\xec\xfc\xb9\xa1\xd3\x90\xd2\x9f\x00\x00\x00\xff\xff\x3b\x33\xcd\x35\x3c\x03\x00\x00") func templateDialectSqlDeleteTmplBytes() ([]byte, error) { return bindataRead( @@ -592,7 +592,7 @@ func templateDialectSqlDeleteTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/sql/delete.tmpl", size: 685, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/sql/delete.tmpl", size: 828, mode: os.FileMode(420), modTime: time.Unix(1568645716, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -612,7 +612,7 @@ func templateDialectSqlErrorsTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/sql/errors.tmpl", size: 967, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/sql/errors.tmpl", size: 967, mode: os.FileMode(420), modTime: time.Unix(1567330602, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -632,7 +632,7 @@ func templateDialectSqlGroupTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/sql/group.tmpl", size: 1031, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/sql/group.tmpl", size: 1031, mode: os.FileMode(420), modTime: time.Unix(1567330605, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -652,7 +652,7 @@ func templateDialectSqlMetaTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/sql/meta.tmpl", size: 1782, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/sql/meta.tmpl", size: 1782, mode: os.FileMode(420), modTime: time.Unix(1567330610, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -672,7 +672,7 @@ func templateDialectSqlPredicateTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/sql/predicate.tmpl", size: 4526, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/sql/predicate.tmpl", size: 4526, mode: os.FileMode(420), modTime: time.Unix(1567330614, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -692,7 +692,7 @@ func templateDialectSqlQueryTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/sql/query.tmpl", size: 6382, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/dialect/sql/query.tmpl", size: 6382, mode: os.FileMode(420), modTime: time.Unix(1567330617, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -712,7 +712,7 @@ func templateDialectSqlSelectTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/sql/select.tmpl", size: 809, mode: os.FileMode(420), modTime: time.Unix(1567611994, 0)} + info := bindataFileInfo{name: "template/dialect/sql/select.tmpl", size: 809, mode: os.FileMode(420), modTime: time.Unix(1567539807, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -732,7 +732,7 @@ func templateDialectSqlUpdateTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/sql/update.tmpl", size: 12520, mode: os.FileMode(420), modTime: time.Unix(1568557285, 0)} + info := bindataFileInfo{name: "template/dialect/sql/update.tmpl", size: 12520, mode: os.FileMode(420), modTime: time.Unix(1568542538, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -752,7 +752,7 @@ func templateEntTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/ent.tmpl", size: 3821, mode: os.FileMode(420), modTime: time.Unix(1567955626, 0)} + info := bindataFileInfo{name: "template/ent.tmpl", size: 3821, mode: os.FileMode(420), modTime: time.Unix(1567952289, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -772,7 +772,7 @@ func templateExampleTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/example.tmpl", size: 2425, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/example.tmpl", size: 2425, mode: os.FileMode(420), modTime: time.Unix(1567330554, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -792,7 +792,7 @@ func templateHeaderTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/header.tmpl", size: 436, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/header.tmpl", size: 436, mode: os.FileMode(420), modTime: time.Unix(1567330551, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -812,7 +812,7 @@ func templateImportTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/import.tmpl", size: 858, mode: os.FileMode(420), modTime: time.Unix(1567955626, 0)} + info := bindataFileInfo{name: "template/import.tmpl", size: 858, mode: os.FileMode(420), modTime: time.Unix(1567952289, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -832,7 +832,7 @@ func templateMetaTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/meta.tmpl", size: 2824, mode: os.FileMode(420), modTime: time.Unix(1568643141, 0)} + info := bindataFileInfo{name: "template/meta.tmpl", size: 2824, mode: os.FileMode(420), modTime: time.Unix(1568625940, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -852,7 +852,7 @@ func templateMigrateMigrateTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/migrate/migrate.tmpl", size: 2450, mode: os.FileMode(420), modTime: time.Unix(1567955626, 0)} + info := bindataFileInfo{name: "template/migrate/migrate.tmpl", size: 2450, mode: os.FileMode(420), modTime: time.Unix(1567952288, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -872,7 +872,7 @@ func templateMigrateSchemaTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/migrate/schema.tmpl", size: 3677, mode: os.FileMode(420), modTime: time.Unix(1568643141, 0)} + info := bindataFileInfo{name: "template/migrate/schema.tmpl", size: 3677, mode: os.FileMode(420), modTime: time.Unix(1568627323, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -892,7 +892,7 @@ func templatePredicateTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/predicate.tmpl", size: 1213, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/predicate.tmpl", size: 1213, mode: os.FileMode(420), modTime: time.Unix(1567330539, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -912,7 +912,7 @@ func templateTxTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/tx.tmpl", size: 3382, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/tx.tmpl", size: 3382, mode: os.FileMode(420), modTime: time.Unix(1567330536, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -932,7 +932,7 @@ func templateWhereTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/where.tmpl", size: 5099, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/where.tmpl", size: 5099, mode: os.FileMode(420), modTime: time.Unix(1567957074, 0)} a := &asset{bytes: bytes, info: info} return a, nil } diff --git a/entc/gen/template/builder/delete.tmpl b/entc/gen/template/builder/delete.tmpl index 18c1031d0..8173e6336 100644 --- a/entc/gen/template/builder/delete.tmpl +++ b/entc/gen/template/builder/delete.tmpl @@ -20,14 +20,14 @@ type {{ $builder }} struct { } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func ({{ $receiver}} *{{ $builder }}) Where(ps ...predicate.{{ $.Name }}) *{{ $builder }} { {{ $receiver}}.predicates = append({{ $receiver}}.predicates, ps...) return {{ $receiver }} } -// Exec executes the deletion query. -func ({{ $receiver}} *{{ $builder }}) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func ({{ $receiver}} *{{ $builder }}) Exec(ctx context.Context) (int, error) { {{- if gt (len $.Storage) 1 -}} switch {{ $receiver }}.driver.Dialect() { {{- range $_, $storage := $.Storage }} @@ -35,7 +35,7 @@ func ({{ $receiver}} *{{ $builder }}) Exec(ctx context.Context) error { return {{ $receiver }}.{{ $storage }}Exec(ctx) {{- end }} default: - return errors.New("{{ $pkg }}: unsupported dialect") + return 0, errors.New("{{ $pkg }}: unsupported dialect") } {{- else -}} return {{ $receiver }}.{{ index $.Storage 0 }}Exec(ctx) @@ -43,10 +43,12 @@ func ({{ $receiver}} *{{ $builder }}) Exec(ctx context.Context) error { } // ExecX is like Exec, but panics if an error occurs. -func ({{ $receiver }} *{{ $builder }}) ExecX(ctx context.Context) { - if err := {{ $receiver }}.Exec(ctx); err != nil { +func ({{ $receiver }} *{{ $builder }}) ExecX(ctx context.Context) int { + n, err := {{ $receiver }}.Exec(ctx) + if err != nil { panic(err) } + return n } {{- range $_, $storage := $.Storage }} @@ -66,7 +68,15 @@ type {{ $onebuilder }} struct { // Exec executes the deletion query. func ({{ $oneReceiver }} *{{ $onebuilder }}) Exec(ctx context.Context) error { - return {{ $oneReceiver }}.{{ $receiver }}.Exec(ctx) + n, err := {{ $oneReceiver }}.{{ $receiver }}.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{ {{ $.Package }}.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/gen/template/dialect/gremlin/delete.tmpl b/entc/gen/template/dialect/gremlin/delete.tmpl index bf1a64c93..861ed0c09 100644 --- a/entc/gen/template/dialect/gremlin/delete.tmpl +++ b/entc/gen/template/dialect/gremlin/delete.tmpl @@ -8,10 +8,13 @@ in the LICENSE file in the root directory of this source tree. {{ $builder := pascal $.Scope.Builder }} {{ $receiver := receiver $builder }} -func ({{ $receiver}} *{{ $builder }}) gremlinExec(ctx context.Context) error { +func ({{ $receiver}} *{{ $builder }}) gremlinExec(ctx context.Context) (int, error) { res := &gremlin.Response{} query, bindings := {{ $receiver }}.gremlin().Query() - return {{ $receiver }}.driver.Exec(ctx, query, bindings, res) + if err := {{ $receiver }}.driver.Exec(ctx, query, bindings, res); err != nil { + return 0, err + } + return res.ReadInt() } @@ -20,6 +23,6 @@ func ({{ $receiver }} *{{ $builder }}) gremlin() *dsl.Traversal { for _, p := range {{ $receiver }}.predicates { p(t) } - return t.Drop() + return t.SideEffect(__.Drop()).Count() } {{ end }} \ No newline at end of file diff --git a/entc/gen/template/dialect/sql/delete.tmpl b/entc/gen/template/dialect/sql/delete.tmpl index 89663fc4e..daa5b574b 100644 --- a/entc/gen/template/dialect/sql/delete.tmpl +++ b/entc/gen/template/dialect/sql/delete.tmpl @@ -8,14 +8,21 @@ in the LICENSE file in the root directory of this source tree. {{ $builder := pascal $.Scope.Builder }} {{ $receiver := receiver $builder }} -func ({{ $receiver}} *{{ $builder }}) sqlExec(ctx context.Context) error { +func ({{ $receiver}} *{{ $builder }}) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table({{ $.Package }}.Table)) for _, p := range {{ $receiver }}.predicates { p(selector) } query, args := sql.Delete({{ $.Package }}.Table).FromSelect(selector).Query() - return {{ $receiver }}.driver.Exec(ctx, query, args, &res) + if err := {{ $receiver }}.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } {{ end }} \ No newline at end of file diff --git a/entc/integration/ent/card_delete.go b/entc/integration/ent/card_delete.go index e50fbf882..98dcf60ab 100644 --- a/entc/integration/ent/card_delete.go +++ b/entc/integration/ent/card_delete.go @@ -16,6 +16,7 @@ import ( "github.com/facebookincubator/ent/dialect" "github.com/facebookincubator/ent/dialect/gremlin" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl" + "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/__" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/g" "github.com/facebookincubator/ent/dialect/sql" ) @@ -26,45 +27,57 @@ type CardDelete struct { predicates []predicate.Card } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (cd *CardDelete) Where(ps ...predicate.Card) *CardDelete { cd.predicates = append(cd.predicates, ps...) return cd } -// Exec executes the deletion query. -func (cd *CardDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (cd *CardDelete) Exec(ctx context.Context) (int, error) { switch cd.driver.Dialect() { case dialect.MySQL, dialect.SQLite: return cd.sqlExec(ctx) case dialect.Gremlin: return cd.gremlinExec(ctx) default: - return errors.New("ent: unsupported dialect") + return 0, errors.New("ent: unsupported dialect") } } // ExecX is like Exec, but panics if an error occurs. -func (cd *CardDelete) ExecX(ctx context.Context) { - if err := cd.Exec(ctx); err != nil { +func (cd *CardDelete) ExecX(ctx context.Context) int { + n, err := cd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (cd *CardDelete) sqlExec(ctx context.Context) error { +func (cd *CardDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(card.Table)) for _, p := range cd.predicates { p(selector) } query, args := sql.Delete(card.Table).FromSelect(selector).Query() - return cd.driver.Exec(ctx, query, args, &res) + if err := cd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } -func (cd *CardDelete) gremlinExec(ctx context.Context) error { +func (cd *CardDelete) gremlinExec(ctx context.Context) (int, error) { res := &gremlin.Response{} query, bindings := cd.gremlin().Query() - return cd.driver.Exec(ctx, query, bindings, res) + if err := cd.driver.Exec(ctx, query, bindings, res); err != nil { + return 0, err + } + return res.ReadInt() } func (cd *CardDelete) gremlin() *dsl.Traversal { @@ -72,7 +85,7 @@ func (cd *CardDelete) gremlin() *dsl.Traversal { for _, p := range cd.predicates { p(t) } - return t.Drop() + return t.SideEffect(__.Drop()).Count() } // CardDeleteOne is the builder for deleting a single Card entity. @@ -82,7 +95,15 @@ type CardDeleteOne struct { // Exec executes the deletion query. func (cdo *CardDeleteOne) Exec(ctx context.Context) error { - return cdo.cd.Exec(ctx) + n, err := cdo.cd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{card.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/ent/comment_delete.go b/entc/integration/ent/comment_delete.go index 10bfebd57..dfcce2ccd 100644 --- a/entc/integration/ent/comment_delete.go +++ b/entc/integration/ent/comment_delete.go @@ -16,6 +16,7 @@ import ( "github.com/facebookincubator/ent/dialect" "github.com/facebookincubator/ent/dialect/gremlin" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl" + "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/__" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/g" "github.com/facebookincubator/ent/dialect/sql" ) @@ -26,45 +27,57 @@ type CommentDelete struct { predicates []predicate.Comment } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (cd *CommentDelete) Where(ps ...predicate.Comment) *CommentDelete { cd.predicates = append(cd.predicates, ps...) return cd } -// Exec executes the deletion query. -func (cd *CommentDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (cd *CommentDelete) Exec(ctx context.Context) (int, error) { switch cd.driver.Dialect() { case dialect.MySQL, dialect.SQLite: return cd.sqlExec(ctx) case dialect.Gremlin: return cd.gremlinExec(ctx) default: - return errors.New("ent: unsupported dialect") + return 0, errors.New("ent: unsupported dialect") } } // ExecX is like Exec, but panics if an error occurs. -func (cd *CommentDelete) ExecX(ctx context.Context) { - if err := cd.Exec(ctx); err != nil { +func (cd *CommentDelete) ExecX(ctx context.Context) int { + n, err := cd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (cd *CommentDelete) sqlExec(ctx context.Context) error { +func (cd *CommentDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(comment.Table)) for _, p := range cd.predicates { p(selector) } query, args := sql.Delete(comment.Table).FromSelect(selector).Query() - return cd.driver.Exec(ctx, query, args, &res) + if err := cd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } -func (cd *CommentDelete) gremlinExec(ctx context.Context) error { +func (cd *CommentDelete) gremlinExec(ctx context.Context) (int, error) { res := &gremlin.Response{} query, bindings := cd.gremlin().Query() - return cd.driver.Exec(ctx, query, bindings, res) + if err := cd.driver.Exec(ctx, query, bindings, res); err != nil { + return 0, err + } + return res.ReadInt() } func (cd *CommentDelete) gremlin() *dsl.Traversal { @@ -72,7 +85,7 @@ func (cd *CommentDelete) gremlin() *dsl.Traversal { for _, p := range cd.predicates { p(t) } - return t.Drop() + return t.SideEffect(__.Drop()).Count() } // CommentDeleteOne is the builder for deleting a single Comment entity. @@ -82,7 +95,15 @@ type CommentDeleteOne struct { // Exec executes the deletion query. func (cdo *CommentDeleteOne) Exec(ctx context.Context) error { - return cdo.cd.Exec(ctx) + n, err := cdo.cd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{comment.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/ent/fieldtype_delete.go b/entc/integration/ent/fieldtype_delete.go index b6a7aee47..b8cd8d107 100644 --- a/entc/integration/ent/fieldtype_delete.go +++ b/entc/integration/ent/fieldtype_delete.go @@ -16,6 +16,7 @@ import ( "github.com/facebookincubator/ent/dialect" "github.com/facebookincubator/ent/dialect/gremlin" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl" + "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/__" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/g" "github.com/facebookincubator/ent/dialect/sql" ) @@ -26,45 +27,57 @@ type FieldTypeDelete struct { predicates []predicate.FieldType } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (ftd *FieldTypeDelete) Where(ps ...predicate.FieldType) *FieldTypeDelete { ftd.predicates = append(ftd.predicates, ps...) return ftd } -// Exec executes the deletion query. -func (ftd *FieldTypeDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (ftd *FieldTypeDelete) Exec(ctx context.Context) (int, error) { switch ftd.driver.Dialect() { case dialect.MySQL, dialect.SQLite: return ftd.sqlExec(ctx) case dialect.Gremlin: return ftd.gremlinExec(ctx) default: - return errors.New("ent: unsupported dialect") + return 0, errors.New("ent: unsupported dialect") } } // ExecX is like Exec, but panics if an error occurs. -func (ftd *FieldTypeDelete) ExecX(ctx context.Context) { - if err := ftd.Exec(ctx); err != nil { +func (ftd *FieldTypeDelete) ExecX(ctx context.Context) int { + n, err := ftd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (ftd *FieldTypeDelete) sqlExec(ctx context.Context) error { +func (ftd *FieldTypeDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(fieldtype.Table)) for _, p := range ftd.predicates { p(selector) } query, args := sql.Delete(fieldtype.Table).FromSelect(selector).Query() - return ftd.driver.Exec(ctx, query, args, &res) + if err := ftd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } -func (ftd *FieldTypeDelete) gremlinExec(ctx context.Context) error { +func (ftd *FieldTypeDelete) gremlinExec(ctx context.Context) (int, error) { res := &gremlin.Response{} query, bindings := ftd.gremlin().Query() - return ftd.driver.Exec(ctx, query, bindings, res) + if err := ftd.driver.Exec(ctx, query, bindings, res); err != nil { + return 0, err + } + return res.ReadInt() } func (ftd *FieldTypeDelete) gremlin() *dsl.Traversal { @@ -72,7 +85,7 @@ func (ftd *FieldTypeDelete) gremlin() *dsl.Traversal { for _, p := range ftd.predicates { p(t) } - return t.Drop() + return t.SideEffect(__.Drop()).Count() } // FieldTypeDeleteOne is the builder for deleting a single FieldType entity. @@ -82,7 +95,15 @@ type FieldTypeDeleteOne struct { // Exec executes the deletion query. func (ftdo *FieldTypeDeleteOne) Exec(ctx context.Context) error { - return ftdo.ftd.Exec(ctx) + n, err := ftdo.ftd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{fieldtype.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/ent/file_delete.go b/entc/integration/ent/file_delete.go index c76cba087..f9095de29 100644 --- a/entc/integration/ent/file_delete.go +++ b/entc/integration/ent/file_delete.go @@ -16,6 +16,7 @@ import ( "github.com/facebookincubator/ent/dialect" "github.com/facebookincubator/ent/dialect/gremlin" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl" + "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/__" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/g" "github.com/facebookincubator/ent/dialect/sql" ) @@ -26,45 +27,57 @@ type FileDelete struct { predicates []predicate.File } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (fd *FileDelete) Where(ps ...predicate.File) *FileDelete { fd.predicates = append(fd.predicates, ps...) return fd } -// Exec executes the deletion query. -func (fd *FileDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (fd *FileDelete) Exec(ctx context.Context) (int, error) { switch fd.driver.Dialect() { case dialect.MySQL, dialect.SQLite: return fd.sqlExec(ctx) case dialect.Gremlin: return fd.gremlinExec(ctx) default: - return errors.New("ent: unsupported dialect") + return 0, errors.New("ent: unsupported dialect") } } // ExecX is like Exec, but panics if an error occurs. -func (fd *FileDelete) ExecX(ctx context.Context) { - if err := fd.Exec(ctx); err != nil { +func (fd *FileDelete) ExecX(ctx context.Context) int { + n, err := fd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (fd *FileDelete) sqlExec(ctx context.Context) error { +func (fd *FileDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(file.Table)) for _, p := range fd.predicates { p(selector) } query, args := sql.Delete(file.Table).FromSelect(selector).Query() - return fd.driver.Exec(ctx, query, args, &res) + if err := fd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } -func (fd *FileDelete) gremlinExec(ctx context.Context) error { +func (fd *FileDelete) gremlinExec(ctx context.Context) (int, error) { res := &gremlin.Response{} query, bindings := fd.gremlin().Query() - return fd.driver.Exec(ctx, query, bindings, res) + if err := fd.driver.Exec(ctx, query, bindings, res); err != nil { + return 0, err + } + return res.ReadInt() } func (fd *FileDelete) gremlin() *dsl.Traversal { @@ -72,7 +85,7 @@ func (fd *FileDelete) gremlin() *dsl.Traversal { for _, p := range fd.predicates { p(t) } - return t.Drop() + return t.SideEffect(__.Drop()).Count() } // FileDeleteOne is the builder for deleting a single File entity. @@ -82,7 +95,15 @@ type FileDeleteOne struct { // Exec executes the deletion query. func (fdo *FileDeleteOne) Exec(ctx context.Context) error { - return fdo.fd.Exec(ctx) + n, err := fdo.fd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{file.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/ent/filetype_delete.go b/entc/integration/ent/filetype_delete.go index b530f3f2f..8753dc171 100644 --- a/entc/integration/ent/filetype_delete.go +++ b/entc/integration/ent/filetype_delete.go @@ -16,6 +16,7 @@ import ( "github.com/facebookincubator/ent/dialect" "github.com/facebookincubator/ent/dialect/gremlin" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl" + "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/__" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/g" "github.com/facebookincubator/ent/dialect/sql" ) @@ -26,45 +27,57 @@ type FileTypeDelete struct { predicates []predicate.FileType } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (ftd *FileTypeDelete) Where(ps ...predicate.FileType) *FileTypeDelete { ftd.predicates = append(ftd.predicates, ps...) return ftd } -// Exec executes the deletion query. -func (ftd *FileTypeDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (ftd *FileTypeDelete) Exec(ctx context.Context) (int, error) { switch ftd.driver.Dialect() { case dialect.MySQL, dialect.SQLite: return ftd.sqlExec(ctx) case dialect.Gremlin: return ftd.gremlinExec(ctx) default: - return errors.New("ent: unsupported dialect") + return 0, errors.New("ent: unsupported dialect") } } // ExecX is like Exec, but panics if an error occurs. -func (ftd *FileTypeDelete) ExecX(ctx context.Context) { - if err := ftd.Exec(ctx); err != nil { +func (ftd *FileTypeDelete) ExecX(ctx context.Context) int { + n, err := ftd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (ftd *FileTypeDelete) sqlExec(ctx context.Context) error { +func (ftd *FileTypeDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(filetype.Table)) for _, p := range ftd.predicates { p(selector) } query, args := sql.Delete(filetype.Table).FromSelect(selector).Query() - return ftd.driver.Exec(ctx, query, args, &res) + if err := ftd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } -func (ftd *FileTypeDelete) gremlinExec(ctx context.Context) error { +func (ftd *FileTypeDelete) gremlinExec(ctx context.Context) (int, error) { res := &gremlin.Response{} query, bindings := ftd.gremlin().Query() - return ftd.driver.Exec(ctx, query, bindings, res) + if err := ftd.driver.Exec(ctx, query, bindings, res); err != nil { + return 0, err + } + return res.ReadInt() } func (ftd *FileTypeDelete) gremlin() *dsl.Traversal { @@ -72,7 +85,7 @@ func (ftd *FileTypeDelete) gremlin() *dsl.Traversal { for _, p := range ftd.predicates { p(t) } - return t.Drop() + return t.SideEffect(__.Drop()).Count() } // FileTypeDeleteOne is the builder for deleting a single FileType entity. @@ -82,7 +95,15 @@ type FileTypeDeleteOne struct { // Exec executes the deletion query. func (ftdo *FileTypeDeleteOne) Exec(ctx context.Context) error { - return ftdo.ftd.Exec(ctx) + n, err := ftdo.ftd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{filetype.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/ent/group_delete.go b/entc/integration/ent/group_delete.go index f5c882986..3c7f0d87f 100644 --- a/entc/integration/ent/group_delete.go +++ b/entc/integration/ent/group_delete.go @@ -16,6 +16,7 @@ import ( "github.com/facebookincubator/ent/dialect" "github.com/facebookincubator/ent/dialect/gremlin" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl" + "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/__" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/g" "github.com/facebookincubator/ent/dialect/sql" ) @@ -26,45 +27,57 @@ type GroupDelete struct { predicates []predicate.Group } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (gd *GroupDelete) Where(ps ...predicate.Group) *GroupDelete { gd.predicates = append(gd.predicates, ps...) return gd } -// Exec executes the deletion query. -func (gd *GroupDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (gd *GroupDelete) Exec(ctx context.Context) (int, error) { switch gd.driver.Dialect() { case dialect.MySQL, dialect.SQLite: return gd.sqlExec(ctx) case dialect.Gremlin: return gd.gremlinExec(ctx) default: - return errors.New("ent: unsupported dialect") + return 0, errors.New("ent: unsupported dialect") } } // ExecX is like Exec, but panics if an error occurs. -func (gd *GroupDelete) ExecX(ctx context.Context) { - if err := gd.Exec(ctx); err != nil { +func (gd *GroupDelete) ExecX(ctx context.Context) int { + n, err := gd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (gd *GroupDelete) sqlExec(ctx context.Context) error { +func (gd *GroupDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(group.Table)) for _, p := range gd.predicates { p(selector) } query, args := sql.Delete(group.Table).FromSelect(selector).Query() - return gd.driver.Exec(ctx, query, args, &res) + if err := gd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } -func (gd *GroupDelete) gremlinExec(ctx context.Context) error { +func (gd *GroupDelete) gremlinExec(ctx context.Context) (int, error) { res := &gremlin.Response{} query, bindings := gd.gremlin().Query() - return gd.driver.Exec(ctx, query, bindings, res) + if err := gd.driver.Exec(ctx, query, bindings, res); err != nil { + return 0, err + } + return res.ReadInt() } func (gd *GroupDelete) gremlin() *dsl.Traversal { @@ -72,7 +85,7 @@ func (gd *GroupDelete) gremlin() *dsl.Traversal { for _, p := range gd.predicates { p(t) } - return t.Drop() + return t.SideEffect(__.Drop()).Count() } // GroupDeleteOne is the builder for deleting a single Group entity. @@ -82,7 +95,15 @@ type GroupDeleteOne struct { // Exec executes the deletion query. func (gdo *GroupDeleteOne) Exec(ctx context.Context) error { - return gdo.gd.Exec(ctx) + n, err := gdo.gd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{group.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/ent/groupinfo_delete.go b/entc/integration/ent/groupinfo_delete.go index 906760767..d58eee3c7 100644 --- a/entc/integration/ent/groupinfo_delete.go +++ b/entc/integration/ent/groupinfo_delete.go @@ -16,6 +16,7 @@ import ( "github.com/facebookincubator/ent/dialect" "github.com/facebookincubator/ent/dialect/gremlin" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl" + "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/__" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/g" "github.com/facebookincubator/ent/dialect/sql" ) @@ -26,45 +27,57 @@ type GroupInfoDelete struct { predicates []predicate.GroupInfo } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (gid *GroupInfoDelete) Where(ps ...predicate.GroupInfo) *GroupInfoDelete { gid.predicates = append(gid.predicates, ps...) return gid } -// Exec executes the deletion query. -func (gid *GroupInfoDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (gid *GroupInfoDelete) Exec(ctx context.Context) (int, error) { switch gid.driver.Dialect() { case dialect.MySQL, dialect.SQLite: return gid.sqlExec(ctx) case dialect.Gremlin: return gid.gremlinExec(ctx) default: - return errors.New("ent: unsupported dialect") + return 0, errors.New("ent: unsupported dialect") } } // ExecX is like Exec, but panics if an error occurs. -func (gid *GroupInfoDelete) ExecX(ctx context.Context) { - if err := gid.Exec(ctx); err != nil { +func (gid *GroupInfoDelete) ExecX(ctx context.Context) int { + n, err := gid.Exec(ctx) + if err != nil { panic(err) } + return n } -func (gid *GroupInfoDelete) sqlExec(ctx context.Context) error { +func (gid *GroupInfoDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(groupinfo.Table)) for _, p := range gid.predicates { p(selector) } query, args := sql.Delete(groupinfo.Table).FromSelect(selector).Query() - return gid.driver.Exec(ctx, query, args, &res) + if err := gid.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } -func (gid *GroupInfoDelete) gremlinExec(ctx context.Context) error { +func (gid *GroupInfoDelete) gremlinExec(ctx context.Context) (int, error) { res := &gremlin.Response{} query, bindings := gid.gremlin().Query() - return gid.driver.Exec(ctx, query, bindings, res) + if err := gid.driver.Exec(ctx, query, bindings, res); err != nil { + return 0, err + } + return res.ReadInt() } func (gid *GroupInfoDelete) gremlin() *dsl.Traversal { @@ -72,7 +85,7 @@ func (gid *GroupInfoDelete) gremlin() *dsl.Traversal { for _, p := range gid.predicates { p(t) } - return t.Drop() + return t.SideEffect(__.Drop()).Count() } // GroupInfoDeleteOne is the builder for deleting a single GroupInfo entity. @@ -82,7 +95,15 @@ type GroupInfoDeleteOne struct { // Exec executes the deletion query. func (gido *GroupInfoDeleteOne) Exec(ctx context.Context) error { - return gido.gid.Exec(ctx) + n, err := gido.gid.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{groupinfo.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/ent/node_delete.go b/entc/integration/ent/node_delete.go index 2ccfb455f..bd9b3c3fb 100644 --- a/entc/integration/ent/node_delete.go +++ b/entc/integration/ent/node_delete.go @@ -16,6 +16,7 @@ import ( "github.com/facebookincubator/ent/dialect" "github.com/facebookincubator/ent/dialect/gremlin" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl" + "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/__" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/g" "github.com/facebookincubator/ent/dialect/sql" ) @@ -26,45 +27,57 @@ type NodeDelete struct { predicates []predicate.Node } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (nd *NodeDelete) Where(ps ...predicate.Node) *NodeDelete { nd.predicates = append(nd.predicates, ps...) return nd } -// Exec executes the deletion query. -func (nd *NodeDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (nd *NodeDelete) Exec(ctx context.Context) (int, error) { switch nd.driver.Dialect() { case dialect.MySQL, dialect.SQLite: return nd.sqlExec(ctx) case dialect.Gremlin: return nd.gremlinExec(ctx) default: - return errors.New("ent: unsupported dialect") + return 0, errors.New("ent: unsupported dialect") } } // ExecX is like Exec, but panics if an error occurs. -func (nd *NodeDelete) ExecX(ctx context.Context) { - if err := nd.Exec(ctx); err != nil { +func (nd *NodeDelete) ExecX(ctx context.Context) int { + n, err := nd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (nd *NodeDelete) sqlExec(ctx context.Context) error { +func (nd *NodeDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(node.Table)) for _, p := range nd.predicates { p(selector) } query, args := sql.Delete(node.Table).FromSelect(selector).Query() - return nd.driver.Exec(ctx, query, args, &res) + if err := nd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } -func (nd *NodeDelete) gremlinExec(ctx context.Context) error { +func (nd *NodeDelete) gremlinExec(ctx context.Context) (int, error) { res := &gremlin.Response{} query, bindings := nd.gremlin().Query() - return nd.driver.Exec(ctx, query, bindings, res) + if err := nd.driver.Exec(ctx, query, bindings, res); err != nil { + return 0, err + } + return res.ReadInt() } func (nd *NodeDelete) gremlin() *dsl.Traversal { @@ -72,7 +85,7 @@ func (nd *NodeDelete) gremlin() *dsl.Traversal { for _, p := range nd.predicates { p(t) } - return t.Drop() + return t.SideEffect(__.Drop()).Count() } // NodeDeleteOne is the builder for deleting a single Node entity. @@ -82,7 +95,15 @@ type NodeDeleteOne struct { // Exec executes the deletion query. func (ndo *NodeDeleteOne) Exec(ctx context.Context) error { - return ndo.nd.Exec(ctx) + n, err := ndo.nd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{node.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/ent/pet_delete.go b/entc/integration/ent/pet_delete.go index e9264c7bc..5833824ef 100644 --- a/entc/integration/ent/pet_delete.go +++ b/entc/integration/ent/pet_delete.go @@ -16,6 +16,7 @@ import ( "github.com/facebookincubator/ent/dialect" "github.com/facebookincubator/ent/dialect/gremlin" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl" + "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/__" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/g" "github.com/facebookincubator/ent/dialect/sql" ) @@ -26,45 +27,57 @@ type PetDelete struct { predicates []predicate.Pet } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (pd *PetDelete) Where(ps ...predicate.Pet) *PetDelete { pd.predicates = append(pd.predicates, ps...) return pd } -// Exec executes the deletion query. -func (pd *PetDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (pd *PetDelete) Exec(ctx context.Context) (int, error) { switch pd.driver.Dialect() { case dialect.MySQL, dialect.SQLite: return pd.sqlExec(ctx) case dialect.Gremlin: return pd.gremlinExec(ctx) default: - return errors.New("ent: unsupported dialect") + return 0, errors.New("ent: unsupported dialect") } } // ExecX is like Exec, but panics if an error occurs. -func (pd *PetDelete) ExecX(ctx context.Context) { - if err := pd.Exec(ctx); err != nil { +func (pd *PetDelete) ExecX(ctx context.Context) int { + n, err := pd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (pd *PetDelete) sqlExec(ctx context.Context) error { +func (pd *PetDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(pet.Table)) for _, p := range pd.predicates { p(selector) } query, args := sql.Delete(pet.Table).FromSelect(selector).Query() - return pd.driver.Exec(ctx, query, args, &res) + if err := pd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } -func (pd *PetDelete) gremlinExec(ctx context.Context) error { +func (pd *PetDelete) gremlinExec(ctx context.Context) (int, error) { res := &gremlin.Response{} query, bindings := pd.gremlin().Query() - return pd.driver.Exec(ctx, query, bindings, res) + if err := pd.driver.Exec(ctx, query, bindings, res); err != nil { + return 0, err + } + return res.ReadInt() } func (pd *PetDelete) gremlin() *dsl.Traversal { @@ -72,7 +85,7 @@ func (pd *PetDelete) gremlin() *dsl.Traversal { for _, p := range pd.predicates { p(t) } - return t.Drop() + return t.SideEffect(__.Drop()).Count() } // PetDeleteOne is the builder for deleting a single Pet entity. @@ -82,7 +95,15 @@ type PetDeleteOne struct { // Exec executes the deletion query. func (pdo *PetDeleteOne) Exec(ctx context.Context) error { - return pdo.pd.Exec(ctx) + n, err := pdo.pd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{pet.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/ent/user_delete.go b/entc/integration/ent/user_delete.go index 58393eeaa..067405300 100644 --- a/entc/integration/ent/user_delete.go +++ b/entc/integration/ent/user_delete.go @@ -16,6 +16,7 @@ import ( "github.com/facebookincubator/ent/dialect" "github.com/facebookincubator/ent/dialect/gremlin" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl" + "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/__" "github.com/facebookincubator/ent/dialect/gremlin/graph/dsl/g" "github.com/facebookincubator/ent/dialect/sql" ) @@ -26,45 +27,57 @@ type UserDelete struct { predicates []predicate.User } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { ud.predicates = append(ud.predicates, ps...) return ud } -// Exec executes the deletion query. -func (ud *UserDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (ud *UserDelete) Exec(ctx context.Context) (int, error) { switch ud.driver.Dialect() { case dialect.MySQL, dialect.SQLite: return ud.sqlExec(ctx) case dialect.Gremlin: return ud.gremlinExec(ctx) default: - return errors.New("ent: unsupported dialect") + return 0, errors.New("ent: unsupported dialect") } } // ExecX is like Exec, but panics if an error occurs. -func (ud *UserDelete) ExecX(ctx context.Context) { - if err := ud.Exec(ctx); err != nil { +func (ud *UserDelete) ExecX(ctx context.Context) int { + n, err := ud.Exec(ctx) + if err != nil { panic(err) } + return n } -func (ud *UserDelete) sqlExec(ctx context.Context) error { +func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(user.Table)) for _, p := range ud.predicates { p(selector) } query, args := sql.Delete(user.Table).FromSelect(selector).Query() - return ud.driver.Exec(ctx, query, args, &res) + if err := ud.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } -func (ud *UserDelete) gremlinExec(ctx context.Context) error { +func (ud *UserDelete) gremlinExec(ctx context.Context) (int, error) { res := &gremlin.Response{} query, bindings := ud.gremlin().Query() - return ud.driver.Exec(ctx, query, bindings, res) + if err := ud.driver.Exec(ctx, query, bindings, res); err != nil { + return 0, err + } + return res.ReadInt() } func (ud *UserDelete) gremlin() *dsl.Traversal { @@ -72,7 +85,7 @@ func (ud *UserDelete) gremlin() *dsl.Traversal { for _, p := range ud.predicates { p(t) } - return t.Drop() + return t.SideEffect(__.Drop()).Count() } // UserDeleteOne is the builder for deleting a single User entity. @@ -82,7 +95,15 @@ type UserDeleteOne struct { // Exec executes the deletion query. func (udo *UserDeleteOne) Exec(ctx context.Context) error { - return udo.ud.Exec(ctx) + n, err := udo.ud.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{user.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/integration_test.go b/entc/integration/integration_test.go index 8e0306a0e..7ab0d8645 100644 --- a/entc/integration/integration_test.go +++ b/entc/integration/integration_test.go @@ -96,6 +96,7 @@ var tests = []func(*testing.T, *ent.Client){ Sanity, Paging, Select, + Delete, Relation, Predicate, AddValues, @@ -367,6 +368,28 @@ func AddValues(t *testing.T, client *ent.Client) { require.Equal(20, *cmt1.NillableInt) } +func Delete(t *testing.T, client *ent.Client) { + require := require.New(t) + ctx := context.Background() + + nd := client.Node.Create().SetValue(1e3).SaveX(ctx) + err := client.Node.DeleteOneID(nd.ID).Exec(ctx) + require.NoError(err) + err = client.Node.DeleteOneID(nd.ID).Exec(ctx) + require.True(ent.IsNotFound(err)) + + for i := 0; i < 5; i++ { + client.Node.Create().SetValue(i).SaveX(ctx) + } + affected, err := client.Node.Delete().Where(node.ValueGT(2)).Exec(ctx) + require.NoError(err) + require.Equal(2, affected) + + affected, err = client.Node.Delete().Exec(ctx) + require.NoError(err) + require.Equal(3, affected) +} + func Relation(t *testing.T, client *ent.Client) { require := require.New(t) ctx := context.Background() diff --git a/entc/integration/migrate/entv1/user_delete.go b/entc/integration/migrate/entv1/user_delete.go index fee7180e8..1182f986e 100644 --- a/entc/integration/migrate/entv1/user_delete.go +++ b/entc/integration/migrate/entv1/user_delete.go @@ -21,32 +21,41 @@ type UserDelete struct { predicates []predicate.User } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { ud.predicates = append(ud.predicates, ps...) return ud } -// Exec executes the deletion query. -func (ud *UserDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (ud *UserDelete) Exec(ctx context.Context) (int, error) { return ud.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (ud *UserDelete) ExecX(ctx context.Context) { - if err := ud.Exec(ctx); err != nil { +func (ud *UserDelete) ExecX(ctx context.Context) int { + n, err := ud.Exec(ctx) + if err != nil { panic(err) } + return n } -func (ud *UserDelete) sqlExec(ctx context.Context) error { +func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(user.Table)) for _, p := range ud.predicates { p(selector) } query, args := sql.Delete(user.Table).FromSelect(selector).Query() - return ud.driver.Exec(ctx, query, args, &res) + if err := ud.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // UserDeleteOne is the builder for deleting a single User entity. @@ -56,7 +65,15 @@ type UserDeleteOne struct { // Exec executes the deletion query. func (udo *UserDeleteOne) Exec(ctx context.Context) error { - return udo.ud.Exec(ctx) + n, err := udo.ud.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{user.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/migrate/entv2/group_delete.go b/entc/integration/migrate/entv2/group_delete.go index a5d095704..65b3798a8 100644 --- a/entc/integration/migrate/entv2/group_delete.go +++ b/entc/integration/migrate/entv2/group_delete.go @@ -21,32 +21,41 @@ type GroupDelete struct { predicates []predicate.Group } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (gd *GroupDelete) Where(ps ...predicate.Group) *GroupDelete { gd.predicates = append(gd.predicates, ps...) return gd } -// Exec executes the deletion query. -func (gd *GroupDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (gd *GroupDelete) Exec(ctx context.Context) (int, error) { return gd.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (gd *GroupDelete) ExecX(ctx context.Context) { - if err := gd.Exec(ctx); err != nil { +func (gd *GroupDelete) ExecX(ctx context.Context) int { + n, err := gd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (gd *GroupDelete) sqlExec(ctx context.Context) error { +func (gd *GroupDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(group.Table)) for _, p := range gd.predicates { p(selector) } query, args := sql.Delete(group.Table).FromSelect(selector).Query() - return gd.driver.Exec(ctx, query, args, &res) + if err := gd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // GroupDeleteOne is the builder for deleting a single Group entity. @@ -56,7 +65,15 @@ type GroupDeleteOne struct { // Exec executes the deletion query. func (gdo *GroupDeleteOne) Exec(ctx context.Context) error { - return gdo.gd.Exec(ctx) + n, err := gdo.gd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{group.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/migrate/entv2/pet_delete.go b/entc/integration/migrate/entv2/pet_delete.go index b83741038..cb197fe15 100644 --- a/entc/integration/migrate/entv2/pet_delete.go +++ b/entc/integration/migrate/entv2/pet_delete.go @@ -21,32 +21,41 @@ type PetDelete struct { predicates []predicate.Pet } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (pd *PetDelete) Where(ps ...predicate.Pet) *PetDelete { pd.predicates = append(pd.predicates, ps...) return pd } -// Exec executes the deletion query. -func (pd *PetDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (pd *PetDelete) Exec(ctx context.Context) (int, error) { return pd.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (pd *PetDelete) ExecX(ctx context.Context) { - if err := pd.Exec(ctx); err != nil { +func (pd *PetDelete) ExecX(ctx context.Context) int { + n, err := pd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (pd *PetDelete) sqlExec(ctx context.Context) error { +func (pd *PetDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(pet.Table)) for _, p := range pd.predicates { p(selector) } query, args := sql.Delete(pet.Table).FromSelect(selector).Query() - return pd.driver.Exec(ctx, query, args, &res) + if err := pd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // PetDeleteOne is the builder for deleting a single Pet entity. @@ -56,7 +65,15 @@ type PetDeleteOne struct { // Exec executes the deletion query. func (pdo *PetDeleteOne) Exec(ctx context.Context) error { - return pdo.pd.Exec(ctx) + n, err := pdo.pd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{pet.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/migrate/entv2/user_delete.go b/entc/integration/migrate/entv2/user_delete.go index e58a8c3de..a6b6f0bfb 100644 --- a/entc/integration/migrate/entv2/user_delete.go +++ b/entc/integration/migrate/entv2/user_delete.go @@ -21,32 +21,41 @@ type UserDelete struct { predicates []predicate.User } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { ud.predicates = append(ud.predicates, ps...) return ud } -// Exec executes the deletion query. -func (ud *UserDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (ud *UserDelete) Exec(ctx context.Context) (int, error) { return ud.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (ud *UserDelete) ExecX(ctx context.Context) { - if err := ud.Exec(ctx); err != nil { +func (ud *UserDelete) ExecX(ctx context.Context) int { + n, err := ud.Exec(ctx) + if err != nil { panic(err) } + return n } -func (ud *UserDelete) sqlExec(ctx context.Context) error { +func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(user.Table)) for _, p := range ud.predicates { p(selector) } query, args := sql.Delete(user.Table).FromSelect(selector).Query() - return ud.driver.Exec(ctx, query, args, &res) + if err := ud.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // UserDeleteOne is the builder for deleting a single User entity. @@ -56,7 +65,15 @@ type UserDeleteOne struct { // Exec executes the deletion query. func (udo *UserDeleteOne) Exec(ctx context.Context) error { - return udo.ud.Exec(ctx) + n, err := udo.ud.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{user.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/template/ent/group_delete.go b/entc/integration/template/ent/group_delete.go index d11908ea6..e99b16943 100644 --- a/entc/integration/template/ent/group_delete.go +++ b/entc/integration/template/ent/group_delete.go @@ -21,32 +21,41 @@ type GroupDelete struct { predicates []predicate.Group } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (gd *GroupDelete) Where(ps ...predicate.Group) *GroupDelete { gd.predicates = append(gd.predicates, ps...) return gd } -// Exec executes the deletion query. -func (gd *GroupDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (gd *GroupDelete) Exec(ctx context.Context) (int, error) { return gd.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (gd *GroupDelete) ExecX(ctx context.Context) { - if err := gd.Exec(ctx); err != nil { +func (gd *GroupDelete) ExecX(ctx context.Context) int { + n, err := gd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (gd *GroupDelete) sqlExec(ctx context.Context) error { +func (gd *GroupDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(group.Table)) for _, p := range gd.predicates { p(selector) } query, args := sql.Delete(group.Table).FromSelect(selector).Query() - return gd.driver.Exec(ctx, query, args, &res) + if err := gd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // GroupDeleteOne is the builder for deleting a single Group entity. @@ -56,7 +65,15 @@ type GroupDeleteOne struct { // Exec executes the deletion query. func (gdo *GroupDeleteOne) Exec(ctx context.Context) error { - return gdo.gd.Exec(ctx) + n, err := gdo.gd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{group.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/template/ent/pet_delete.go b/entc/integration/template/ent/pet_delete.go index 94629260a..122bea46e 100644 --- a/entc/integration/template/ent/pet_delete.go +++ b/entc/integration/template/ent/pet_delete.go @@ -21,32 +21,41 @@ type PetDelete struct { predicates []predicate.Pet } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (pd *PetDelete) Where(ps ...predicate.Pet) *PetDelete { pd.predicates = append(pd.predicates, ps...) return pd } -// Exec executes the deletion query. -func (pd *PetDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (pd *PetDelete) Exec(ctx context.Context) (int, error) { return pd.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (pd *PetDelete) ExecX(ctx context.Context) { - if err := pd.Exec(ctx); err != nil { +func (pd *PetDelete) ExecX(ctx context.Context) int { + n, err := pd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (pd *PetDelete) sqlExec(ctx context.Context) error { +func (pd *PetDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(pet.Table)) for _, p := range pd.predicates { p(selector) } query, args := sql.Delete(pet.Table).FromSelect(selector).Query() - return pd.driver.Exec(ctx, query, args, &res) + if err := pd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // PetDeleteOne is the builder for deleting a single Pet entity. @@ -56,7 +65,15 @@ type PetDeleteOne struct { // Exec executes the deletion query. func (pdo *PetDeleteOne) Exec(ctx context.Context) error { - return pdo.pd.Exec(ctx) + n, err := pdo.pd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{pet.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/integration/template/ent/user_delete.go b/entc/integration/template/ent/user_delete.go index d98f18c92..1c62bb591 100644 --- a/entc/integration/template/ent/user_delete.go +++ b/entc/integration/template/ent/user_delete.go @@ -21,32 +21,41 @@ type UserDelete struct { predicates []predicate.User } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { ud.predicates = append(ud.predicates, ps...) return ud } -// Exec executes the deletion query. -func (ud *UserDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (ud *UserDelete) Exec(ctx context.Context) (int, error) { return ud.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (ud *UserDelete) ExecX(ctx context.Context) { - if err := ud.Exec(ctx); err != nil { +func (ud *UserDelete) ExecX(ctx context.Context) int { + n, err := ud.Exec(ctx) + if err != nil { panic(err) } + return n } -func (ud *UserDelete) sqlExec(ctx context.Context) error { +func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(user.Table)) for _, p := range ud.predicates { p(selector) } query, args := sql.Delete(user.Table).FromSelect(selector).Query() - return ud.driver.Exec(ctx, query, args, &res) + if err := ud.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // UserDeleteOne is the builder for deleting a single User entity. @@ -56,7 +65,15 @@ type UserDeleteOne struct { // Exec executes the deletion query. func (udo *UserDeleteOne) Exec(ctx context.Context) error { - return udo.ud.Exec(ctx) + n, err := udo.ud.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{user.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/entc/load/internal/bindata.go b/entc/load/internal/bindata.go index 3c8e4d380..7345bc58f 100644 --- a/entc/load/internal/bindata.go +++ b/entc/load/internal/bindata.go @@ -19,7 +19,7 @@ import ( func bindataRead(data []byte, name string) ([]byte, error) { gz, err := gzip.NewReader(bytes.NewBuffer(data)) if err != nil { - return nil, fmt.Errorf("Read %q: %v", name, err) + return nil, fmt.Errorf("read %q: %v", name, err) } var buf bytes.Buffer @@ -27,7 +27,7 @@ func bindataRead(data []byte, name string) ([]byte, error) { clErr := gz.Close() if err != nil { - return nil, fmt.Errorf("Read %q: %v", name, err) + return nil, fmt.Errorf("read %q: %v", name, err) } if clErr != nil { return nil, err @@ -63,7 +63,7 @@ func (fi bindataFileInfo) Mode() os.FileMode { return fi.mode } -// Mode return file modify time +// ModTime return file modify time func (fi bindataFileInfo) ModTime() time.Time { return fi.modTime } @@ -93,7 +93,7 @@ func templateMainTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/main.tmpl", size: 843, mode: os.FileMode(420), modTime: time.Unix(1567360769, 0)} + info := bindataFileInfo{name: "template/main.tmpl", size: 843, mode: os.FileMode(420), modTime: time.Unix(1567330508, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -113,7 +113,7 @@ func schemaGo() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "schema.go", size: 5321, mode: os.FileMode(420), modTime: time.Unix(1568643141, 0)} + info := bindataFileInfo{name: "schema.go", size: 5321, mode: os.FileMode(420), modTime: time.Unix(1568644555, 0)} a := &asset{bytes: bytes, info: info} return a, nil } diff --git a/examples/edgeindex/ent/city_delete.go b/examples/edgeindex/ent/city_delete.go index 0ecc8bb5d..65036acc3 100644 --- a/examples/edgeindex/ent/city_delete.go +++ b/examples/edgeindex/ent/city_delete.go @@ -21,32 +21,41 @@ type CityDelete struct { predicates []predicate.City } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (cd *CityDelete) Where(ps ...predicate.City) *CityDelete { cd.predicates = append(cd.predicates, ps...) return cd } -// Exec executes the deletion query. -func (cd *CityDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (cd *CityDelete) Exec(ctx context.Context) (int, error) { return cd.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (cd *CityDelete) ExecX(ctx context.Context) { - if err := cd.Exec(ctx); err != nil { +func (cd *CityDelete) ExecX(ctx context.Context) int { + n, err := cd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (cd *CityDelete) sqlExec(ctx context.Context) error { +func (cd *CityDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(city.Table)) for _, p := range cd.predicates { p(selector) } query, args := sql.Delete(city.Table).FromSelect(selector).Query() - return cd.driver.Exec(ctx, query, args, &res) + if err := cd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // CityDeleteOne is the builder for deleting a single City entity. @@ -56,7 +65,15 @@ type CityDeleteOne struct { // Exec executes the deletion query. func (cdo *CityDeleteOne) Exec(ctx context.Context) error { - return cdo.cd.Exec(ctx) + n, err := cdo.cd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{city.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/edgeindex/ent/city_query.go b/examples/edgeindex/ent/city_query.go index ee990e31d..5d1e7d290 100644 --- a/examples/edgeindex/ent/city_query.go +++ b/examples/edgeindex/ent/city_query.go @@ -68,20 +68,6 @@ func (cq *CityQuery) QueryStreets() *StreetQuery { return query } -// Get returns a City entity by its id. -func (cq *CityQuery) Get(ctx context.Context, id int) (*City, error) { - return cq.Where(city.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (cq *CityQuery) GetX(ctx context.Context, id int) *City { - c, err := cq.Get(ctx, id) - if err != nil { - panic(err) - } - return c -} - // First returns the first City entity in the query. Returns *ErrNotFound when no city was found. func (cq *CityQuery) First(ctx context.Context) (*City, error) { cs, err := cq.Limit(1).All(ctx) diff --git a/examples/edgeindex/ent/city_update.go b/examples/edgeindex/ent/city_update.go index aee7ccbca..c54e4b75c 100644 --- a/examples/edgeindex/ent/city_update.go +++ b/examples/edgeindex/ent/city_update.go @@ -137,9 +137,9 @@ func (cu *CityUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(city.Table).Where(sql.InInts(city.FieldID, ids...)) ) - if cu.name != nil { + if value := cu.name; value != nil { update = true - builder.Set(city.FieldName, *cu.name) + builder.Set(city.FieldName, *value) } if update { query, args := builder.Query() @@ -306,10 +306,10 @@ func (cuo *CityUpdateOne) sqlSave(ctx context.Context) (c *City, err error) { res sql.Result builder = sql.Update(city.Table).Where(sql.InInts(city.FieldID, ids...)) ) - if cuo.name != nil { + if value := cuo.name; value != nil { update = true - builder.Set(city.FieldName, *cuo.name) - c.Name = *cuo.name + builder.Set(city.FieldName, *value) + c.Name = *value } if update { query, args := builder.Query() diff --git a/examples/edgeindex/ent/client.go b/examples/edgeindex/ent/client.go index 75064ae2c..9d14990de 100644 --- a/examples/edgeindex/ent/client.go +++ b/examples/edgeindex/ent/client.go @@ -130,6 +130,20 @@ func (c *CityClient) Query() *CityQuery { return &CityQuery{config: c.config} } +// Get returns a City entity by its id. +func (c *CityClient) Get(ctx context.Context, id int) (*City, error) { + return c.Query().Where(city.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *CityClient) GetX(ctx context.Context, id int) *City { + ci, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return ci +} + // QueryStreets queries the streets edge of a City. func (c *CityClient) QueryStreets(ci *City) *StreetQuery { query := &StreetQuery{config: c.config} @@ -190,6 +204,20 @@ func (c *StreetClient) Query() *StreetQuery { return &StreetQuery{config: c.config} } +// Get returns a Street entity by its id. +func (c *StreetClient) Get(ctx context.Context, id int) (*Street, error) { + return c.Query().Where(street.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *StreetClient) GetX(ctx context.Context, id int) *Street { + s, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return s +} + // QueryCity queries the city edge of a Street. func (c *StreetClient) QueryCity(s *Street) *CityQuery { query := &CityQuery{config: c.config} diff --git a/examples/edgeindex/ent/street_delete.go b/examples/edgeindex/ent/street_delete.go index 330867cd0..e66b109b4 100644 --- a/examples/edgeindex/ent/street_delete.go +++ b/examples/edgeindex/ent/street_delete.go @@ -21,32 +21,41 @@ type StreetDelete struct { predicates []predicate.Street } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (sd *StreetDelete) Where(ps ...predicate.Street) *StreetDelete { sd.predicates = append(sd.predicates, ps...) return sd } -// Exec executes the deletion query. -func (sd *StreetDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (sd *StreetDelete) Exec(ctx context.Context) (int, error) { return sd.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (sd *StreetDelete) ExecX(ctx context.Context) { - if err := sd.Exec(ctx); err != nil { +func (sd *StreetDelete) ExecX(ctx context.Context) int { + n, err := sd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (sd *StreetDelete) sqlExec(ctx context.Context) error { +func (sd *StreetDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(street.Table)) for _, p := range sd.predicates { p(selector) } query, args := sql.Delete(street.Table).FromSelect(selector).Query() - return sd.driver.Exec(ctx, query, args, &res) + if err := sd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // StreetDeleteOne is the builder for deleting a single Street entity. @@ -56,7 +65,15 @@ type StreetDeleteOne struct { // Exec executes the deletion query. func (sdo *StreetDeleteOne) Exec(ctx context.Context) error { - return sdo.sd.Exec(ctx) + n, err := sdo.sd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{street.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/edgeindex/ent/street_query.go b/examples/edgeindex/ent/street_query.go index ebc740e1b..0619c9026 100644 --- a/examples/edgeindex/ent/street_query.go +++ b/examples/edgeindex/ent/street_query.go @@ -68,20 +68,6 @@ func (sq *StreetQuery) QueryCity() *CityQuery { return query } -// Get returns a Street entity by its id. -func (sq *StreetQuery) Get(ctx context.Context, id int) (*Street, error) { - return sq.Where(street.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (sq *StreetQuery) GetX(ctx context.Context, id int) *Street { - s, err := sq.Get(ctx, id) - if err != nil { - panic(err) - } - return s -} - // First returns the first Street entity in the query. Returns *ErrNotFound when no street was found. func (sq *StreetQuery) First(ctx context.Context) (*Street, error) { sSlice, err := sq.Limit(1).All(ctx) diff --git a/examples/edgeindex/ent/street_update.go b/examples/edgeindex/ent/street_update.go index 2f0009829..7a0a0fcb0 100644 --- a/examples/edgeindex/ent/street_update.go +++ b/examples/edgeindex/ent/street_update.go @@ -129,9 +129,9 @@ func (su *StreetUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(street.Table).Where(sql.InInts(street.FieldID, ids...)) ) - if su.name != nil { + if value := su.name; value != nil { update = true - builder.Set(street.FieldName, *su.name) + builder.Set(street.FieldName, *value) } if update { query, args := builder.Query() @@ -273,10 +273,10 @@ func (suo *StreetUpdateOne) sqlSave(ctx context.Context) (s *Street, err error) res sql.Result builder = sql.Update(street.Table).Where(sql.InInts(street.FieldID, ids...)) ) - if suo.name != nil { + if value := suo.name; value != nil { update = true - builder.Set(street.FieldName, *suo.name) - s.Name = *suo.name + builder.Set(street.FieldName, *value) + s.Name = *value } if update { query, args := builder.Query() diff --git a/examples/m2m2types/ent/client.go b/examples/m2m2types/ent/client.go index a09e534ce..907c59ec2 100644 --- a/examples/m2m2types/ent/client.go +++ b/examples/m2m2types/ent/client.go @@ -130,6 +130,20 @@ func (c *GroupClient) Query() *GroupQuery { return &GroupQuery{config: c.config} } +// Get returns a Group entity by its id. +func (c *GroupClient) Get(ctx context.Context, id int) (*Group, error) { + return c.Query().Where(group.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *GroupClient) GetX(ctx context.Context, id int) *Group { + gr, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return gr +} + // QueryUsers queries the users edge of a Group. func (c *GroupClient) QueryUsers(gr *Group) *UserQuery { query := &UserQuery{config: c.config} @@ -200,6 +214,20 @@ func (c *UserClient) Query() *UserQuery { return &UserQuery{config: c.config} } +// Get returns a User entity by its id. +func (c *UserClient) Get(ctx context.Context, id int) (*User, error) { + return c.Query().Where(user.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *UserClient) GetX(ctx context.Context, id int) *User { + u, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return u +} + // QueryGroups queries the groups edge of a User. func (c *UserClient) QueryGroups(u *User) *GroupQuery { query := &GroupQuery{config: c.config} diff --git a/examples/m2m2types/ent/group_delete.go b/examples/m2m2types/ent/group_delete.go index c65da58d8..38cc63b52 100644 --- a/examples/m2m2types/ent/group_delete.go +++ b/examples/m2m2types/ent/group_delete.go @@ -21,32 +21,41 @@ type GroupDelete struct { predicates []predicate.Group } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (gd *GroupDelete) Where(ps ...predicate.Group) *GroupDelete { gd.predicates = append(gd.predicates, ps...) return gd } -// Exec executes the deletion query. -func (gd *GroupDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (gd *GroupDelete) Exec(ctx context.Context) (int, error) { return gd.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (gd *GroupDelete) ExecX(ctx context.Context) { - if err := gd.Exec(ctx); err != nil { +func (gd *GroupDelete) ExecX(ctx context.Context) int { + n, err := gd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (gd *GroupDelete) sqlExec(ctx context.Context) error { +func (gd *GroupDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(group.Table)) for _, p := range gd.predicates { p(selector) } query, args := sql.Delete(group.Table).FromSelect(selector).Query() - return gd.driver.Exec(ctx, query, args, &res) + if err := gd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // GroupDeleteOne is the builder for deleting a single Group entity. @@ -56,7 +65,15 @@ type GroupDeleteOne struct { // Exec executes the deletion query. func (gdo *GroupDeleteOne) Exec(ctx context.Context) error { - return gdo.gd.Exec(ctx) + n, err := gdo.gd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{group.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/m2m2types/ent/group_query.go b/examples/m2m2types/ent/group_query.go index c4c42ae4a..18bde620e 100644 --- a/examples/m2m2types/ent/group_query.go +++ b/examples/m2m2types/ent/group_query.go @@ -73,20 +73,6 @@ func (gq *GroupQuery) QueryUsers() *UserQuery { return query } -// Get returns a Group entity by its id. -func (gq *GroupQuery) Get(ctx context.Context, id int) (*Group, error) { - return gq.Where(group.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (gq *GroupQuery) GetX(ctx context.Context, id int) *Group { - gr, err := gq.Get(ctx, id) - if err != nil { - panic(err) - } - return gr -} - // First returns the first Group entity in the query. Returns *ErrNotFound when no group was found. func (gq *GroupQuery) First(ctx context.Context) (*Group, error) { grs, err := gq.Limit(1).All(ctx) diff --git a/examples/m2m2types/ent/group_update.go b/examples/m2m2types/ent/group_update.go index bd78e18db..717902f9c 100644 --- a/examples/m2m2types/ent/group_update.go +++ b/examples/m2m2types/ent/group_update.go @@ -136,9 +136,9 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(group.Table).Where(sql.InInts(group.FieldID, ids...)) ) - if gu.name != nil { + if value := gu.name; value != nil { update = true - builder.Set(group.FieldName, *gu.name) + builder.Set(group.FieldName, *value) } if update { query, args := builder.Query() @@ -299,10 +299,10 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (gr *Group, err error) { res sql.Result builder = sql.Update(group.Table).Where(sql.InInts(group.FieldID, ids...)) ) - if guo.name != nil { + if value := guo.name; value != nil { update = true - builder.Set(group.FieldName, *guo.name) - gr.Name = *guo.name + builder.Set(group.FieldName, *value) + gr.Name = *value } if update { query, args := builder.Query() diff --git a/examples/m2m2types/ent/user_delete.go b/examples/m2m2types/ent/user_delete.go index da59f8288..21dbc7460 100644 --- a/examples/m2m2types/ent/user_delete.go +++ b/examples/m2m2types/ent/user_delete.go @@ -21,32 +21,41 @@ type UserDelete struct { predicates []predicate.User } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { ud.predicates = append(ud.predicates, ps...) return ud } -// Exec executes the deletion query. -func (ud *UserDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (ud *UserDelete) Exec(ctx context.Context) (int, error) { return ud.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (ud *UserDelete) ExecX(ctx context.Context) { - if err := ud.Exec(ctx); err != nil { +func (ud *UserDelete) ExecX(ctx context.Context) int { + n, err := ud.Exec(ctx) + if err != nil { panic(err) } + return n } -func (ud *UserDelete) sqlExec(ctx context.Context) error { +func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(user.Table)) for _, p := range ud.predicates { p(selector) } query, args := sql.Delete(user.Table).FromSelect(selector).Query() - return ud.driver.Exec(ctx, query, args, &res) + if err := ud.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // UserDeleteOne is the builder for deleting a single User entity. @@ -56,7 +65,15 @@ type UserDeleteOne struct { // Exec executes the deletion query. func (udo *UserDeleteOne) Exec(ctx context.Context) error { - return udo.ud.Exec(ctx) + n, err := udo.ud.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{user.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/m2m2types/ent/user_query.go b/examples/m2m2types/ent/user_query.go index f699481a6..5eba5c7c4 100644 --- a/examples/m2m2types/ent/user_query.go +++ b/examples/m2m2types/ent/user_query.go @@ -73,20 +73,6 @@ func (uq *UserQuery) QueryGroups() *GroupQuery { return query } -// Get returns a User entity by its id. -func (uq *UserQuery) Get(ctx context.Context, id int) (*User, error) { - return uq.Where(user.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (uq *UserQuery) GetX(ctx context.Context, id int) *User { - u, err := uq.Get(ctx, id) - if err != nil { - panic(err) - } - return u -} - // First returns the first User entity in the query. Returns *ErrNotFound when no user was found. func (uq *UserQuery) First(ctx context.Context) (*User, error) { us, err := uq.Limit(1).All(ctx) diff --git a/examples/m2m2types/ent/user_update.go b/examples/m2m2types/ent/user_update.go index 043fb06f2..8fb50fe47 100644 --- a/examples/m2m2types/ent/user_update.go +++ b/examples/m2m2types/ent/user_update.go @@ -20,6 +20,7 @@ import ( type UserUpdate struct { config age *int + addage *int name *string groups map[int]struct{} removedGroups map[int]struct{} @@ -38,6 +39,12 @@ func (uu *UserUpdate) SetAge(i int) *UserUpdate { return uu } +// AddAge adds i to age. +func (uu *UserUpdate) AddAge(i int) *UserUpdate { + uu.addage = &i + return uu +} + // SetName sets the name field. func (uu *UserUpdate) SetName(s string) *UserUpdate { uu.name = &s @@ -143,13 +150,17 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uu.age != nil { + if value := uu.age; value != nil { update = true - builder.Set(user.FieldAge, *uu.age) + builder.Set(user.FieldAge, *value) } - if uu.name != nil { + if value := uu.addage; value != nil { update = true - builder.Set(user.FieldName, *uu.name) + builder.Add(user.FieldAge, *value) + } + if value := uu.name; value != nil { + update = true + builder.Set(user.FieldName, *value) } if update { query, args := builder.Query() @@ -198,6 +209,7 @@ type UserUpdateOne struct { config id int age *int + addage *int name *string groups map[int]struct{} removedGroups map[int]struct{} @@ -209,6 +221,12 @@ func (uuo *UserUpdateOne) SetAge(i int) *UserUpdateOne { return uuo } +// AddAge adds i to age. +func (uuo *UserUpdateOne) AddAge(i int) *UserUpdateOne { + uuo.addage = &i + return uuo +} + // SetName sets the name field. func (uuo *UserUpdateOne) SetName(s string) *UserUpdateOne { uuo.name = &s @@ -317,15 +335,20 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (u *User, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uuo.age != nil { + if value := uuo.age; value != nil { update = true - builder.Set(user.FieldAge, *uuo.age) - u.Age = *uuo.age + builder.Set(user.FieldAge, *value) + u.Age = *value } - if uuo.name != nil { + if value := uuo.addage; value != nil { update = true - builder.Set(user.FieldName, *uuo.name) - u.Name = *uuo.name + builder.Add(user.FieldAge, *value) + u.Age += *value + } + if value := uuo.name; value != nil { + update = true + builder.Set(user.FieldName, *value) + u.Name = *value } if update { query, args := builder.Query() diff --git a/examples/m2mbidi/ent/client.go b/examples/m2mbidi/ent/client.go index 2a2ae803a..aa66f4a23 100644 --- a/examples/m2mbidi/ent/client.go +++ b/examples/m2mbidi/ent/client.go @@ -124,6 +124,20 @@ func (c *UserClient) Query() *UserQuery { return &UserQuery{config: c.config} } +// Get returns a User entity by its id. +func (c *UserClient) Get(ctx context.Context, id int) (*User, error) { + return c.Query().Where(user.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *UserClient) GetX(ctx context.Context, id int) *User { + u, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return u +} + // QueryFriends queries the friends edge of a User. func (c *UserClient) QueryFriends(u *User) *UserQuery { query := &UserQuery{config: c.config} diff --git a/examples/m2mbidi/ent/user_delete.go b/examples/m2mbidi/ent/user_delete.go index ca7d47185..f3298deb4 100644 --- a/examples/m2mbidi/ent/user_delete.go +++ b/examples/m2mbidi/ent/user_delete.go @@ -21,32 +21,41 @@ type UserDelete struct { predicates []predicate.User } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { ud.predicates = append(ud.predicates, ps...) return ud } -// Exec executes the deletion query. -func (ud *UserDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (ud *UserDelete) Exec(ctx context.Context) (int, error) { return ud.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (ud *UserDelete) ExecX(ctx context.Context) { - if err := ud.Exec(ctx); err != nil { +func (ud *UserDelete) ExecX(ctx context.Context) int { + n, err := ud.Exec(ctx) + if err != nil { panic(err) } + return n } -func (ud *UserDelete) sqlExec(ctx context.Context) error { +func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(user.Table)) for _, p := range ud.predicates { p(selector) } query, args := sql.Delete(user.Table).FromSelect(selector).Query() - return ud.driver.Exec(ctx, query, args, &res) + if err := ud.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // UserDeleteOne is the builder for deleting a single User entity. @@ -56,7 +65,15 @@ type UserDeleteOne struct { // Exec executes the deletion query. func (udo *UserDeleteOne) Exec(ctx context.Context) error { - return udo.ud.Exec(ctx) + n, err := udo.ud.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{user.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/m2mbidi/ent/user_query.go b/examples/m2mbidi/ent/user_query.go index f502fc12c..c09cd9d06 100644 --- a/examples/m2mbidi/ent/user_query.go +++ b/examples/m2mbidi/ent/user_query.go @@ -72,20 +72,6 @@ func (uq *UserQuery) QueryFriends() *UserQuery { return query } -// Get returns a User entity by its id. -func (uq *UserQuery) Get(ctx context.Context, id int) (*User, error) { - return uq.Where(user.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (uq *UserQuery) GetX(ctx context.Context, id int) *User { - u, err := uq.Get(ctx, id) - if err != nil { - panic(err) - } - return u -} - // First returns the first User entity in the query. Returns *ErrNotFound when no user was found. func (uq *UserQuery) First(ctx context.Context) (*User, error) { us, err := uq.Limit(1).All(ctx) diff --git a/examples/m2mbidi/ent/user_update.go b/examples/m2mbidi/ent/user_update.go index c7272f342..90af6df26 100644 --- a/examples/m2mbidi/ent/user_update.go +++ b/examples/m2mbidi/ent/user_update.go @@ -20,6 +20,7 @@ import ( type UserUpdate struct { config age *int + addage *int name *string friends map[int]struct{} removedFriends map[int]struct{} @@ -38,6 +39,12 @@ func (uu *UserUpdate) SetAge(i int) *UserUpdate { return uu } +// AddAge adds i to age. +func (uu *UserUpdate) AddAge(i int) *UserUpdate { + uu.addage = &i + return uu +} + // SetName sets the name field. func (uu *UserUpdate) SetName(s string) *UserUpdate { uu.name = &s @@ -143,13 +150,17 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uu.age != nil { + if value := uu.age; value != nil { update = true - builder.Set(user.FieldAge, *uu.age) + builder.Set(user.FieldAge, *value) } - if uu.name != nil { + if value := uu.addage; value != nil { update = true - builder.Set(user.FieldName, *uu.name) + builder.Add(user.FieldAge, *value) + } + if value := uu.name; value != nil { + update = true + builder.Set(user.FieldName, *value) } if update { query, args := builder.Query() @@ -205,6 +216,7 @@ type UserUpdateOne struct { config id int age *int + addage *int name *string friends map[int]struct{} removedFriends map[int]struct{} @@ -216,6 +228,12 @@ func (uuo *UserUpdateOne) SetAge(i int) *UserUpdateOne { return uuo } +// AddAge adds i to age. +func (uuo *UserUpdateOne) AddAge(i int) *UserUpdateOne { + uuo.addage = &i + return uuo +} + // SetName sets the name field. func (uuo *UserUpdateOne) SetName(s string) *UserUpdateOne { uuo.name = &s @@ -324,15 +342,20 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (u *User, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uuo.age != nil { + if value := uuo.age; value != nil { update = true - builder.Set(user.FieldAge, *uuo.age) - u.Age = *uuo.age + builder.Set(user.FieldAge, *value) + u.Age = *value } - if uuo.name != nil { + if value := uuo.addage; value != nil { update = true - builder.Set(user.FieldName, *uuo.name) - u.Name = *uuo.name + builder.Add(user.FieldAge, *value) + u.Age += *value + } + if value := uuo.name; value != nil { + update = true + builder.Set(user.FieldName, *value) + u.Name = *value } if update { query, args := builder.Query() diff --git a/examples/m2mrecur/ent/client.go b/examples/m2mrecur/ent/client.go index cd82d4f6f..d2d8032b5 100644 --- a/examples/m2mrecur/ent/client.go +++ b/examples/m2mrecur/ent/client.go @@ -124,6 +124,20 @@ func (c *UserClient) Query() *UserQuery { return &UserQuery{config: c.config} } +// Get returns a User entity by its id. +func (c *UserClient) Get(ctx context.Context, id int) (*User, error) { + return c.Query().Where(user.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *UserClient) GetX(ctx context.Context, id int) *User { + u, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return u +} + // QueryFollowers queries the followers edge of a User. func (c *UserClient) QueryFollowers(u *User) *UserQuery { query := &UserQuery{config: c.config} diff --git a/examples/m2mrecur/ent/user_delete.go b/examples/m2mrecur/ent/user_delete.go index 80848bfd7..b6b408d87 100644 --- a/examples/m2mrecur/ent/user_delete.go +++ b/examples/m2mrecur/ent/user_delete.go @@ -21,32 +21,41 @@ type UserDelete struct { predicates []predicate.User } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { ud.predicates = append(ud.predicates, ps...) return ud } -// Exec executes the deletion query. -func (ud *UserDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (ud *UserDelete) Exec(ctx context.Context) (int, error) { return ud.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (ud *UserDelete) ExecX(ctx context.Context) { - if err := ud.Exec(ctx); err != nil { +func (ud *UserDelete) ExecX(ctx context.Context) int { + n, err := ud.Exec(ctx) + if err != nil { panic(err) } + return n } -func (ud *UserDelete) sqlExec(ctx context.Context) error { +func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(user.Table)) for _, p := range ud.predicates { p(selector) } query, args := sql.Delete(user.Table).FromSelect(selector).Query() - return ud.driver.Exec(ctx, query, args, &res) + if err := ud.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // UserDeleteOne is the builder for deleting a single User entity. @@ -56,7 +65,15 @@ type UserDeleteOne struct { // Exec executes the deletion query. func (udo *UserDeleteOne) Exec(ctx context.Context) error { - return udo.ud.Exec(ctx) + n, err := udo.ud.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{user.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/m2mrecur/ent/user_query.go b/examples/m2mrecur/ent/user_query.go index 877e54381..f4ba159c1 100644 --- a/examples/m2mrecur/ent/user_query.go +++ b/examples/m2mrecur/ent/user_query.go @@ -90,20 +90,6 @@ func (uq *UserQuery) QueryFollowing() *UserQuery { return query } -// Get returns a User entity by its id. -func (uq *UserQuery) Get(ctx context.Context, id int) (*User, error) { - return uq.Where(user.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (uq *UserQuery) GetX(ctx context.Context, id int) *User { - u, err := uq.Get(ctx, id) - if err != nil { - panic(err) - } - return u -} - // First returns the first User entity in the query. Returns *ErrNotFound when no user was found. func (uq *UserQuery) First(ctx context.Context) (*User, error) { us, err := uq.Limit(1).All(ctx) diff --git a/examples/m2mrecur/ent/user_update.go b/examples/m2mrecur/ent/user_update.go index fb6f87fad..2e3000882 100644 --- a/examples/m2mrecur/ent/user_update.go +++ b/examples/m2mrecur/ent/user_update.go @@ -20,6 +20,7 @@ import ( type UserUpdate struct { config age *int + addage *int name *string followers map[int]struct{} following map[int]struct{} @@ -40,6 +41,12 @@ func (uu *UserUpdate) SetAge(i int) *UserUpdate { return uu } +// AddAge adds i to age. +func (uu *UserUpdate) AddAge(i int) *UserUpdate { + uu.addage = &i + return uu +} + // SetName sets the name field. func (uu *UserUpdate) SetName(s string) *UserUpdate { uu.name = &s @@ -185,13 +192,17 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uu.age != nil { + if value := uu.age; value != nil { update = true - builder.Set(user.FieldAge, *uu.age) + builder.Set(user.FieldAge, *value) } - if uu.name != nil { + if value := uu.addage; value != nil { update = true - builder.Set(user.FieldName, *uu.name) + builder.Add(user.FieldAge, *value) + } + if value := uu.name; value != nil { + update = true + builder.Set(user.FieldName, *value) } if update { query, args := builder.Query() @@ -270,6 +281,7 @@ type UserUpdateOne struct { config id int age *int + addage *int name *string followers map[int]struct{} following map[int]struct{} @@ -283,6 +295,12 @@ func (uuo *UserUpdateOne) SetAge(i int) *UserUpdateOne { return uuo } +// AddAge adds i to age. +func (uuo *UserUpdateOne) AddAge(i int) *UserUpdateOne { + uuo.addage = &i + return uuo +} + // SetName sets the name field. func (uuo *UserUpdateOne) SetName(s string) *UserUpdateOne { uuo.name = &s @@ -431,15 +449,20 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (u *User, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uuo.age != nil { + if value := uuo.age; value != nil { update = true - builder.Set(user.FieldAge, *uuo.age) - u.Age = *uuo.age + builder.Set(user.FieldAge, *value) + u.Age = *value } - if uuo.name != nil { + if value := uuo.addage; value != nil { update = true - builder.Set(user.FieldName, *uuo.name) - u.Name = *uuo.name + builder.Add(user.FieldAge, *value) + u.Age += *value + } + if value := uuo.name; value != nil { + update = true + builder.Set(user.FieldName, *value) + u.Name = *value } if update { query, args := builder.Query() diff --git a/examples/o2m2types/ent/client.go b/examples/o2m2types/ent/client.go index 6a249166e..8befb71b6 100644 --- a/examples/o2m2types/ent/client.go +++ b/examples/o2m2types/ent/client.go @@ -130,6 +130,20 @@ func (c *PetClient) Query() *PetQuery { return &PetQuery{config: c.config} } +// Get returns a Pet entity by its id. +func (c *PetClient) Get(ctx context.Context, id int) (*Pet, error) { + return c.Query().Where(pet.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *PetClient) GetX(ctx context.Context, id int) *Pet { + pe, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return pe +} + // QueryOwner queries the owner edge of a Pet. func (c *PetClient) QueryOwner(pe *Pet) *UserQuery { query := &UserQuery{config: c.config} @@ -193,6 +207,20 @@ func (c *UserClient) Query() *UserQuery { return &UserQuery{config: c.config} } +// Get returns a User entity by its id. +func (c *UserClient) Get(ctx context.Context, id int) (*User, error) { + return c.Query().Where(user.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *UserClient) GetX(ctx context.Context, id int) *User { + u, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return u +} + // QueryPets queries the pets edge of a User. func (c *UserClient) QueryPets(u *User) *PetQuery { query := &PetQuery{config: c.config} diff --git a/examples/o2m2types/ent/pet_delete.go b/examples/o2m2types/ent/pet_delete.go index 125b64e7f..4c374a825 100644 --- a/examples/o2m2types/ent/pet_delete.go +++ b/examples/o2m2types/ent/pet_delete.go @@ -21,32 +21,41 @@ type PetDelete struct { predicates []predicate.Pet } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (pd *PetDelete) Where(ps ...predicate.Pet) *PetDelete { pd.predicates = append(pd.predicates, ps...) return pd } -// Exec executes the deletion query. -func (pd *PetDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (pd *PetDelete) Exec(ctx context.Context) (int, error) { return pd.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (pd *PetDelete) ExecX(ctx context.Context) { - if err := pd.Exec(ctx); err != nil { +func (pd *PetDelete) ExecX(ctx context.Context) int { + n, err := pd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (pd *PetDelete) sqlExec(ctx context.Context) error { +func (pd *PetDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(pet.Table)) for _, p := range pd.predicates { p(selector) } query, args := sql.Delete(pet.Table).FromSelect(selector).Query() - return pd.driver.Exec(ctx, query, args, &res) + if err := pd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // PetDeleteOne is the builder for deleting a single Pet entity. @@ -56,7 +65,15 @@ type PetDeleteOne struct { // Exec executes the deletion query. func (pdo *PetDeleteOne) Exec(ctx context.Context) error { - return pdo.pd.Exec(ctx) + n, err := pdo.pd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{pet.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/o2m2types/ent/pet_query.go b/examples/o2m2types/ent/pet_query.go index fd9f97c6a..0a6705369 100644 --- a/examples/o2m2types/ent/pet_query.go +++ b/examples/o2m2types/ent/pet_query.go @@ -68,20 +68,6 @@ func (pq *PetQuery) QueryOwner() *UserQuery { return query } -// Get returns a Pet entity by its id. -func (pq *PetQuery) Get(ctx context.Context, id int) (*Pet, error) { - return pq.Where(pet.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (pq *PetQuery) GetX(ctx context.Context, id int) *Pet { - pe, err := pq.Get(ctx, id) - if err != nil { - panic(err) - } - return pe -} - // First returns the first Pet entity in the query. Returns *ErrNotFound when no pet was found. func (pq *PetQuery) First(ctx context.Context) (*Pet, error) { pes, err := pq.Limit(1).All(ctx) diff --git a/examples/o2m2types/ent/pet_update.go b/examples/o2m2types/ent/pet_update.go index acb4ebde2..5c35843b1 100644 --- a/examples/o2m2types/ent/pet_update.go +++ b/examples/o2m2types/ent/pet_update.go @@ -129,9 +129,9 @@ func (pu *PetUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(pet.Table).Where(sql.InInts(pet.FieldID, ids...)) ) - if pu.name != nil { + if value := pu.name; value != nil { update = true - builder.Set(pet.FieldName, *pu.name) + builder.Set(pet.FieldName, *value) } if update { query, args := builder.Query() @@ -273,10 +273,10 @@ func (puo *PetUpdateOne) sqlSave(ctx context.Context) (pe *Pet, err error) { res sql.Result builder = sql.Update(pet.Table).Where(sql.InInts(pet.FieldID, ids...)) ) - if puo.name != nil { + if value := puo.name; value != nil { update = true - builder.Set(pet.FieldName, *puo.name) - pe.Name = *puo.name + builder.Set(pet.FieldName, *value) + pe.Name = *value } if update { query, args := builder.Query() diff --git a/examples/o2m2types/ent/user_delete.go b/examples/o2m2types/ent/user_delete.go index 89edaaf53..59bc9f4dc 100644 --- a/examples/o2m2types/ent/user_delete.go +++ b/examples/o2m2types/ent/user_delete.go @@ -21,32 +21,41 @@ type UserDelete struct { predicates []predicate.User } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { ud.predicates = append(ud.predicates, ps...) return ud } -// Exec executes the deletion query. -func (ud *UserDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (ud *UserDelete) Exec(ctx context.Context) (int, error) { return ud.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (ud *UserDelete) ExecX(ctx context.Context) { - if err := ud.Exec(ctx); err != nil { +func (ud *UserDelete) ExecX(ctx context.Context) int { + n, err := ud.Exec(ctx) + if err != nil { panic(err) } + return n } -func (ud *UserDelete) sqlExec(ctx context.Context) error { +func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(user.Table)) for _, p := range ud.predicates { p(selector) } query, args := sql.Delete(user.Table).FromSelect(selector).Query() - return ud.driver.Exec(ctx, query, args, &res) + if err := ud.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // UserDeleteOne is the builder for deleting a single User entity. @@ -56,7 +65,15 @@ type UserDeleteOne struct { // Exec executes the deletion query. func (udo *UserDeleteOne) Exec(ctx context.Context) error { - return udo.ud.Exec(ctx) + n, err := udo.ud.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{user.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/o2m2types/ent/user_query.go b/examples/o2m2types/ent/user_query.go index 1f7c9e425..5e1fa7a7c 100644 --- a/examples/o2m2types/ent/user_query.go +++ b/examples/o2m2types/ent/user_query.go @@ -68,20 +68,6 @@ func (uq *UserQuery) QueryPets() *PetQuery { return query } -// Get returns a User entity by its id. -func (uq *UserQuery) Get(ctx context.Context, id int) (*User, error) { - return uq.Where(user.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (uq *UserQuery) GetX(ctx context.Context, id int) *User { - u, err := uq.Get(ctx, id) - if err != nil { - panic(err) - } - return u -} - // First returns the first User entity in the query. Returns *ErrNotFound when no user was found. func (uq *UserQuery) First(ctx context.Context) (*User, error) { us, err := uq.Limit(1).All(ctx) diff --git a/examples/o2m2types/ent/user_update.go b/examples/o2m2types/ent/user_update.go index 502191099..4f0fae2fe 100644 --- a/examples/o2m2types/ent/user_update.go +++ b/examples/o2m2types/ent/user_update.go @@ -21,6 +21,7 @@ import ( type UserUpdate struct { config age *int + addage *int name *string pets map[int]struct{} removedPets map[int]struct{} @@ -39,6 +40,12 @@ func (uu *UserUpdate) SetAge(i int) *UserUpdate { return uu } +// AddAge adds i to age. +func (uu *UserUpdate) AddAge(i int) *UserUpdate { + uu.addage = &i + return uu +} + // SetName sets the name field. func (uu *UserUpdate) SetName(s string) *UserUpdate { uu.name = &s @@ -144,13 +151,17 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uu.age != nil { + if value := uu.age; value != nil { update = true - builder.Set(user.FieldAge, *uu.age) + builder.Set(user.FieldAge, *value) } - if uu.name != nil { + if value := uu.addage; value != nil { update = true - builder.Set(user.FieldName, *uu.name) + builder.Add(user.FieldAge, *value) + } + if value := uu.name; value != nil { + update = true + builder.Set(user.FieldName, *value) } if update { query, args := builder.Query() @@ -205,6 +216,7 @@ type UserUpdateOne struct { config id int age *int + addage *int name *string pets map[int]struct{} removedPets map[int]struct{} @@ -216,6 +228,12 @@ func (uuo *UserUpdateOne) SetAge(i int) *UserUpdateOne { return uuo } +// AddAge adds i to age. +func (uuo *UserUpdateOne) AddAge(i int) *UserUpdateOne { + uuo.addage = &i + return uuo +} + // SetName sets the name field. func (uuo *UserUpdateOne) SetName(s string) *UserUpdateOne { uuo.name = &s @@ -324,15 +342,20 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (u *User, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uuo.age != nil { + if value := uuo.age; value != nil { update = true - builder.Set(user.FieldAge, *uuo.age) - u.Age = *uuo.age + builder.Set(user.FieldAge, *value) + u.Age = *value } - if uuo.name != nil { + if value := uuo.addage; value != nil { update = true - builder.Set(user.FieldName, *uuo.name) - u.Name = *uuo.name + builder.Add(user.FieldAge, *value) + u.Age += *value + } + if value := uuo.name; value != nil { + update = true + builder.Set(user.FieldName, *value) + u.Name = *value } if update { query, args := builder.Query() diff --git a/examples/o2mrecur/ent/client.go b/examples/o2mrecur/ent/client.go index 78aa2237e..ab4593f1b 100644 --- a/examples/o2mrecur/ent/client.go +++ b/examples/o2mrecur/ent/client.go @@ -124,6 +124,20 @@ func (c *NodeClient) Query() *NodeQuery { return &NodeQuery{config: c.config} } +// Get returns a Node entity by its id. +func (c *NodeClient) Get(ctx context.Context, id int) (*Node, error) { + return c.Query().Where(node.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *NodeClient) GetX(ctx context.Context, id int) *Node { + n, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return n +} + // QueryParent queries the parent edge of a Node. func (c *NodeClient) QueryParent(n *Node) *NodeQuery { query := &NodeQuery{config: c.config} diff --git a/examples/o2mrecur/ent/node_delete.go b/examples/o2mrecur/ent/node_delete.go index 968d614fa..99c0b807a 100644 --- a/examples/o2mrecur/ent/node_delete.go +++ b/examples/o2mrecur/ent/node_delete.go @@ -21,32 +21,41 @@ type NodeDelete struct { predicates []predicate.Node } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (nd *NodeDelete) Where(ps ...predicate.Node) *NodeDelete { nd.predicates = append(nd.predicates, ps...) return nd } -// Exec executes the deletion query. -func (nd *NodeDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (nd *NodeDelete) Exec(ctx context.Context) (int, error) { return nd.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (nd *NodeDelete) ExecX(ctx context.Context) { - if err := nd.Exec(ctx); err != nil { +func (nd *NodeDelete) ExecX(ctx context.Context) int { + n, err := nd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (nd *NodeDelete) sqlExec(ctx context.Context) error { +func (nd *NodeDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(node.Table)) for _, p := range nd.predicates { p(selector) } query, args := sql.Delete(node.Table).FromSelect(selector).Query() - return nd.driver.Exec(ctx, query, args, &res) + if err := nd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // NodeDeleteOne is the builder for deleting a single Node entity. @@ -56,7 +65,15 @@ type NodeDeleteOne struct { // Exec executes the deletion query. func (ndo *NodeDeleteOne) Exec(ctx context.Context) error { - return ndo.nd.Exec(ctx) + n, err := ndo.nd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{node.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/o2mrecur/ent/node_query.go b/examples/o2mrecur/ent/node_query.go index bc8ab4b35..54fc8b0c9 100644 --- a/examples/o2mrecur/ent/node_query.go +++ b/examples/o2mrecur/ent/node_query.go @@ -80,20 +80,6 @@ func (nq *NodeQuery) QueryChildren() *NodeQuery { return query } -// Get returns a Node entity by its id. -func (nq *NodeQuery) Get(ctx context.Context, id int) (*Node, error) { - return nq.Where(node.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (nq *NodeQuery) GetX(ctx context.Context, id int) *Node { - n, err := nq.Get(ctx, id) - if err != nil { - panic(err) - } - return n -} - // First returns the first Node entity in the query. Returns *ErrNotFound when no node was found. func (nq *NodeQuery) First(ctx context.Context) (*Node, error) { ns, err := nq.Limit(1).All(ctx) diff --git a/examples/o2mrecur/ent/node_update.go b/examples/o2mrecur/ent/node_update.go index 92d1fdce7..7a9bdf195 100644 --- a/examples/o2mrecur/ent/node_update.go +++ b/examples/o2mrecur/ent/node_update.go @@ -21,6 +21,7 @@ import ( type NodeUpdate struct { config value *int + addvalue *int parent map[int]struct{} children map[int]struct{} clearedParent bool @@ -40,6 +41,12 @@ func (nu *NodeUpdate) SetValue(i int) *NodeUpdate { return nu } +// AddValue adds i to value. +func (nu *NodeUpdate) AddValue(i int) *NodeUpdate { + nu.addvalue = &i + return nu +} + // SetParentID sets the parent edge to Node by id. func (nu *NodeUpdate) SetParentID(id int) *NodeUpdate { if nu.parent == nil { @@ -170,9 +177,13 @@ func (nu *NodeUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(node.Table).Where(sql.InInts(node.FieldID, ids...)) ) - if nu.value != nil { + if value := nu.value; value != nil { update = true - builder.Set(node.FieldValue, *nu.value) + builder.Set(node.FieldValue, *value) + } + if value := nu.addvalue; value != nil { + update = true + builder.Add(node.FieldValue, *value) } if update { query, args := builder.Query() @@ -247,6 +258,7 @@ type NodeUpdateOne struct { config id int value *int + addvalue *int parent map[int]struct{} children map[int]struct{} clearedParent bool @@ -259,6 +271,12 @@ func (nuo *NodeUpdateOne) SetValue(i int) *NodeUpdateOne { return nuo } +// AddValue adds i to value. +func (nuo *NodeUpdateOne) AddValue(i int) *NodeUpdateOne { + nuo.addvalue = &i + return nuo +} + // SetParentID sets the parent edge to Node by id. func (nuo *NodeUpdateOne) SetParentID(id int) *NodeUpdateOne { if nuo.parent == nil { @@ -392,10 +410,15 @@ func (nuo *NodeUpdateOne) sqlSave(ctx context.Context) (n *Node, err error) { res sql.Result builder = sql.Update(node.Table).Where(sql.InInts(node.FieldID, ids...)) ) - if nuo.value != nil { + if value := nuo.value; value != nil { update = true - builder.Set(node.FieldValue, *nuo.value) - n.Value = *nuo.value + builder.Set(node.FieldValue, *value) + n.Value = *value + } + if value := nuo.addvalue; value != nil { + update = true + builder.Add(node.FieldValue, *value) + n.Value += *value } if update { query, args := builder.Query() diff --git a/examples/o2o2types/ent/card_delete.go b/examples/o2o2types/ent/card_delete.go index 2f5fa5ad9..06a404cc2 100644 --- a/examples/o2o2types/ent/card_delete.go +++ b/examples/o2o2types/ent/card_delete.go @@ -21,32 +21,41 @@ type CardDelete struct { predicates []predicate.Card } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (cd *CardDelete) Where(ps ...predicate.Card) *CardDelete { cd.predicates = append(cd.predicates, ps...) return cd } -// Exec executes the deletion query. -func (cd *CardDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (cd *CardDelete) Exec(ctx context.Context) (int, error) { return cd.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (cd *CardDelete) ExecX(ctx context.Context) { - if err := cd.Exec(ctx); err != nil { +func (cd *CardDelete) ExecX(ctx context.Context) int { + n, err := cd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (cd *CardDelete) sqlExec(ctx context.Context) error { +func (cd *CardDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(card.Table)) for _, p := range cd.predicates { p(selector) } query, args := sql.Delete(card.Table).FromSelect(selector).Query() - return cd.driver.Exec(ctx, query, args, &res) + if err := cd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // CardDeleteOne is the builder for deleting a single Card entity. @@ -56,7 +65,15 @@ type CardDeleteOne struct { // Exec executes the deletion query. func (cdo *CardDeleteOne) Exec(ctx context.Context) error { - return cdo.cd.Exec(ctx) + n, err := cdo.cd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{card.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/o2o2types/ent/card_query.go b/examples/o2o2types/ent/card_query.go index 00a5ffbc6..ec3ee5628 100644 --- a/examples/o2o2types/ent/card_query.go +++ b/examples/o2o2types/ent/card_query.go @@ -68,20 +68,6 @@ func (cq *CardQuery) QueryOwner() *UserQuery { return query } -// Get returns a Card entity by its id. -func (cq *CardQuery) Get(ctx context.Context, id int) (*Card, error) { - return cq.Where(card.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (cq *CardQuery) GetX(ctx context.Context, id int) *Card { - c, err := cq.Get(ctx, id) - if err != nil { - panic(err) - } - return c -} - // First returns the first Card entity in the query. Returns *ErrNotFound when no card was found. func (cq *CardQuery) First(ctx context.Context) (*Card, error) { cs, err := cq.Limit(1).All(ctx) diff --git a/examples/o2o2types/ent/card_update.go b/examples/o2o2types/ent/card_update.go index 86654b0ab..469176b6f 100644 --- a/examples/o2o2types/ent/card_update.go +++ b/examples/o2o2types/ent/card_update.go @@ -132,13 +132,13 @@ func (cu *CardUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(card.Table).Where(sql.InInts(card.FieldID, ids...)) ) - if cu.expired != nil { + if value := cu.expired; value != nil { update = true - builder.Set(card.FieldExpired, *cu.expired) + builder.Set(card.FieldExpired, *value) } - if cu.number != nil { + if value := cu.number; value != nil { update = true - builder.Set(card.FieldNumber, *cu.number) + builder.Set(card.FieldNumber, *value) } if update { query, args := builder.Query() @@ -290,15 +290,15 @@ func (cuo *CardUpdateOne) sqlSave(ctx context.Context) (c *Card, err error) { res sql.Result builder = sql.Update(card.Table).Where(sql.InInts(card.FieldID, ids...)) ) - if cuo.expired != nil { + if value := cuo.expired; value != nil { update = true - builder.Set(card.FieldExpired, *cuo.expired) - c.Expired = *cuo.expired + builder.Set(card.FieldExpired, *value) + c.Expired = *value } - if cuo.number != nil { + if value := cuo.number; value != nil { update = true - builder.Set(card.FieldNumber, *cuo.number) - c.Number = *cuo.number + builder.Set(card.FieldNumber, *value) + c.Number = *value } if update { query, args := builder.Query() diff --git a/examples/o2o2types/ent/client.go b/examples/o2o2types/ent/client.go index 5098a06fd..2f0d53a87 100644 --- a/examples/o2o2types/ent/client.go +++ b/examples/o2o2types/ent/client.go @@ -130,6 +130,20 @@ func (c *CardClient) Query() *CardQuery { return &CardQuery{config: c.config} } +// Get returns a Card entity by its id. +func (c *CardClient) Get(ctx context.Context, id int) (*Card, error) { + return c.Query().Where(card.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *CardClient) GetX(ctx context.Context, id int) *Card { + ca, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return ca +} + // QueryOwner queries the owner edge of a Card. func (c *CardClient) QueryOwner(ca *Card) *UserQuery { query := &UserQuery{config: c.config} @@ -193,6 +207,20 @@ func (c *UserClient) Query() *UserQuery { return &UserQuery{config: c.config} } +// Get returns a User entity by its id. +func (c *UserClient) Get(ctx context.Context, id int) (*User, error) { + return c.Query().Where(user.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *UserClient) GetX(ctx context.Context, id int) *User { + u, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return u +} + // QueryCard queries the card edge of a User. func (c *UserClient) QueryCard(u *User) *CardQuery { query := &CardQuery{config: c.config} diff --git a/examples/o2o2types/ent/user_delete.go b/examples/o2o2types/ent/user_delete.go index 990408ea8..7af51fb06 100644 --- a/examples/o2o2types/ent/user_delete.go +++ b/examples/o2o2types/ent/user_delete.go @@ -21,32 +21,41 @@ type UserDelete struct { predicates []predicate.User } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { ud.predicates = append(ud.predicates, ps...) return ud } -// Exec executes the deletion query. -func (ud *UserDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (ud *UserDelete) Exec(ctx context.Context) (int, error) { return ud.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (ud *UserDelete) ExecX(ctx context.Context) { - if err := ud.Exec(ctx); err != nil { +func (ud *UserDelete) ExecX(ctx context.Context) int { + n, err := ud.Exec(ctx) + if err != nil { panic(err) } + return n } -func (ud *UserDelete) sqlExec(ctx context.Context) error { +func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(user.Table)) for _, p := range ud.predicates { p(selector) } query, args := sql.Delete(user.Table).FromSelect(selector).Query() - return ud.driver.Exec(ctx, query, args, &res) + if err := ud.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // UserDeleteOne is the builder for deleting a single User entity. @@ -56,7 +65,15 @@ type UserDeleteOne struct { // Exec executes the deletion query. func (udo *UserDeleteOne) Exec(ctx context.Context) error { - return udo.ud.Exec(ctx) + n, err := udo.ud.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{user.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/o2o2types/ent/user_query.go b/examples/o2o2types/ent/user_query.go index 6cc8534ee..c66396aa5 100644 --- a/examples/o2o2types/ent/user_query.go +++ b/examples/o2o2types/ent/user_query.go @@ -68,20 +68,6 @@ func (uq *UserQuery) QueryCard() *CardQuery { return query } -// Get returns a User entity by its id. -func (uq *UserQuery) Get(ctx context.Context, id int) (*User, error) { - return uq.Where(user.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (uq *UserQuery) GetX(ctx context.Context, id int) *User { - u, err := uq.Get(ctx, id) - if err != nil { - panic(err) - } - return u -} - // First returns the first User entity in the query. Returns *ErrNotFound when no user was found. func (uq *UserQuery) First(ctx context.Context) (*User, error) { us, err := uq.Limit(1).All(ctx) diff --git a/examples/o2o2types/ent/user_update.go b/examples/o2o2types/ent/user_update.go index 2e199e3a6..c95e1fb5a 100644 --- a/examples/o2o2types/ent/user_update.go +++ b/examples/o2o2types/ent/user_update.go @@ -22,6 +22,7 @@ import ( type UserUpdate struct { config age *int + addage *int name *string card map[int]struct{} clearedCard bool @@ -40,6 +41,12 @@ func (uu *UserUpdate) SetAge(i int) *UserUpdate { return uu } +// AddAge adds i to age. +func (uu *UserUpdate) AddAge(i int) *UserUpdate { + uu.addage = &i + return uu +} + // SetName sets the name field. func (uu *UserUpdate) SetName(s string) *UserUpdate { uu.name = &s @@ -136,13 +143,17 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uu.age != nil { + if value := uu.age; value != nil { update = true - builder.Set(user.FieldAge, *uu.age) + builder.Set(user.FieldAge, *value) } - if uu.name != nil { + if value := uu.addage; value != nil { update = true - builder.Set(user.FieldName, *uu.name) + builder.Add(user.FieldAge, *value) + } + if value := uu.name; value != nil { + update = true + builder.Set(user.FieldName, *value) } if update { query, args := builder.Query() @@ -189,6 +200,7 @@ type UserUpdateOne struct { config id int age *int + addage *int name *string card map[int]struct{} clearedCard bool @@ -200,6 +212,12 @@ func (uuo *UserUpdateOne) SetAge(i int) *UserUpdateOne { return uuo } +// AddAge adds i to age. +func (uuo *UserUpdateOne) AddAge(i int) *UserUpdateOne { + uuo.addage = &i + return uuo +} + // SetName sets the name field. func (uuo *UserUpdateOne) SetName(s string) *UserUpdateOne { uuo.name = &s @@ -299,15 +317,20 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (u *User, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uuo.age != nil { + if value := uuo.age; value != nil { update = true - builder.Set(user.FieldAge, *uuo.age) - u.Age = *uuo.age + builder.Set(user.FieldAge, *value) + u.Age = *value } - if uuo.name != nil { + if value := uuo.addage; value != nil { update = true - builder.Set(user.FieldName, *uuo.name) - u.Name = *uuo.name + builder.Add(user.FieldAge, *value) + u.Age += *value + } + if value := uuo.name; value != nil { + update = true + builder.Set(user.FieldName, *value) + u.Name = *value } if update { query, args := builder.Query() diff --git a/examples/o2obidi/ent/client.go b/examples/o2obidi/ent/client.go index 95bcb1d89..a2f9c385f 100644 --- a/examples/o2obidi/ent/client.go +++ b/examples/o2obidi/ent/client.go @@ -124,6 +124,20 @@ func (c *UserClient) Query() *UserQuery { return &UserQuery{config: c.config} } +// Get returns a User entity by its id. +func (c *UserClient) Get(ctx context.Context, id int) (*User, error) { + return c.Query().Where(user.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *UserClient) GetX(ctx context.Context, id int) *User { + u, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return u +} + // QuerySpouse queries the spouse edge of a User. func (c *UserClient) QuerySpouse(u *User) *UserQuery { query := &UserQuery{config: c.config} diff --git a/examples/o2obidi/ent/user_delete.go b/examples/o2obidi/ent/user_delete.go index eb48344d8..f76f38900 100644 --- a/examples/o2obidi/ent/user_delete.go +++ b/examples/o2obidi/ent/user_delete.go @@ -21,32 +21,41 @@ type UserDelete struct { predicates []predicate.User } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { ud.predicates = append(ud.predicates, ps...) return ud } -// Exec executes the deletion query. -func (ud *UserDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (ud *UserDelete) Exec(ctx context.Context) (int, error) { return ud.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (ud *UserDelete) ExecX(ctx context.Context) { - if err := ud.Exec(ctx); err != nil { +func (ud *UserDelete) ExecX(ctx context.Context) int { + n, err := ud.Exec(ctx) + if err != nil { panic(err) } + return n } -func (ud *UserDelete) sqlExec(ctx context.Context) error { +func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(user.Table)) for _, p := range ud.predicates { p(selector) } query, args := sql.Delete(user.Table).FromSelect(selector).Query() - return ud.driver.Exec(ctx, query, args, &res) + if err := ud.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // UserDeleteOne is the builder for deleting a single User entity. @@ -56,7 +65,15 @@ type UserDeleteOne struct { // Exec executes the deletion query. func (udo *UserDeleteOne) Exec(ctx context.Context) error { - return udo.ud.Exec(ctx) + n, err := udo.ud.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{user.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/o2obidi/ent/user_query.go b/examples/o2obidi/ent/user_query.go index 84ee32539..22563379c 100644 --- a/examples/o2obidi/ent/user_query.go +++ b/examples/o2obidi/ent/user_query.go @@ -67,20 +67,6 @@ func (uq *UserQuery) QuerySpouse() *UserQuery { return query } -// Get returns a User entity by its id. -func (uq *UserQuery) Get(ctx context.Context, id int) (*User, error) { - return uq.Where(user.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (uq *UserQuery) GetX(ctx context.Context, id int) *User { - u, err := uq.Get(ctx, id) - if err != nil { - panic(err) - } - return u -} - // First returns the first User entity in the query. Returns *ErrNotFound when no user was found. func (uq *UserQuery) First(ctx context.Context) (*User, error) { us, err := uq.Limit(1).All(ctx) diff --git a/examples/o2obidi/ent/user_update.go b/examples/o2obidi/ent/user_update.go index c871a9577..2867a2eeb 100644 --- a/examples/o2obidi/ent/user_update.go +++ b/examples/o2obidi/ent/user_update.go @@ -21,6 +21,7 @@ import ( type UserUpdate struct { config age *int + addage *int name *string spouse map[int]struct{} clearedSpouse bool @@ -39,6 +40,12 @@ func (uu *UserUpdate) SetAge(i int) *UserUpdate { return uu } +// AddAge adds i to age. +func (uu *UserUpdate) AddAge(i int) *UserUpdate { + uu.addage = &i + return uu +} + // SetName sets the name field. func (uu *UserUpdate) SetName(s string) *UserUpdate { uu.name = &s @@ -135,13 +142,17 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uu.age != nil { + if value := uu.age; value != nil { update = true - builder.Set(user.FieldAge, *uu.age) + builder.Set(user.FieldAge, *value) } - if uu.name != nil { + if value := uu.addage; value != nil { update = true - builder.Set(user.FieldName, *uu.name) + builder.Add(user.FieldAge, *value) + } + if value := uu.name; value != nil { + update = true + builder.Set(user.FieldName, *value) } if update { query, args := builder.Query() @@ -202,6 +213,7 @@ type UserUpdateOne struct { config id int age *int + addage *int name *string spouse map[int]struct{} clearedSpouse bool @@ -213,6 +225,12 @@ func (uuo *UserUpdateOne) SetAge(i int) *UserUpdateOne { return uuo } +// AddAge adds i to age. +func (uuo *UserUpdateOne) AddAge(i int) *UserUpdateOne { + uuo.addage = &i + return uuo +} + // SetName sets the name field. func (uuo *UserUpdateOne) SetName(s string) *UserUpdateOne { uuo.name = &s @@ -312,15 +330,20 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (u *User, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uuo.age != nil { + if value := uuo.age; value != nil { update = true - builder.Set(user.FieldAge, *uuo.age) - u.Age = *uuo.age + builder.Set(user.FieldAge, *value) + u.Age = *value } - if uuo.name != nil { + if value := uuo.addage; value != nil { update = true - builder.Set(user.FieldName, *uuo.name) - u.Name = *uuo.name + builder.Add(user.FieldAge, *value) + u.Age += *value + } + if value := uuo.name; value != nil { + update = true + builder.Set(user.FieldName, *value) + u.Name = *value } if update { query, args := builder.Query() diff --git a/examples/o2orecur/ent/client.go b/examples/o2orecur/ent/client.go index 058394540..1ed5680ac 100644 --- a/examples/o2orecur/ent/client.go +++ b/examples/o2orecur/ent/client.go @@ -124,6 +124,20 @@ func (c *NodeClient) Query() *NodeQuery { return &NodeQuery{config: c.config} } +// Get returns a Node entity by its id. +func (c *NodeClient) Get(ctx context.Context, id int) (*Node, error) { + return c.Query().Where(node.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *NodeClient) GetX(ctx context.Context, id int) *Node { + n, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return n +} + // QueryPrev queries the prev edge of a Node. func (c *NodeClient) QueryPrev(n *Node) *NodeQuery { query := &NodeQuery{config: c.config} diff --git a/examples/o2orecur/ent/node_delete.go b/examples/o2orecur/ent/node_delete.go index 4c2f74d76..6ba036718 100644 --- a/examples/o2orecur/ent/node_delete.go +++ b/examples/o2orecur/ent/node_delete.go @@ -21,32 +21,41 @@ type NodeDelete struct { predicates []predicate.Node } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (nd *NodeDelete) Where(ps ...predicate.Node) *NodeDelete { nd.predicates = append(nd.predicates, ps...) return nd } -// Exec executes the deletion query. -func (nd *NodeDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (nd *NodeDelete) Exec(ctx context.Context) (int, error) { return nd.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (nd *NodeDelete) ExecX(ctx context.Context) { - if err := nd.Exec(ctx); err != nil { +func (nd *NodeDelete) ExecX(ctx context.Context) int { + n, err := nd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (nd *NodeDelete) sqlExec(ctx context.Context) error { +func (nd *NodeDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(node.Table)) for _, p := range nd.predicates { p(selector) } query, args := sql.Delete(node.Table).FromSelect(selector).Query() - return nd.driver.Exec(ctx, query, args, &res) + if err := nd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // NodeDeleteOne is the builder for deleting a single Node entity. @@ -56,7 +65,15 @@ type NodeDeleteOne struct { // Exec executes the deletion query. func (ndo *NodeDeleteOne) Exec(ctx context.Context) error { - return ndo.nd.Exec(ctx) + n, err := ndo.nd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{node.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/o2orecur/ent/node_query.go b/examples/o2orecur/ent/node_query.go index 0b36d9d50..3e2bb933a 100644 --- a/examples/o2orecur/ent/node_query.go +++ b/examples/o2orecur/ent/node_query.go @@ -80,20 +80,6 @@ func (nq *NodeQuery) QueryNext() *NodeQuery { return query } -// Get returns a Node entity by its id. -func (nq *NodeQuery) Get(ctx context.Context, id int) (*Node, error) { - return nq.Where(node.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (nq *NodeQuery) GetX(ctx context.Context, id int) *Node { - n, err := nq.Get(ctx, id) - if err != nil { - panic(err) - } - return n -} - // First returns the first Node entity in the query. Returns *ErrNotFound when no node was found. func (nq *NodeQuery) First(ctx context.Context) (*Node, error) { ns, err := nq.Limit(1).All(ctx) diff --git a/examples/o2orecur/ent/node_update.go b/examples/o2orecur/ent/node_update.go index bde3c3b69..2d32217d5 100644 --- a/examples/o2orecur/ent/node_update.go +++ b/examples/o2orecur/ent/node_update.go @@ -21,6 +21,7 @@ import ( type NodeUpdate struct { config value *int + addvalue *int prev map[int]struct{} next map[int]struct{} clearedPrev bool @@ -40,6 +41,12 @@ func (nu *NodeUpdate) SetValue(i int) *NodeUpdate { return nu } +// AddValue adds i to value. +func (nu *NodeUpdate) AddValue(i int) *NodeUpdate { + nu.addvalue = &i + return nu +} + // SetPrevID sets the prev edge to Node by id. func (nu *NodeUpdate) SetPrevID(id int) *NodeUpdate { if nu.prev == nil { @@ -161,9 +168,13 @@ func (nu *NodeUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(node.Table).Where(sql.InInts(node.FieldID, ids...)) ) - if nu.value != nil { + if value := nu.value; value != nil { update = true - builder.Set(node.FieldValue, *nu.value) + builder.Set(node.FieldValue, *value) + } + if value := nu.addvalue; value != nil { + update = true + builder.Add(node.FieldValue, *value) } if update { query, args := builder.Query() @@ -238,6 +249,7 @@ type NodeUpdateOne struct { config id int value *int + addvalue *int prev map[int]struct{} next map[int]struct{} clearedPrev bool @@ -250,6 +262,12 @@ func (nuo *NodeUpdateOne) SetValue(i int) *NodeUpdateOne { return nuo } +// AddValue adds i to value. +func (nuo *NodeUpdateOne) AddValue(i int) *NodeUpdateOne { + nuo.addvalue = &i + return nuo +} + // SetPrevID sets the prev edge to Node by id. func (nuo *NodeUpdateOne) SetPrevID(id int) *NodeUpdateOne { if nuo.prev == nil { @@ -374,10 +392,15 @@ func (nuo *NodeUpdateOne) sqlSave(ctx context.Context) (n *Node, err error) { res sql.Result builder = sql.Update(node.Table).Where(sql.InInts(node.FieldID, ids...)) ) - if nuo.value != nil { + if value := nuo.value; value != nil { update = true - builder.Set(node.FieldValue, *nuo.value) - n.Value = *nuo.value + builder.Set(node.FieldValue, *value) + n.Value = *value + } + if value := nuo.addvalue; value != nil { + update = true + builder.Add(node.FieldValue, *value) + n.Value += *value } if update { query, args := builder.Query() diff --git a/examples/traversal/ent/client.go b/examples/traversal/ent/client.go index 0014a8fdc..307d85a44 100644 --- a/examples/traversal/ent/client.go +++ b/examples/traversal/ent/client.go @@ -136,6 +136,20 @@ func (c *GroupClient) Query() *GroupQuery { return &GroupQuery{config: c.config} } +// Get returns a Group entity by its id. +func (c *GroupClient) Get(ctx context.Context, id int) (*Group, error) { + return c.Query().Where(group.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *GroupClient) GetX(ctx context.Context, id int) *Group { + gr, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return gr +} + // QueryUsers queries the users edge of a Group. func (c *GroupClient) QueryUsers(gr *Group) *UserQuery { query := &UserQuery{config: c.config} @@ -219,6 +233,20 @@ func (c *PetClient) Query() *PetQuery { return &PetQuery{config: c.config} } +// Get returns a Pet entity by its id. +func (c *PetClient) Get(ctx context.Context, id int) (*Pet, error) { + return c.Query().Where(pet.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *PetClient) GetX(ctx context.Context, id int) *Pet { + pe, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return pe +} + // QueryFriends queries the friends edge of a Pet. func (c *PetClient) QueryFriends(pe *Pet) *PetQuery { query := &PetQuery{config: c.config} @@ -302,6 +330,20 @@ func (c *UserClient) Query() *UserQuery { return &UserQuery{config: c.config} } +// Get returns a User entity by its id. +func (c *UserClient) Get(ctx context.Context, id int) (*User, error) { + return c.Query().Where(user.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *UserClient) GetX(ctx context.Context, id int) *User { + u, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return u +} + // QueryPets queries the pets edge of a User. func (c *UserClient) QueryPets(u *User) *PetQuery { query := &PetQuery{config: c.config} diff --git a/examples/traversal/ent/group_delete.go b/examples/traversal/ent/group_delete.go index 4cd9c402a..62280dc2a 100644 --- a/examples/traversal/ent/group_delete.go +++ b/examples/traversal/ent/group_delete.go @@ -21,32 +21,41 @@ type GroupDelete struct { predicates []predicate.Group } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (gd *GroupDelete) Where(ps ...predicate.Group) *GroupDelete { gd.predicates = append(gd.predicates, ps...) return gd } -// Exec executes the deletion query. -func (gd *GroupDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (gd *GroupDelete) Exec(ctx context.Context) (int, error) { return gd.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (gd *GroupDelete) ExecX(ctx context.Context) { - if err := gd.Exec(ctx); err != nil { +func (gd *GroupDelete) ExecX(ctx context.Context) int { + n, err := gd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (gd *GroupDelete) sqlExec(ctx context.Context) error { +func (gd *GroupDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(group.Table)) for _, p := range gd.predicates { p(selector) } query, args := sql.Delete(group.Table).FromSelect(selector).Query() - return gd.driver.Exec(ctx, query, args, &res) + if err := gd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // GroupDeleteOne is the builder for deleting a single Group entity. @@ -56,7 +65,15 @@ type GroupDeleteOne struct { // Exec executes the deletion query. func (gdo *GroupDeleteOne) Exec(ctx context.Context) error { - return gdo.gd.Exec(ctx) + n, err := gdo.gd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{group.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/traversal/ent/group_query.go b/examples/traversal/ent/group_query.go index 2928ad258..ef419297d 100644 --- a/examples/traversal/ent/group_query.go +++ b/examples/traversal/ent/group_query.go @@ -86,20 +86,6 @@ func (gq *GroupQuery) QueryAdmin() *UserQuery { return query } -// Get returns a Group entity by its id. -func (gq *GroupQuery) Get(ctx context.Context, id int) (*Group, error) { - return gq.Where(group.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (gq *GroupQuery) GetX(ctx context.Context, id int) *Group { - gr, err := gq.Get(ctx, id) - if err != nil { - panic(err) - } - return gr -} - // First returns the first Group entity in the query. Returns *ErrNotFound when no group was found. func (gq *GroupQuery) First(ctx context.Context) (*Group, error) { grs, err := gq.Limit(1).All(ctx) diff --git a/examples/traversal/ent/group_update.go b/examples/traversal/ent/group_update.go index 293519ac7..a710ebeea 100644 --- a/examples/traversal/ent/group_update.go +++ b/examples/traversal/ent/group_update.go @@ -171,9 +171,9 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(group.Table).Where(sql.InInts(group.FieldID, ids...)) ) - if gu.name != nil { + if value := gu.name; value != nil { update = true - builder.Set(group.FieldName, *gu.name) + builder.Set(group.FieldName, *value) } if update { query, args := builder.Query() @@ -387,10 +387,10 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (gr *Group, err error) { res sql.Result builder = sql.Update(group.Table).Where(sql.InInts(group.FieldID, ids...)) ) - if guo.name != nil { + if value := guo.name; value != nil { update = true - builder.Set(group.FieldName, *guo.name) - gr.Name = *guo.name + builder.Set(group.FieldName, *value) + gr.Name = *value } if update { query, args := builder.Query() diff --git a/examples/traversal/ent/pet_delete.go b/examples/traversal/ent/pet_delete.go index fee20fddf..60809fb7c 100644 --- a/examples/traversal/ent/pet_delete.go +++ b/examples/traversal/ent/pet_delete.go @@ -21,32 +21,41 @@ type PetDelete struct { predicates []predicate.Pet } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (pd *PetDelete) Where(ps ...predicate.Pet) *PetDelete { pd.predicates = append(pd.predicates, ps...) return pd } -// Exec executes the deletion query. -func (pd *PetDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (pd *PetDelete) Exec(ctx context.Context) (int, error) { return pd.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (pd *PetDelete) ExecX(ctx context.Context) { - if err := pd.Exec(ctx); err != nil { +func (pd *PetDelete) ExecX(ctx context.Context) int { + n, err := pd.Exec(ctx) + if err != nil { panic(err) } + return n } -func (pd *PetDelete) sqlExec(ctx context.Context) error { +func (pd *PetDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(pet.Table)) for _, p := range pd.predicates { p(selector) } query, args := sql.Delete(pet.Table).FromSelect(selector).Query() - return pd.driver.Exec(ctx, query, args, &res) + if err := pd.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // PetDeleteOne is the builder for deleting a single Pet entity. @@ -56,7 +65,15 @@ type PetDeleteOne struct { // Exec executes the deletion query. func (pdo *PetDeleteOne) Exec(ctx context.Context) error { - return pdo.pd.Exec(ctx) + n, err := pdo.pd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{pet.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/traversal/ent/pet_query.go b/examples/traversal/ent/pet_query.go index 0f83f59ad..0be26548e 100644 --- a/examples/traversal/ent/pet_query.go +++ b/examples/traversal/ent/pet_query.go @@ -86,20 +86,6 @@ func (pq *PetQuery) QueryOwner() *UserQuery { return query } -// Get returns a Pet entity by its id. -func (pq *PetQuery) Get(ctx context.Context, id int) (*Pet, error) { - return pq.Where(pet.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (pq *PetQuery) GetX(ctx context.Context, id int) *Pet { - pe, err := pq.Get(ctx, id) - if err != nil { - panic(err) - } - return pe -} - // First returns the first Pet entity in the query. Returns *ErrNotFound when no pet was found. func (pq *PetQuery) First(ctx context.Context) (*Pet, error) { pes, err := pq.Limit(1).All(ctx) diff --git a/examples/traversal/ent/pet_update.go b/examples/traversal/ent/pet_update.go index 9ebaeba69..ca46910dc 100644 --- a/examples/traversal/ent/pet_update.go +++ b/examples/traversal/ent/pet_update.go @@ -171,9 +171,9 @@ func (pu *PetUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(pet.Table).Where(sql.InInts(pet.FieldID, ids...)) ) - if pu.name != nil { + if value := pu.name; value != nil { update = true - builder.Set(pet.FieldName, *pu.name) + builder.Set(pet.FieldName, *value) } if update { query, args := builder.Query() @@ -394,10 +394,10 @@ func (puo *PetUpdateOne) sqlSave(ctx context.Context) (pe *Pet, err error) { res sql.Result builder = sql.Update(pet.Table).Where(sql.InInts(pet.FieldID, ids...)) ) - if puo.name != nil { + if value := puo.name; value != nil { update = true - builder.Set(pet.FieldName, *puo.name) - pe.Name = *puo.name + builder.Set(pet.FieldName, *value) + pe.Name = *value } if update { query, args := builder.Query() diff --git a/examples/traversal/ent/user_delete.go b/examples/traversal/ent/user_delete.go index 0c1b963ec..5a1775382 100644 --- a/examples/traversal/ent/user_delete.go +++ b/examples/traversal/ent/user_delete.go @@ -21,32 +21,41 @@ type UserDelete struct { predicates []predicate.User } -// Where adds a new predicate for the builder. +// Where adds a new predicate to the delete builder. func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { ud.predicates = append(ud.predicates, ps...) return ud } -// Exec executes the deletion query. -func (ud *UserDelete) Exec(ctx context.Context) error { +// Exec executes the deletion query and returns how many vertices were deleted. +func (ud *UserDelete) Exec(ctx context.Context) (int, error) { return ud.sqlExec(ctx) } // ExecX is like Exec, but panics if an error occurs. -func (ud *UserDelete) ExecX(ctx context.Context) { - if err := ud.Exec(ctx); err != nil { +func (ud *UserDelete) ExecX(ctx context.Context) int { + n, err := ud.Exec(ctx) + if err != nil { panic(err) } + return n } -func (ud *UserDelete) sqlExec(ctx context.Context) error { +func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) { var res sql.Result selector := sql.Select().From(sql.Table(user.Table)) for _, p := range ud.predicates { p(selector) } query, args := sql.Delete(user.Table).FromSelect(selector).Query() - return ud.driver.Exec(ctx, query, args, &res) + if err := ud.driver.Exec(ctx, query, args, &res); err != nil { + return 0, err + } + affected, err := res.RowsAffected() + if err != nil { + return 0, err + } + return int(affected), nil } // UserDeleteOne is the builder for deleting a single User entity. @@ -56,7 +65,15 @@ type UserDeleteOne struct { // Exec executes the deletion query. func (udo *UserDeleteOne) Exec(ctx context.Context) error { - return udo.ud.Exec(ctx) + n, err := udo.ud.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &ErrNotFound{user.Label} + default: + return nil + } } // ExecX is like Exec, but panics if an error occurs. diff --git a/examples/traversal/ent/user_query.go b/examples/traversal/ent/user_query.go index 362b3da45..98213f60a 100644 --- a/examples/traversal/ent/user_query.go +++ b/examples/traversal/ent/user_query.go @@ -118,20 +118,6 @@ func (uq *UserQuery) QueryManage() *GroupQuery { return query } -// Get returns a User entity by its id. -func (uq *UserQuery) Get(ctx context.Context, id int) (*User, error) { - return uq.Where(user.ID(id)).Only(ctx) -} - -// GetX is like Get, but panics if an error occurs. -func (uq *UserQuery) GetX(ctx context.Context, id int) *User { - u, err := uq.Get(ctx, id) - if err != nil { - panic(err) - } - return u -} - // First returns the first User entity in the query. Returns *ErrNotFound when no user was found. func (uq *UserQuery) First(ctx context.Context) (*User, error) { us, err := uq.Limit(1).All(ctx) diff --git a/examples/traversal/ent/user_update.go b/examples/traversal/ent/user_update.go index d1db7d3b9..13ccdf13f 100644 --- a/examples/traversal/ent/user_update.go +++ b/examples/traversal/ent/user_update.go @@ -22,6 +22,7 @@ import ( type UserUpdate struct { config age *int + addage *int name *string pets map[int]struct{} friends map[int]struct{} @@ -46,6 +47,12 @@ func (uu *UserUpdate) SetAge(i int) *UserUpdate { return uu } +// AddAge adds i to age. +func (uu *UserUpdate) AddAge(i int) *UserUpdate { + uu.addage = &i + return uu +} + // SetName sets the name field. func (uu *UserUpdate) SetName(s string) *UserUpdate { uu.name = &s @@ -271,13 +278,17 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uu.age != nil { + if value := uu.age; value != nil { update = true - builder.Set(user.FieldAge, *uu.age) + builder.Set(user.FieldAge, *value) } - if uu.name != nil { + if value := uu.addage; value != nil { update = true - builder.Set(user.FieldName, *uu.name) + builder.Add(user.FieldAge, *value) + } + if value := uu.name; value != nil { + update = true + builder.Set(user.FieldName, *value) } if update { query, args := builder.Query() @@ -435,6 +446,7 @@ type UserUpdateOne struct { config id int age *int + addage *int name *string pets map[int]struct{} friends map[int]struct{} @@ -452,6 +464,12 @@ func (uuo *UserUpdateOne) SetAge(i int) *UserUpdateOne { return uuo } +// AddAge adds i to age. +func (uuo *UserUpdateOne) AddAge(i int) *UserUpdateOne { + uuo.addage = &i + return uuo +} + // SetName sets the name field. func (uuo *UserUpdateOne) SetName(s string) *UserUpdateOne { uuo.name = &s @@ -680,15 +698,20 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (u *User, err error) { res sql.Result builder = sql.Update(user.Table).Where(sql.InInts(user.FieldID, ids...)) ) - if uuo.age != nil { + if value := uuo.age; value != nil { update = true - builder.Set(user.FieldAge, *uuo.age) - u.Age = *uuo.age + builder.Set(user.FieldAge, *value) + u.Age = *value } - if uuo.name != nil { + if value := uuo.addage; value != nil { update = true - builder.Set(user.FieldName, *uuo.name) - u.Name = *uuo.name + builder.Add(user.FieldAge, *value) + u.Age += *value + } + if value := uuo.name; value != nil { + update = true + builder.Set(user.FieldName, *value) + u.Name = *value } if update { query, args := builder.Query()