From ed3747ff82345cd272cb15fe7794bc4712095430 Mon Sep 17 00:00:00 2001 From: Ariel Mashraki Date: Wed, 27 Nov 2019 06:11:04 -0800 Subject: [PATCH] entc/gen: change neighbors query to use Step builder Summary: Pull Request resolved: https://github.com/facebookincubator/ent/pull/202 Reviewed By: alexsn Differential Revision: D18725770 fbshipit-source-id: d7720ac89f55022a7721edc7df15fab1d6e3672c --- entc/gen/internal/bindata.go | 4 +- entc/gen/template/dialect/sql/query.tmpl | 23 +-- entc/integration/customid/ent/group_query.go | 15 +- entc/integration/customid/ent/user_query.go | 15 +- entc/integration/ent/card_query.go | 15 +- entc/integration/ent/file_query.go | 30 ++-- entc/integration/ent/filetype_query.go | 15 +- entc/integration/ent/group_query.go | 60 +++---- entc/integration/ent/groupinfo_query.go | 15 +- entc/integration/ent/node_query.go | 30 ++-- entc/integration/ent/pet_query.go | 30 ++-- entc/integration/ent/user_query.go | 165 +++++++------------ entc/integration/idtype/ent/user_query.go | 45 ++--- entc/integration/template/ent/pet_query.go | 15 +- entc/integration/template/ent/user_query.go | 30 ++-- 15 files changed, 174 insertions(+), 333 deletions(-) diff --git a/entc/gen/internal/bindata.go b/entc/gen/internal/bindata.go index 3e00c7e48..34df0a604 100644 --- a/entc/gen/internal/bindata.go +++ b/entc/gen/internal/bindata.go @@ -761,7 +761,7 @@ func templateDialectSqlPredicateTmpl() (*asset, error) { return a, nil } -var _templateDialectSqlQueryTmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xc4\x57\x51\x6f\xdb\x36\x10\x7e\x8e\x7e\xc5\x35\xe8\x0a\x29\x50\xe5\x24\x7b\x5a\x82\x0c\xe8\xd2\x14\x30\xd6\x66\x5d\x12\x6c\x0f\x45\x31\x30\xd2\xc9\x26\x42\x93\x0e\x49\x39\x09\x0c\xfd\xf7\xe1\x8e\x92\x2c\xc7\x72\x92\x76\xc3\xf6\x50\xd4\xe2\x7d\x77\xf7\xf1\x78\x1f\x79\x59\x2e\x47\x7b\xd1\xa9\x99\x3f\x58\x39\x99\x7a\x38\xdc\x3f\xf8\xe9\xed\xdc\xa2\x43\xed\xe1\x83\xc8\xf1\xda\x98\x1b\x18\xeb\x3c\x83\x77\x4a\x01\x83\x1c\x90\xdd\x2e\xb0\xc8\xa2\xab\xa9\x74\xe0\x4c\x65\x73\x84\xdc\x14\x08\xd2\x81\x92\x39\x6a\x87\x05\x54\xba\x40\x0b\x7e\x8a\xf0\x6e\x2e\xf2\x29\xc2\x61\xb6\xdf\x5a\xa1\x34\x95\x2e\x22\xa9\xd9\xfe\x71\x7c\x7a\x76\x7e\x79\x06\xa5\x54\x08\xcd\x9a\x35\xc6\x43\x21\x2d\xe6\xde\xd8\x07\x30\x25\xf8\x5e\x32\x6f\x11\xb3\x68\x6f\x54\xd7\x51\xb4\x5c\x42\x81\xa5\xd4\x08\xbb\x85\x14\x0a\x73\x3f\x72\xb7\x6a\x74\x5b\xa1\x7d\xd8\x85\xba\x26\xc0\xeb\xf9\xcd\x04\x8e\x4e\xe0\x75\x76\x99\x9b\x39\x66\x9f\x45\x7e\x23\x26\xd8\x5a\xaf\x2b\xa9\x88\xec\xd1\x09\xcc\x85\xcb\x85\xea\x80\xbf\x34\x96\x06\x68\x31\x47\xb9\x08\xc8\xee\x77\xe7\x4e\x6c\xca\x4a\xe7\x10\xaf\x61\xeb\x1a\xf6\xfa\x59\xea\x3a\x01\x77\xab\xde\x29\x15\xe7\xfe\x1e\x72\xa3\x3d\xde\xfb\xec\x34\xfc\x9f\x40\xfc\xe5\x2b\xe3\xb3\x73\x31\x23\x8a\x29\xa0\xb5\xc6\x26\xb0\x8c\x76\xac\xb9\x73\x94\xfc\x8d\xbb\x55\xd9\x85\xb9\x73\xcb\x3a\xda\x71\xa8\xb8\x4c\x64\x78\x94\x39\x73\xb7\xea\x77\xaa\x44\x9c\x44\x3b\xb2\x84\x4a\xcb\xdb\x0a\x87\x80\xc1\x72\x0c\x0a\x75\x1c\x7e\x27\x70\x72\x02\xfb\x94\xb5\xcb\x90\xbd\x97\xce\x4b\x9d\x7b\x0a\x57\x47\x3b\x5c\xe4\x14\x84\x9d\x30\xab\x0e\xd6\x4f\x89\x76\x90\x58\x61\xe9\x57\x83\xcc\xfd\x7d\x0a\xbd\x60\x29\xd0\x46\x93\x63\x76\x7e\x75\x02\x5a\x2a\xe6\x61\xd1\x57\x56\xd3\x27\x17\x85\x39\x14\x58\xa2\x65\x7c\x76\xaa\x8c\x43\x4a\xbb\x5c\xbe\xa5\x6c\x9e\x4f\x54\x55\x96\x4f\xf4\x62\x95\x3d\xda\x59\x08\xdb\x50\xf2\x74\x40\xcb\xe5\x0a\xc7\x65\x67\xd0\x63\xf6\x04\xcd\x3e\x58\x33\xa3\xca\xc7\x2f\xa7\xd8\xf3\xce\x8d\x2e\xe5\xe4\x71\x83\x34\xcb\x49\xd4\xba\xaf\x3c\x52\x0a\x15\x7d\x53\x67\x9d\x9a\x4a\xfb\x2d\xbd\x25\xb5\xff\xd7\xfa\x69\xd5\x4c\x5f\xbe\x3a\x6f\xa5\x9e\x2c\x19\xdf\x93\x57\xc6\xdf\xe3\xf7\xc4\xc0\x79\xa1\xb9\xd8\xa1\xb2\xd4\x68\xc3\x4d\x98\xc0\xcf\x4d\xdf\x35\x19\xb6\x75\x2b\x17\xb7\x6b\xba\xb0\x6d\xda\x48\xd7\xa5\x3d\x9b\xaa\x66\xda\x35\x9d\x9d\x65\x59\x42\xff\x92\xff\xad\x83\xf7\x9f\xee\x5f\x59\xc2\x2b\x5e\x39\xc7\x7b\x1f\x27\x9b\x9e\xc6\x92\xed\x2e\xde\x6d\x2f\xb7\xba\x3e\x02\x6d\x38\x4c\xb8\x5c\x77\x83\x42\xa9\xcf\x35\x48\xed\xfb\x3b\xe1\xd0\x97\xb9\xd0\xf1\x1b\xfd\x14\xc5\x72\xe6\xb3\x33\x4a\x56\xae\x27\x2a\x85\x54\x58\x80\x45\x51\x48\x3d\x81\x9c\x0a\x7f\x04\x3f\x2c\x76\x99\x5b\x48\xdc\xea\xe0\x3b\xfa\xf7\xec\x5e\xba\x6d\xfd\x7b\x6d\x8c\xea\x37\xb0\x4e\xb7\x1d\x4f\x5f\x08\xab\x73\xdc\xdc\x67\x29\x94\xc3\xed\x7b\xcd\xa7\x98\xdf\x00\x12\x25\xd4\x39\x6e\xdb\x26\xb5\xec\x77\x6c\xb5\x69\x33\xd8\xa3\xb6\xbd\x6c\x75\xb7\x8c\x76\x7a\x4f\x52\xe8\x68\x7e\xd9\x36\x04\xd3\xf4\x60\x6b\xa6\x8e\xf6\x07\xe4\xd4\xf8\x67\x57\xe2\x5a\x61\xfc\x58\x95\xbc\x9a\xac\x2b\xbd\xf5\x08\x2c\x62\x7f\xd0\x89\xe6\xb1\x77\xb3\xde\xaa\x88\x6f\xc4\xd8\x1f\x84\x22\x0f\x1c\x43\xbf\xe8\x5d\xc6\xc1\x03\xeb\x3f\x35\x0d\x8f\x0d\x09\x3f\xc3\x86\x4f\xa5\x34\x16\xfe\x4a\x61\xce\xcd\x2e\xf4\x04\x37\x92\xcd\x2d\x16\x32\x17\x1e\x1d\xd3\x9a\x77\x79\x5e\x1a\xc0\x58\x3a\x9e\x21\x5f\x59\x82\x29\x4b\x17\x5e\x9f\x0d\x37\xb6\x1c\xb7\x88\x5e\x65\x46\x23\x50\x72\x26\x3d\x0d\x51\x33\xa1\x0b\xc1\x83\x0f\x11\x69\xb0\xb9\x12\x95\xc3\x0c\xfe\x44\x70\x5e\x58\x1f\x7c\xee\xa4\x9f\xd2\x00\x24\x2a\xe5\x61\x21\x54\x85\x29\x08\x5d\x80\x59\xa0\xb5\x92\x66\x32\x0f\xd7\xa8\xcc\x1d\xc8\x12\x34\x62\x41\x83\x5b\xaf\xcc\xbf\x71\xf0\x78\x2f\x24\x49\xb2\x8f\xc4\x21\x9e\x09\x3f\xcd\x3e\x89\xfb\xb1\xf6\x3f\x1e\x76\xdb\x0a\xfc\x06\x76\xc5\x86\xe3\xc6\x3e\x70\xda\x4d\xd4\x3d\x06\xac\x09\xa7\x45\x44\x3c\x60\xa1\x2e\x20\xcc\x74\xa3\xbd\x70\x9b\x8e\xe6\x22\xec\x4f\x6a\x74\x3c\x19\xf2\x32\x4c\x50\xa3\x15\x5e\x1a\xcd\x25\x62\x94\x29\x41\xc0\x44\x2e\x50\x03\x16\x13\xcc\x80\x07\xc4\xa7\xe6\x43\x8e\xce\x43\x62\x18\x19\x34\x0f\x89\xab\x6f\xec\x0f\x8d\x67\x05\x37\x1c\x30\x39\x62\x42\x49\xe0\x0e\xb9\xaa\xe0\x0d\x73\x9a\x58\xe1\x91\xad\x4c\xc9\x9b\x86\x45\x3b\x92\xac\xe6\xc7\x36\xec\xda\x58\xe2\x3c\xce\xbb\xf7\xf8\xd2\xe3\x7c\xd9\x2c\xb2\xc8\xb2\x3f\x86\x65\xd3\x3d\x56\x2b\x24\x2b\xbc\x41\xeb\x0d\xe9\xf7\x91\x41\x3f\x43\xd0\xb0\xb0\xfe\x78\x37\x9e\x57\x66\x2d\x03\x66\x57\x0f\x6b\x63\xf5\x5a\x9a\x2b\xb3\x9e\x64\x13\xdd\x5b\x1d\x4c\x47\xa5\xcf\x2e\x50\x41\xb8\x0d\x03\xfc\x02\x15\xbb\x3c\x82\x8d\xf5\x02\xad\x5b\x31\x1b\xbb\x76\x65\x1d\xb7\xb5\x42\x0d\x19\x32\x6f\x61\xd2\x5c\x39\x70\x02\x62\x3e\x47\x5d\xc4\x1b\xa6\x94\xc2\xca\x92\x02\x7d\x3a\xfc\x04\x75\xbd\x25\xcb\xe7\x5f\x7b\x29\xb2\x8c\x56\x51\x31\xd5\x2d\x0e\x21\x7e\xcf\xa9\x53\x4d\x3b\xcc\xf0\x8d\x1b\xea\x74\x89\xfe\x1c\xe5\x64\x7a\x6d\xac\x7b\xf6\xe9\x48\x81\x76\x91\x6c\x91\x61\x69\xcd\xec\x79\x19\x8a\xa0\xbc\xc6\xc8\x3e\xad\x22\xb5\x29\x5e\xa4\x48\x72\x1a\x52\xe4\x4a\x76\x14\x89\x64\xc7\x97\x60\x8f\x0b\x79\xae\xa9\xed\x3f\x55\xef\x5b\xfe\x83\xa1\x18\xba\x1d\xc9\x99\x7a\x81\xb5\x34\x76\x97\x3c\x2a\x43\x5d\xcb\x22\x4e\x56\x07\x3e\x7e\xbf\xaa\x7c\x77\x0f\xd0\x29\x9e\xe3\x1d\xdd\x04\x31\xdd\xa7\xb7\x2a\xbc\xb6\xc3\xb2\x4e\x5f\xa6\xe1\x14\x64\x91\xa4\x4d\xb8\x2b\x13\x3f\xa1\xe0\xf4\x5b\x05\xdb\xc5\xa5\x7a\xc7\x83\x62\x4d\x07\x84\xb9\x85\xf9\xa6\x0c\x29\xfc\x4e\x5b\xd0\x20\x2e\xae\x3c\xaf\xbe\x48\x62\x6d\x00\x2e\xfb\x33\xbe\x1b\x6a\xeb\x9c\x75\xd1\xf8\xd2\x86\x07\xa4\xf7\x4f\x74\xf7\x77\x00\x00\x00\xff\xff\xb7\xdf\x58\xd2\x96\x11\x00\x00") +var _templateDialectSqlQueryTmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x56\xdf\x6f\xdb\xb6\x13\x7f\xb6\xfe\x8a\x6b\xd0\x6f\x21\x19\x2e\x9d\xe4\xfb\xb4\x04\x19\xd0\xa5\x29\x60\xac\xcd\xba\x26\xc0\x1e\x8a\x62\x60\xa4\x93\x4d\x84\x26\x1d\x92\x72\x12\x18\xfa\xdf\x87\x3b\x4a\xb2\x1c\x3b\x49\xd7\xad\x18\x06\xec\x21\x88\xcc\xfb\xf5\xb9\xbb\xcf\x91\xb7\x5a\x8d\x87\xc9\xa9\x5d\xdc\x3b\x35\x9d\x05\x38\xdc\x3f\xf8\xe1\xf5\xc2\xa1\x47\x13\xe0\x9d\xcc\xf1\xca\xda\x6b\x98\x98\x5c\xc0\x1b\xad\x81\x95\x3c\x90\xdc\x2d\xb1\x10\xc9\xe5\x4c\x79\xf0\xb6\x72\x39\x42\x6e\x0b\x04\xe5\x41\xab\x1c\x8d\xc7\x02\x2a\x53\xa0\x83\x30\x43\x78\xb3\x90\xf9\x0c\xe1\x50\xec\xb7\x52\x28\x6d\x65\x8a\x44\x19\x96\xbf\x9f\x9c\x9e\x9d\x5f\x9c\x41\xa9\x34\x42\x73\xe6\xac\x0d\x50\x28\x87\x79\xb0\xee\x1e\x6c\x09\xa1\x17\x2c\x38\x44\x91\x0c\xc7\x75\x9d\x24\xab\x15\x14\x58\x2a\x83\xb0\x57\x28\xa9\x31\x0f\x63\x7f\xa3\xc7\x37\x15\xba\xfb\x3d\xa8\x6b\x52\x78\xb9\xb8\x9e\xc2\xd1\x09\xbc\x14\x17\xb9\x5d\xa0\xf8\x28\xf3\x6b\x39\xc5\x56\x7a\x55\x29\x4d\x60\x8f\x4e\x60\x21\x7d\x2e\x75\xa7\xf8\x53\x23\x69\x14\x1d\xe6\xa8\x96\x51\xb3\xfb\xee\xcc\x09\x4d\x59\x99\x1c\xd2\x0d\xdd\xba\x86\x61\x3f\x4a\x5d\x67\xe0\x6f\xf4\x1b\xad\xd3\x3c\xdc\x41\x6e\x4d\xc0\xbb\x20\x4e\xe3\xff\x0c\xd2\xcf\x5f\x58\x5f\x9c\xcb\x39\x41\x1c\x01\x3a\x67\x5d\x06\xab\x64\xe0\xec\xad\xa7\xe0\xaf\xfc\x8d\x16\x9f\xec\xad\x5f\xd5\xc9\xc0\xa3\xe6\x32\x91\xe0\x41\x64\xe1\x6f\xf4\xaf\x54\x89\x34\x4b\x06\xaa\x84\xca\xa8\x9b\x0a\x77\x29\x46\xc9\x31\x68\x34\x69\xfc\xce\xe0\xe4\x04\xf6\x29\x6a\x17\x41\xbc\x55\x3e\x28\x93\x07\x72\x57\x27\x03\x2e\xf2\x08\xa4\x9b\x32\xaa\x4e\xad\x1f\x12\xdd\x4e\x60\x85\xa3\xaf\x46\x33\x0f\x77\x23\xe8\x39\x1b\x01\x25\x9a\x1d\xb3\xf1\x8b\x13\x30\x4a\x33\x0e\x87\xa1\x72\x86\x7e\x72\x51\x18\x43\x81\x25\x3a\xd6\x17\xa7\xda\x7a\xa4\xb0\xab\xd5\x6b\x8a\x16\xb8\xa3\xba\x72\xdc\xd1\x4f\xeb\xe8\xc9\x60\x29\x5d\x03\x29\x50\x83\x56\xab\xb5\x1e\x97\x9d\x95\x1e\xa2\x27\x55\xf1\xce\xd9\x39\x55\x3e\xfd\x7a\x88\x3d\xeb\xdc\x9a\x52\x4d\x1f\x12\xa4\x39\xce\x92\xd6\x7c\x6d\x31\x22\x57\xc9\x9f\x62\xd6\xa9\xad\x4c\x78\x84\x5b\xca\x84\xbf\x8d\x4f\x6b\x32\x7d\xfe\xe2\x83\x53\x66\xba\x62\xfd\xde\x78\x09\xfe\x3d\x79\x4b\x08\x7c\x90\x86\x8b\x1d\x2b\x4b\x44\xdb\x4d\xc2\x0c\x7e\x6c\x78\xd7\x44\x78\x8c\xad\x5c\xdc\x8e\x74\x31\x6d\x4a\xa4\x63\x69\x4f\xa6\xab\xb9\xf1\x0d\xb3\x85\x10\x19\xfd\x65\xff\x18\x83\xf7\x9f\xe6\xaf\x2a\xe1\x05\x9f\x9c\xe3\x5d\x48\xb3\x6d\x4b\xeb\x48\x76\x9b\xee\xb5\x97\x5b\x5d\x1f\x81\xb1\xec\x26\x5e\xae\x7b\x71\x42\x89\xe7\x06\x94\x09\xfd\x4c\xd8\xf5\x45\x2e\x4d\xfa\xca\x3c\x05\xb1\x9c\x07\x71\x46\xc1\xca\xcd\x40\xa5\x54\x1a\x0b\x70\x28\x0b\x65\xa6\x90\x53\xe1\x8f\xe0\x7f\xcb\x3d\xc6\x16\x03\xb7\x73\xf0\x0d\xfc\x3d\xbb\x53\xfe\x31\xfe\x5e\x59\xab\xfb\x04\x36\xa3\xc7\xda\xd3\x1f\x84\x75\x1f\xb7\xf3\x2c\xa5\xf6\xf8\x78\xae\xf9\x0c\xf3\x6b\x40\x82\x84\x26\xc7\xc7\xd2\x24\xca\x7e\x43\xaa\x0d\xcd\x60\x48\xb4\xbd\x68\xe7\x6e\x95\x0c\x7a\x4f\x52\x64\x34\xbf\x6c\x5b\x03\xd3\x70\xb0\x15\x13\xa3\xc3\x01\x19\x35\xf6\xe2\x52\x5e\x69\x4c\x1f\x4e\x25\x9f\x66\x9b\x93\xde\x5a\x44\x14\x69\x38\xe8\x86\xe6\xa1\x75\x73\xde\x4e\x11\xdf\x88\x69\x38\x88\x45\xde\xd1\x86\x7e\xd1\xbb\x88\x3b\x1b\xd6\x7f\x6a\x1a\x1c\x5b\x23\xfc\x0c\x1a\xee\x4a\x69\x1d\xfc\x3e\x82\x05\x93\x5d\x9a\x29\x6e\x05\x5b\x38\x2c\x54\x2e\x03\x7a\x86\xb5\xe8\xe2\x7c\xad\x03\xeb\xa8\x3d\xbb\x6c\x55\x09\xb6\x2c\x7d\x7c\x7d\xb6\xcc\x58\x72\xdc\x6a\xf4\x2a\x33\x1e\x83\x56\x73\x15\x68\x89\x9a\x4b\x53\x48\x5e\x7c\x08\x48\xa3\x9b\x6b\x59\x79\x14\xf0\x1b\x82\x0f\xd2\x85\x68\x73\xab\xc2\x8c\x16\x20\x59\xe9\x00\x4b\xa9\x2b\x1c\x81\x34\x05\xd8\x25\x3a\xa7\x68\x27\x0b\x70\x85\xda\xde\x82\x2a\xc1\x20\x16\xb4\xb8\xf5\xca\xfc\x0b\x3b\x4f\x87\x31\x48\x26\xde\x13\x86\x74\x2e\xc3\x4c\x7c\x90\x77\x13\x13\xfe\x7f\xd8\xa5\x15\xf1\xed\xc8\x8a\x05\xc7\x8d\x7c\x47\xb7\x1b\xaf\x43\x56\xd8\x18\x9c\x56\x23\xe1\x05\x0b\x4d\x01\x71\xa7\x1b\x0f\xe3\x6d\x3a\x5e\xc8\x98\x9f\x32\xe8\x79\x33\xe4\x63\x98\xa2\x41\x27\x83\xb2\x86\x4b\xc4\x5a\xb6\x04\x09\x53\xb5\x44\x03\x58\x4c\x51\x00\x2f\x88\x4f\xed\x87\xec\x9d\x97\xc4\xb8\x32\x18\x5e\x12\xe3\x42\x30\x1e\x72\x38\x43\x7b\xed\x6d\x53\xf2\x1e\x80\xd2\xd9\x79\x13\x21\xda\x62\x7f\xc1\x3c\x2b\x98\x9c\x6b\x37\x04\x88\xdc\x50\x07\x20\x58\xc6\x3f\x75\x32\x20\x4b\x19\x7e\xb0\x1b\xfe\xfa\xbb\x66\xeb\x76\x63\x85\xf1\x01\x17\xed\xfd\x70\x8e\xb7\x17\x01\x17\x29\xd5\xfc\x46\xc7\x89\xa4\x26\x99\xad\xa9\x1f\xc1\xd6\x79\x3c\xd8\x7c\xa4\x47\x4f\xbc\xfc\xd9\xa8\x09\x73\x69\x39\x08\x8a\xcb\xfb\x8d\xa5\xba\x1f\x69\x5b\xd8\x3b\xdd\x8c\xd9\xf9\xa5\xea\xf1\x43\x1e\x55\x3f\xa1\x66\xf5\x0e\x16\x8a\x89\x9f\x98\x25\x3a\xbf\x3e\xdb\xca\x08\x23\x8a\x7e\x4e\xc9\x60\xc0\xb5\x55\x25\x89\x3f\x1c\x7e\x80\xd7\x54\x48\x3e\xdd\xe9\xe1\xe3\xcf\x3d\x73\x21\x44\xeb\x00\xb5\xc7\xe7\x6c\xe3\xbd\xd4\xb3\xef\x8c\x4d\xd1\xd8\x52\xc2\xed\x0e\xc2\x17\x65\x6c\xe6\x05\x86\x73\x54\xd3\xd9\x95\x75\xfe\xd9\x1b\x7f\x04\xc4\x83\xec\x91\xe9\x21\x96\x3e\x3f\x3d\x32\x0e\x4c\x8f\xd9\xdd\x20\x11\xfd\xbf\x66\x90\xc8\xe8\xdf\x38\x48\xdc\x08\x55\xec\xba\xd4\x5a\xa6\xf0\x68\x4c\xfc\x05\x6f\xb8\x50\xd7\xaa\x48\x33\xaa\xb6\x66\xf6\x4d\xde\xae\x2b\xff\xbd\x47\x52\x15\xff\x8d\xde\xf7\x1d\xbd\xbf\x32\x77\x7f\x04\x00\x00\xff\xff\xfd\xe0\xb6\x00\x4d\x11\x00\x00") func templateDialectSqlQueryTmplBytes() ([]byte, error) { return bindataRead( @@ -776,7 +776,7 @@ func templateDialectSqlQueryTmpl() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "template/dialect/sql/query.tmpl", size: 4502, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + info := bindataFileInfo{name: "template/dialect/sql/query.tmpl", size: 4429, mode: os.FileMode(420), modTime: time.Unix(1, 0)} a := &asset{bytes: bytes, info: info} return a, nil } diff --git a/entc/gen/template/dialect/sql/query.tmpl b/entc/gen/template/dialect/sql/query.tmpl index e9c743842..cdb134988 100644 --- a/entc/gen/template/dialect/sql/query.tmpl +++ b/entc/gen/template/dialect/sql/query.tmpl @@ -88,19 +88,20 @@ func ({{ $receiver }} *{{ $builder }}) sqlQuery() *sql.Selector { {{/* query/path defines the query generation for path of a given edge. */}} {{ define "dialect/sql/query/path" }} - {{- $n := $ }} + {{- $n := $ }} {{/* the node we start the query from. */}} {{- $e := $.Scope.Edge }} {{/* the edge we need to genegrate the path to. */}} {{- $receiver := $.Scope.Receiver }} - step := &sql.Step{} - step.From.V = {{ $receiver }}.sqlQuery() - step.From.Table = {{ $n.Package }}.Table - step.From.Column = {{ $n.Package }}.{{ $n.ID.Constant }} - step.To.Table = {{ $e.Type.Package }}.Table - step.To.Column = {{ $e.Type.Package }}.{{ $e.Type.ID.Constant }} - step.Edge.Rel = sql.{{ $e.Rel.Type }} - step.Edge.Inverse = {{ $e.IsInverse }} - step.Edge.Table = {{ $n.Package }}.{{ $e.TableConstant }} - step.Edge.Columns = append(step.Edge.Columns, {{ if $e.M2M }}{{ $n.Package }}.{{ $e.PKConstant }}...{{ else }}{{ $n.Package }}.{{ $e.ColumnConstant }}{{ end }}) + step := sql.NewStep( + sql.From({{ $n.Package }}.Table, {{ $n.Package }}.{{ $n.ID.Constant }}, {{ $receiver }}.sqlQuery()), + sql.To({{ $e.Type.Package }}.Table, {{ $e.Type.Package }}.{{ $e.Type.ID.Constant }}), + sql.Edge(sql.{{ $e.Rel.Type }}, {{ $e.IsInverse }}, {{ $n.Package }}.{{ $e.TableConstant }}, + {{- if $e.M2M -}} + {{ $n.Package }}.{{ $e.PKConstant }}... + {{- else -}} + {{ $n.Package }}.{{ $e.ColumnConstant }} + {{- end -}} + ), + ) query.sql = sql.SetNeighbors({{ $receiver }}.driver.Dialect(), step) {{ end }} diff --git a/entc/integration/customid/ent/group_query.go b/entc/integration/customid/ent/group_query.go index 57653dbd7..958388447 100644 --- a/entc/integration/customid/ent/group_query.go +++ b/entc/integration/customid/ent/group_query.go @@ -57,16 +57,11 @@ func (gq *GroupQuery) Order(o ...Order) *GroupQuery { // QueryUsers chains the current query on the users edge. func (gq *GroupQuery) QueryUsers() *UserQuery { query := &UserQuery{config: gq.config} - step := &sql.Step{} - step.From.V = gq.sqlQuery() - step.From.Table = group.Table - step.From.Column = group.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2M - step.Edge.Inverse = false - step.Edge.Table = group.UsersTable - step.Edge.Columns = append(step.Edge.Columns, group.UsersPrimaryKey...) + step := sql.NewStep( + sql.From(group.Table, group.FieldID, gq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2M, false, group.UsersTable, group.UsersPrimaryKey...), + ) query.sql = sql.SetNeighbors(gq.driver.Dialect(), step) return query } diff --git a/entc/integration/customid/ent/user_query.go b/entc/integration/customid/ent/user_query.go index 0904da3d7..da5092308 100644 --- a/entc/integration/customid/ent/user_query.go +++ b/entc/integration/customid/ent/user_query.go @@ -57,16 +57,11 @@ func (uq *UserQuery) Order(o ...Order) *UserQuery { // QueryGroups chains the current query on the groups edge. func (uq *UserQuery) QueryGroups() *GroupQuery { query := &GroupQuery{config: uq.config} - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = group.Table - step.To.Column = group.FieldID - step.Edge.Rel = sql.M2M - step.Edge.Inverse = true - step.Edge.Table = user.GroupsTable - step.Edge.Columns = append(step.Edge.Columns, user.GroupsPrimaryKey...) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(group.Table, group.FieldID), + sql.Edge(sql.M2M, true, user.GroupsTable, user.GroupsPrimaryKey...), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) return query } diff --git a/entc/integration/ent/card_query.go b/entc/integration/ent/card_query.go index 3ca934bcc..e31cd3bbc 100644 --- a/entc/integration/ent/card_query.go +++ b/entc/integration/ent/card_query.go @@ -65,16 +65,11 @@ func (cq *CardQuery) QueryOwner() *UserQuery { query := &UserQuery{config: cq.config} switch cq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = cq.sqlQuery() - step.From.Table = card.Table - step.From.Column = card.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = true - step.Edge.Table = card.OwnerTable - step.Edge.Columns = append(step.Edge.Columns, card.OwnerColumn) + step := sql.NewStep( + sql.From(card.Table, card.FieldID, cq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.O2O, true, card.OwnerTable, card.OwnerColumn), + ) query.sql = sql.SetNeighbors(cq.driver.Dialect(), step) case dialect.Gremlin: gremlin := cq.gremlinQuery() diff --git a/entc/integration/ent/file_query.go b/entc/integration/ent/file_query.go index 559120a3e..25f5a6c8e 100644 --- a/entc/integration/ent/file_query.go +++ b/entc/integration/ent/file_query.go @@ -66,16 +66,11 @@ func (fq *FileQuery) QueryOwner() *UserQuery { query := &UserQuery{config: fq.config} switch fq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = fq.sqlQuery() - step.From.Table = file.Table - step.From.Column = file.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2O - step.Edge.Inverse = true - step.Edge.Table = file.OwnerTable - step.Edge.Columns = append(step.Edge.Columns, file.OwnerColumn) + step := sql.NewStep( + sql.From(file.Table, file.FieldID, fq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2O, true, file.OwnerTable, file.OwnerColumn), + ) query.sql = sql.SetNeighbors(fq.driver.Dialect(), step) case dialect.Gremlin: gremlin := fq.gremlinQuery() @@ -89,16 +84,11 @@ func (fq *FileQuery) QueryType() *FileTypeQuery { query := &FileTypeQuery{config: fq.config} switch fq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = fq.sqlQuery() - step.From.Table = file.Table - step.From.Column = file.FieldID - step.To.Table = filetype.Table - step.To.Column = filetype.FieldID - step.Edge.Rel = sql.M2O - step.Edge.Inverse = true - step.Edge.Table = file.TypeTable - step.Edge.Columns = append(step.Edge.Columns, file.TypeColumn) + step := sql.NewStep( + sql.From(file.Table, file.FieldID, fq.sqlQuery()), + sql.To(filetype.Table, filetype.FieldID), + sql.Edge(sql.M2O, true, file.TypeTable, file.TypeColumn), + ) query.sql = sql.SetNeighbors(fq.driver.Dialect(), step) case dialect.Gremlin: gremlin := fq.gremlinQuery() diff --git a/entc/integration/ent/filetype_query.go b/entc/integration/ent/filetype_query.go index 8746c3d65..570df3500 100644 --- a/entc/integration/ent/filetype_query.go +++ b/entc/integration/ent/filetype_query.go @@ -65,16 +65,11 @@ func (ftq *FileTypeQuery) QueryFiles() *FileQuery { query := &FileQuery{config: ftq.config} switch ftq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = ftq.sqlQuery() - step.From.Table = filetype.Table - step.From.Column = filetype.FieldID - step.To.Table = file.Table - step.To.Column = file.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = false - step.Edge.Table = filetype.FilesTable - step.Edge.Columns = append(step.Edge.Columns, filetype.FilesColumn) + step := sql.NewStep( + sql.From(filetype.Table, filetype.FieldID, ftq.sqlQuery()), + sql.To(file.Table, file.FieldID), + sql.Edge(sql.O2M, false, filetype.FilesTable, filetype.FilesColumn), + ) query.sql = sql.SetNeighbors(ftq.driver.Dialect(), step) case dialect.Gremlin: gremlin := ftq.gremlinQuery() diff --git a/entc/integration/ent/group_query.go b/entc/integration/ent/group_query.go index e1d74f2fc..b9bedc908 100644 --- a/entc/integration/ent/group_query.go +++ b/entc/integration/ent/group_query.go @@ -67,16 +67,11 @@ func (gq *GroupQuery) QueryFiles() *FileQuery { query := &FileQuery{config: gq.config} switch gq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = gq.sqlQuery() - step.From.Table = group.Table - step.From.Column = group.FieldID - step.To.Table = file.Table - step.To.Column = file.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = false - step.Edge.Table = group.FilesTable - step.Edge.Columns = append(step.Edge.Columns, group.FilesColumn) + step := sql.NewStep( + sql.From(group.Table, group.FieldID, gq.sqlQuery()), + sql.To(file.Table, file.FieldID), + sql.Edge(sql.O2M, false, group.FilesTable, group.FilesColumn), + ) query.sql = sql.SetNeighbors(gq.driver.Dialect(), step) case dialect.Gremlin: gremlin := gq.gremlinQuery() @@ -90,16 +85,11 @@ func (gq *GroupQuery) QueryBlocked() *UserQuery { query := &UserQuery{config: gq.config} switch gq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = gq.sqlQuery() - step.From.Table = group.Table - step.From.Column = group.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = false - step.Edge.Table = group.BlockedTable - step.Edge.Columns = append(step.Edge.Columns, group.BlockedColumn) + step := sql.NewStep( + sql.From(group.Table, group.FieldID, gq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.O2M, false, group.BlockedTable, group.BlockedColumn), + ) query.sql = sql.SetNeighbors(gq.driver.Dialect(), step) case dialect.Gremlin: gremlin := gq.gremlinQuery() @@ -113,16 +103,11 @@ func (gq *GroupQuery) QueryUsers() *UserQuery { query := &UserQuery{config: gq.config} switch gq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = gq.sqlQuery() - step.From.Table = group.Table - step.From.Column = group.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2M - step.Edge.Inverse = true - step.Edge.Table = group.UsersTable - step.Edge.Columns = append(step.Edge.Columns, group.UsersPrimaryKey...) + step := sql.NewStep( + sql.From(group.Table, group.FieldID, gq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2M, true, group.UsersTable, group.UsersPrimaryKey...), + ) query.sql = sql.SetNeighbors(gq.driver.Dialect(), step) case dialect.Gremlin: gremlin := gq.gremlinQuery() @@ -136,16 +121,11 @@ func (gq *GroupQuery) QueryInfo() *GroupInfoQuery { query := &GroupInfoQuery{config: gq.config} switch gq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = gq.sqlQuery() - step.From.Table = group.Table - step.From.Column = group.FieldID - step.To.Table = groupinfo.Table - step.To.Column = groupinfo.FieldID - step.Edge.Rel = sql.M2O - step.Edge.Inverse = false - step.Edge.Table = group.InfoTable - step.Edge.Columns = append(step.Edge.Columns, group.InfoColumn) + step := sql.NewStep( + sql.From(group.Table, group.FieldID, gq.sqlQuery()), + sql.To(groupinfo.Table, groupinfo.FieldID), + sql.Edge(sql.M2O, false, group.InfoTable, group.InfoColumn), + ) query.sql = sql.SetNeighbors(gq.driver.Dialect(), step) case dialect.Gremlin: gremlin := gq.gremlinQuery() diff --git a/entc/integration/ent/groupinfo_query.go b/entc/integration/ent/groupinfo_query.go index ff3da2711..35502ce9a 100644 --- a/entc/integration/ent/groupinfo_query.go +++ b/entc/integration/ent/groupinfo_query.go @@ -65,16 +65,11 @@ func (giq *GroupInfoQuery) QueryGroups() *GroupQuery { query := &GroupQuery{config: giq.config} switch giq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = giq.sqlQuery() - step.From.Table = groupinfo.Table - step.From.Column = groupinfo.FieldID - step.To.Table = group.Table - step.To.Column = group.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = true - step.Edge.Table = groupinfo.GroupsTable - step.Edge.Columns = append(step.Edge.Columns, groupinfo.GroupsColumn) + step := sql.NewStep( + sql.From(groupinfo.Table, groupinfo.FieldID, giq.sqlQuery()), + sql.To(group.Table, group.FieldID), + sql.Edge(sql.O2M, true, groupinfo.GroupsTable, groupinfo.GroupsColumn), + ) query.sql = sql.SetNeighbors(giq.driver.Dialect(), step) case dialect.Gremlin: gremlin := giq.gremlinQuery() diff --git a/entc/integration/ent/node_query.go b/entc/integration/ent/node_query.go index 395e180de..910e9d084 100644 --- a/entc/integration/ent/node_query.go +++ b/entc/integration/ent/node_query.go @@ -64,16 +64,11 @@ func (nq *NodeQuery) QueryPrev() *NodeQuery { query := &NodeQuery{config: nq.config} switch nq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = nq.sqlQuery() - step.From.Table = node.Table - step.From.Column = node.FieldID - step.To.Table = node.Table - step.To.Column = node.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = true - step.Edge.Table = node.PrevTable - step.Edge.Columns = append(step.Edge.Columns, node.PrevColumn) + step := sql.NewStep( + sql.From(node.Table, node.FieldID, nq.sqlQuery()), + sql.To(node.Table, node.FieldID), + sql.Edge(sql.O2O, true, node.PrevTable, node.PrevColumn), + ) query.sql = sql.SetNeighbors(nq.driver.Dialect(), step) case dialect.Gremlin: gremlin := nq.gremlinQuery() @@ -87,16 +82,11 @@ func (nq *NodeQuery) QueryNext() *NodeQuery { query := &NodeQuery{config: nq.config} switch nq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = nq.sqlQuery() - step.From.Table = node.Table - step.From.Column = node.FieldID - step.To.Table = node.Table - step.To.Column = node.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = false - step.Edge.Table = node.NextTable - step.Edge.Columns = append(step.Edge.Columns, node.NextColumn) + step := sql.NewStep( + sql.From(node.Table, node.FieldID, nq.sqlQuery()), + sql.To(node.Table, node.FieldID), + sql.Edge(sql.O2O, false, node.NextTable, node.NextColumn), + ) query.sql = sql.SetNeighbors(nq.driver.Dialect(), step) case dialect.Gremlin: gremlin := nq.gremlinQuery() diff --git a/entc/integration/ent/pet_query.go b/entc/integration/ent/pet_query.go index c0f46d0b2..6cf2f4d20 100644 --- a/entc/integration/ent/pet_query.go +++ b/entc/integration/ent/pet_query.go @@ -65,16 +65,11 @@ func (pq *PetQuery) QueryTeam() *UserQuery { query := &UserQuery{config: pq.config} switch pq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = pq.sqlQuery() - step.From.Table = pet.Table - step.From.Column = pet.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = true - step.Edge.Table = pet.TeamTable - step.Edge.Columns = append(step.Edge.Columns, pet.TeamColumn) + step := sql.NewStep( + sql.From(pet.Table, pet.FieldID, pq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.O2O, true, pet.TeamTable, pet.TeamColumn), + ) query.sql = sql.SetNeighbors(pq.driver.Dialect(), step) case dialect.Gremlin: gremlin := pq.gremlinQuery() @@ -88,16 +83,11 @@ func (pq *PetQuery) QueryOwner() *UserQuery { query := &UserQuery{config: pq.config} switch pq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = pq.sqlQuery() - step.From.Table = pet.Table - step.From.Column = pet.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2O - step.Edge.Inverse = true - step.Edge.Table = pet.OwnerTable - step.Edge.Columns = append(step.Edge.Columns, pet.OwnerColumn) + step := sql.NewStep( + sql.From(pet.Table, pet.FieldID, pq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2O, true, pet.OwnerTable, pet.OwnerColumn), + ) query.sql = sql.SetNeighbors(pq.driver.Dialect(), step) case dialect.Gremlin: gremlin := pq.gremlinQuery() diff --git a/entc/integration/ent/user_query.go b/entc/integration/ent/user_query.go index 66b00bf61..ee5b6076e 100644 --- a/entc/integration/ent/user_query.go +++ b/entc/integration/ent/user_query.go @@ -68,16 +68,11 @@ func (uq *UserQuery) QueryCard() *CardQuery { query := &CardQuery{config: uq.config} switch uq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = card.Table - step.To.Column = card.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = false - step.Edge.Table = user.CardTable - step.Edge.Columns = append(step.Edge.Columns, user.CardColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(card.Table, card.FieldID), + sql.Edge(sql.O2O, false, user.CardTable, user.CardColumn), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) case dialect.Gremlin: gremlin := uq.gremlinQuery() @@ -91,16 +86,11 @@ func (uq *UserQuery) QueryPets() *PetQuery { query := &PetQuery{config: uq.config} switch uq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = pet.Table - step.To.Column = pet.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = false - step.Edge.Table = user.PetsTable - step.Edge.Columns = append(step.Edge.Columns, user.PetsColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(pet.Table, pet.FieldID), + sql.Edge(sql.O2M, false, user.PetsTable, user.PetsColumn), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) case dialect.Gremlin: gremlin := uq.gremlinQuery() @@ -114,16 +104,11 @@ func (uq *UserQuery) QueryFiles() *FileQuery { query := &FileQuery{config: uq.config} switch uq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = file.Table - step.To.Column = file.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = false - step.Edge.Table = user.FilesTable - step.Edge.Columns = append(step.Edge.Columns, user.FilesColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(file.Table, file.FieldID), + sql.Edge(sql.O2M, false, user.FilesTable, user.FilesColumn), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) case dialect.Gremlin: gremlin := uq.gremlinQuery() @@ -137,16 +122,11 @@ func (uq *UserQuery) QueryGroups() *GroupQuery { query := &GroupQuery{config: uq.config} switch uq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = group.Table - step.To.Column = group.FieldID - step.Edge.Rel = sql.M2M - step.Edge.Inverse = false - step.Edge.Table = user.GroupsTable - step.Edge.Columns = append(step.Edge.Columns, user.GroupsPrimaryKey...) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(group.Table, group.FieldID), + sql.Edge(sql.M2M, false, user.GroupsTable, user.GroupsPrimaryKey...), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) case dialect.Gremlin: gremlin := uq.gremlinQuery() @@ -160,16 +140,11 @@ func (uq *UserQuery) QueryFriends() *UserQuery { query := &UserQuery{config: uq.config} switch uq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2M - step.Edge.Inverse = false - step.Edge.Table = user.FriendsTable - step.Edge.Columns = append(step.Edge.Columns, user.FriendsPrimaryKey...) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2M, false, user.FriendsTable, user.FriendsPrimaryKey...), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) case dialect.Gremlin: gremlin := uq.gremlinQuery() @@ -183,16 +158,11 @@ func (uq *UserQuery) QueryFollowers() *UserQuery { query := &UserQuery{config: uq.config} switch uq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2M - step.Edge.Inverse = true - step.Edge.Table = user.FollowersTable - step.Edge.Columns = append(step.Edge.Columns, user.FollowersPrimaryKey...) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2M, true, user.FollowersTable, user.FollowersPrimaryKey...), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) case dialect.Gremlin: gremlin := uq.gremlinQuery() @@ -206,16 +176,11 @@ func (uq *UserQuery) QueryFollowing() *UserQuery { query := &UserQuery{config: uq.config} switch uq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2M - step.Edge.Inverse = false - step.Edge.Table = user.FollowingTable - step.Edge.Columns = append(step.Edge.Columns, user.FollowingPrimaryKey...) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2M, false, user.FollowingTable, user.FollowingPrimaryKey...), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) case dialect.Gremlin: gremlin := uq.gremlinQuery() @@ -229,16 +194,11 @@ func (uq *UserQuery) QueryTeam() *PetQuery { query := &PetQuery{config: uq.config} switch uq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = pet.Table - step.To.Column = pet.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = false - step.Edge.Table = user.TeamTable - step.Edge.Columns = append(step.Edge.Columns, user.TeamColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(pet.Table, pet.FieldID), + sql.Edge(sql.O2O, false, user.TeamTable, user.TeamColumn), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) case dialect.Gremlin: gremlin := uq.gremlinQuery() @@ -252,16 +212,11 @@ func (uq *UserQuery) QuerySpouse() *UserQuery { query := &UserQuery{config: uq.config} switch uq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = false - step.Edge.Table = user.SpouseTable - step.Edge.Columns = append(step.Edge.Columns, user.SpouseColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.O2O, false, user.SpouseTable, user.SpouseColumn), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) case dialect.Gremlin: gremlin := uq.gremlinQuery() @@ -275,16 +230,11 @@ func (uq *UserQuery) QueryChildren() *UserQuery { query := &UserQuery{config: uq.config} switch uq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = true - step.Edge.Table = user.ChildrenTable - step.Edge.Columns = append(step.Edge.Columns, user.ChildrenColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.O2M, true, user.ChildrenTable, user.ChildrenColumn), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) case dialect.Gremlin: gremlin := uq.gremlinQuery() @@ -298,16 +248,11 @@ func (uq *UserQuery) QueryParent() *UserQuery { query := &UserQuery{config: uq.config} switch uq.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2O - step.Edge.Inverse = false - step.Edge.Table = user.ParentTable - step.Edge.Columns = append(step.Edge.Columns, user.ParentColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2O, false, user.ParentTable, user.ParentColumn), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) case dialect.Gremlin: gremlin := uq.gremlinQuery() diff --git a/entc/integration/idtype/ent/user_query.go b/entc/integration/idtype/ent/user_query.go index 5487d3d58..7cc86d633 100644 --- a/entc/integration/idtype/ent/user_query.go +++ b/entc/integration/idtype/ent/user_query.go @@ -56,16 +56,11 @@ func (uq *UserQuery) Order(o ...Order) *UserQuery { // QuerySpouse chains the current query on the spouse edge. func (uq *UserQuery) QuerySpouse() *UserQuery { query := &UserQuery{config: uq.config} - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = false - step.Edge.Table = user.SpouseTable - step.Edge.Columns = append(step.Edge.Columns, user.SpouseColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.O2O, false, user.SpouseTable, user.SpouseColumn), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) return query } @@ -73,16 +68,11 @@ func (uq *UserQuery) QuerySpouse() *UserQuery { // QueryFollowers chains the current query on the followers edge. func (uq *UserQuery) QueryFollowers() *UserQuery { query := &UserQuery{config: uq.config} - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2M - step.Edge.Inverse = true - step.Edge.Table = user.FollowersTable - step.Edge.Columns = append(step.Edge.Columns, user.FollowersPrimaryKey...) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2M, true, user.FollowersTable, user.FollowersPrimaryKey...), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) return query } @@ -90,16 +80,11 @@ func (uq *UserQuery) QueryFollowers() *UserQuery { // QueryFollowing chains the current query on the following edge. func (uq *UserQuery) QueryFollowing() *UserQuery { query := &UserQuery{config: uq.config} - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2M - step.Edge.Inverse = false - step.Edge.Table = user.FollowingTable - step.Edge.Columns = append(step.Edge.Columns, user.FollowingPrimaryKey...) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2M, false, user.FollowingTable, user.FollowingPrimaryKey...), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) return query } diff --git a/entc/integration/template/ent/pet_query.go b/entc/integration/template/ent/pet_query.go index 7648dda82..fe9a07ec7 100644 --- a/entc/integration/template/ent/pet_query.go +++ b/entc/integration/template/ent/pet_query.go @@ -57,16 +57,11 @@ func (pq *PetQuery) Order(o ...Order) *PetQuery { // QueryOwner chains the current query on the owner edge. func (pq *PetQuery) QueryOwner() *UserQuery { query := &UserQuery{config: pq.config} - step := &sql.Step{} - step.From.V = pq.sqlQuery() - step.From.Table = pet.Table - step.From.Column = pet.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2O - step.Edge.Inverse = true - step.Edge.Table = pet.OwnerTable - step.Edge.Columns = append(step.Edge.Columns, pet.OwnerColumn) + step := sql.NewStep( + sql.From(pet.Table, pet.FieldID, pq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2O, true, pet.OwnerTable, pet.OwnerColumn), + ) query.sql = sql.SetNeighbors(pq.driver.Dialect(), step) return query } diff --git a/entc/integration/template/ent/user_query.go b/entc/integration/template/ent/user_query.go index f191555b1..ea6e58578 100644 --- a/entc/integration/template/ent/user_query.go +++ b/entc/integration/template/ent/user_query.go @@ -57,16 +57,11 @@ func (uq *UserQuery) Order(o ...Order) *UserQuery { // QueryPets chains the current query on the pets edge. func (uq *UserQuery) QueryPets() *PetQuery { query := &PetQuery{config: uq.config} - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = pet.Table - step.To.Column = pet.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = false - step.Edge.Table = user.PetsTable - step.Edge.Columns = append(step.Edge.Columns, user.PetsColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(pet.Table, pet.FieldID), + sql.Edge(sql.O2M, false, user.PetsTable, user.PetsColumn), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) return query } @@ -74,16 +69,11 @@ func (uq *UserQuery) QueryPets() *PetQuery { // QueryFriends chains the current query on the friends edge. func (uq *UserQuery) QueryFriends() *UserQuery { query := &UserQuery{config: uq.config} - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2M - step.Edge.Inverse = false - step.Edge.Table = user.FriendsTable - step.Edge.Columns = append(step.Edge.Columns, user.FriendsPrimaryKey...) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2M, false, user.FriendsTable, user.FriendsPrimaryKey...), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) return query }