From 930a17b7676a153e5b076822d1fafa839338f88d Mon Sep 17 00:00:00 2001 From: Ariel Mashraki Date: Tue, 5 Nov 2019 13:07:38 -0800 Subject: [PATCH] dialect/sql: add neighbors function (#140) Summary: Pull Request resolved: https://github.com/facebookincubator/ent/pull/140 This part of the effort of moving logic from Go templates to shared packages. Next diffs will migrate the neighbors-set and predicates as well. Dedicated tests for `sql/dialect/graph.go` will be added in a follow-up diff. Reviewed By: alexsn Differential Revision: D18304531 fbshipit-source-id: 93e9cf2636b5b4525eb27305bd2708122cfd6e40 --- dialect/sql/graph.go | 107 ++++++ entc/gen/internal/bindata.go | 4 +- entc/gen/template/dialect/sql/query.tmpl | 37 +- entc/integration/ent/client.go | 410 +++++++++++++++-------- entc/integration/idtype/ent/client.go | 62 ++-- entc/integration/template/ent/client.go | 55 +-- examples/edgeindex/ent/client.go | 31 +- examples/m2m2types/ent/client.go | 48 ++- examples/m2mbidi/ent/client.go | 24 +- examples/m2mrecur/ent/client.go | 48 ++- examples/o2m2types/ent/client.go | 31 +- examples/o2mrecur/ent/client.go | 31 +- examples/o2o2types/ent/client.go | 31 +- examples/o2obidi/ent/client.go | 14 +- examples/o2orecur/ent/client.go | 31 +- examples/start/ent/client.go | 79 +++-- examples/traversal/ent/client.go | 158 +++++---- 17 files changed, 758 insertions(+), 443 deletions(-) create mode 100644 dialect/sql/graph.go diff --git a/dialect/sql/graph.go b/dialect/sql/graph.go new file mode 100644 index 000000000..7d0e76cb2 --- /dev/null +++ b/dialect/sql/graph.go @@ -0,0 +1,107 @@ +// Copyright 2019-present Facebook Inc. All rights reserved. +// This source code is licensed under the Apache 2.0 license found +// in the LICENSE file in the root directory of this source tree. + +package sql + +// Rel is a relation type of an edge. +type Rel int + +// Relation types. +const ( + Unk Rel = iota // Unknown. + O2O // One to one / has one. + O2M // One to many / has many. + M2O // Many to one (inverse perspective for O2M). + M2M // Many to many. +) + +// String returns the relation name. +func (r Rel) String() (s string) { + switch r { + case O2O: + s = "O2O" + case O2M: + s = "O2M" + case M2O: + s = "M2O" + case M2M: + s = "M2M" + default: + s = "Unknown" + } + return s +} + +// A Step provides a path-step information to the traversal functions. +type Step struct { + // From is the source of the step. + From struct { + // V can be either one vertex or set of vertices. + // It can be a pre-processed step (sql.Query) or a simple Go type (integer or string). + V interface{} + // Table holds the table name of V (from). + Table string + // Column to join with. Usually the "id" column. + Column string + } + // Edge holds the edge information for getting the neighbors. + Edge struct { + // Rel of the edge. + Rel Rel + // Table name of where this edge columns reside. + Table string + // Columns of the edge. + // In O2O and M2O, it holds the foreign-key column. Hence, len == 1. + // In M2M, it holds the primary-key columns of the join table. Hence, len == 2. + Columns []string + // Inverse indicates if the edge is an inverse edge. + Inverse bool + } + // To is the dest of the path (the neighbors). + To struct { + // Table holds the table name of the neighbors (to). + Table string + // Column to join with. Usually the "id" column. + Column string + } +} + +// Neighbors returns a Selector for evaluating the path-step +// and getting the neighbors of one or more vertices. +func Neighbors(dialect string, s *Step) (q *Selector) { + builder := Dialect(dialect) + switch r := s.Edge.Rel; { + case r == M2M: + pk1, pk2 := s.Edge.Columns[1], s.Edge.Columns[0] + if s.Edge.Inverse { + pk1, pk2 = pk2, pk1 + } + to := builder.Table(s.To.Table) + from := builder.Table(s.From.Table) + join := builder.Table(s.Edge.Table) + match := builder.Select(join.C(pk1)). + From(join). + Join(from). + On(join.C(pk2), from.C(s.From.Column)). + Where(EQ(from.C(s.From.Column), s.From.V)) + q = builder.Select(). + From(to). + Join(match). + On(to.C(s.To.Column), match.C(pk1)) + case r == M2O || (r == O2O && s.Edge.Inverse): + t1 := builder.Table(s.To.Table) + t2 := builder.Select(s.Edge.Columns[0]). + From(builder.Table(s.Edge.Table)). + Where(EQ(s.From.Column, s.From.V)) + q = builder.Select(). + From(t1). + Join(t2). + On(t1.C(s.From.Column), t2.C(s.Edge.Columns[0])) + case r == O2M || (r == O2O && !s.Edge.Inverse): + q = builder.Select(). + From(builder.Table(s.To.Table)). + Where(EQ(s.Edge.Columns[0], s.From.V)) + } + return q +} diff --git a/entc/gen/internal/bindata.go b/entc/gen/internal/bindata.go index 88fbb936b..6b4d1b5cd 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\xcc\x58\x5f\x6f\xdb\x38\x12\x7f\xb6\x3f\xc5\x6c\x90\x5b\x48\x86\x23\x27\x4e\x5f\x2e\x41\x0e\xe8\xa5\x59\xc0\x77\x9b\x66\xdb\x14\xe8\x43\x51\x1c\x18\x69\x64\xb3\x91\x49\x87\xa4\x9d\x04\xae\xbe\xfb\x61\x86\x92\x2c\xdb\x72\x63\xa7\xc1\x36\x0f\x45\x4d\x71\xfe\xcf\x6f\xf8\x9b\x76\x3e\xef\x75\xda\xe7\x7a\xf2\x68\xe4\x70\xe4\xa0\x7f\x78\xf4\xcf\x83\x89\x41\x8b\xca\xc1\x1f\x22\xc6\x1b\xad\x6f\x61\xa0\xe2\x08\xde\x66\x19\xb0\x90\x05\xba\x37\x33\x4c\xa2\xf6\xa7\x91\xb4\x60\xf5\xd4\xc4\x08\xb1\x4e\x10\xa4\x85\x4c\xc6\xa8\x2c\x26\x30\x55\x09\x1a\x70\x23\x84\xb7\x13\x11\x8f\x10\xfa\xd1\x61\x79\x0b\xa9\x9e\xaa\xa4\x2d\x15\xdf\xff\x39\x38\xbf\x78\x7f\x7d\x01\xa9\xcc\x10\x8a\x6f\x46\x6b\x07\x89\x34\x18\x3b\x6d\x1e\x41\xa7\xe0\x6a\xce\x9c\x41\x8c\xda\x9d\x5e\x9e\xb7\xdb\xf3\x39\x24\x98\x4a\x85\xb0\x97\x48\x91\x61\xec\x7a\xf6\x2e\xeb\xdd\x4d\xd1\x3c\xee\x41\x9e\x93\xc0\xfe\xe4\x76\x08\x27\x67\xb0\x1f\x5d\xc7\x7a\x82\xd1\x5f\x22\xbe\x15\x43\x2c\x6f\x6f\xa6\x32\xa3\x60\x4f\xce\x60\x22\x6c\x2c\xb2\x4a\xf0\xdf\xc5\x4d\x21\x68\x30\x46\x39\xf3\x92\xd5\xef\x4a\x9d\xa2\x49\xa7\x2a\x86\x60\x49\x36\xcf\xa1\x53\xf7\x92\xe7\x21\xd8\xbb\xec\x6d\x96\x05\xb1\x7b\x80\x58\x2b\x87\x0f\x2e\x3a\xf7\x7f\x87\x10\x7c\xf9\xca\xf2\xd1\x7b\x31\xa6\x10\xbb\x80\xc6\x68\x13\xc2\xbc\xdd\x32\xfa\xde\x92\xf3\xdf\xed\x5d\x16\x7d\xd4\xf7\x76\x9e\xb7\x5b\x16\x33\x2e\x13\x5d\xac\x78\x8e\xec\x5d\xf6\x81\x2a\x11\x84\xed\x96\x4c\x61\xaa\xe4\xdd\x14\x9b\x04\xfd\xcd\x29\x64\xa8\x02\xff\x3b\x84\xb3\x33\x38\x24\xaf\x95\x87\xe8\x9d\xb4\x4e\xaa\xd8\x91\xb9\xbc\xdd\xe2\x22\x77\x41\x98\x21\x47\x55\x89\xd5\x5d\xa2\x69\x0c\x2c\x31\xf4\xab\x90\x8c\xdd\x43\x17\x6a\xc6\xba\x40\x89\x86\xa7\xac\xfc\xdb\x19\x28\x99\x71\x1c\x06\xdd\xd4\x28\x3a\x72\x51\x38\x86\x04\x53\x34\x2c\x1f\x9d\x67\xda\x22\xb9\x9d\xcf\x0f\xc8\x9b\xe3\x8e\x66\x53\xc3\x1d\xfd\xb8\xf0\xde\x6e\xcd\x84\x29\x42\x72\xd4\xa0\xf9\x7c\x21\xc7\x65\x67\xa1\xd5\xe8\x49\x34\xfa\xc3\xe8\x31\x55\x3e\xd8\x3e\xc4\x9a\x76\xac\x55\x2a\x87\xab\x00\x29\x3e\x87\xed\x52\x7d\xa1\xd1\x25\x53\xed\x9d\x90\x75\xae\xa7\xca\x6d\xc0\x96\x54\xee\xc5\xf0\xb4\x00\xd3\x97\xaf\xd6\x19\xa9\x86\x73\x96\xaf\x8d\x57\xc4\xe7\xc1\x3b\x8a\xc0\x3a\xa1\xb8\xd8\xbe\xb2\x04\xb4\x66\x10\x86\xf0\xaf\x02\x77\x85\x87\x4d\x68\xe5\xe2\x56\xa0\xf3\x69\x53\x22\x15\x4a\x6b\x77\xd9\x74\xac\x6c\x81\xec\x28\x8a\x42\xfa\x13\xfe\x32\x04\x1f\xfe\x18\xbf\x32\x85\xdf\xf8\xcb\x7b\x7c\x70\x41\xb8\xae\xa9\x0d\xdd\xdd\x07\x7b\xe5\xe3\x96\xe7\x27\xa0\x34\x9b\xf1\x8f\xeb\x9e\x9f\x50\xc2\xb9\x02\xa9\x5c\x3d\x13\x36\x7d\x1d\x0b\x15\xfc\xae\x7e\x14\x62\x3a\x76\xd1\x05\x39\x4b\x97\x1d\xa5\x42\x66\x98\x80\x41\x91\x48\x35\x84\x98\x0a\x7f\x02\xff\x98\xed\x71\x6c\xde\x71\x39\x07\xcf\xc0\xef\xc5\x83\xb4\x9b\xf0\x7b\xa3\x75\x56\x07\xb0\xea\x6e\x6a\x4f\x7d\x10\x16\x7d\x5c\xcf\x33\x15\x99\xc5\xcd\xb9\xc6\x23\x8c\x6f\x01\x29\x24\x54\x31\x6e\x4a\x93\x20\xfb\x8c\x54\x0b\x98\x41\x87\x60\x7b\x5d\xce\xdd\xbc\xdd\xaa\x51\x92\x47\x34\x33\xdb\xda\xc0\x14\x18\x2c\xaf\x09\xd1\xee\x88\x94\x0a\xfd\xe8\x93\xb8\xc9\x30\x58\x9d\x4a\xfe\x1a\x2e\x4f\x7a\xa9\xe1\xa3\x08\xdc\x51\x35\x34\xab\xda\xc5\xf7\x72\x8a\xf8\x45\x0c\xdc\x91\x2f\x72\x43\x1b\xea\x45\xaf\x3c\x36\x36\xac\x4e\x35\x45\x1c\x6b\x23\xfc\x44\x34\xdc\x95\x54\x1b\xf8\x5f\x17\x26\x0c\x76\xa1\x86\xb8\xe6\x6c\x62\x30\x91\xb1\x70\x68\x39\xac\x49\xe5\x67\x5b\x03\xda\x50\x7b\x9a\x74\x65\x0a\x3a\x4d\xad\x67\x9f\x35\x35\xbe\x39\x2d\x25\x6a\x95\xe9\xf5\x20\x93\x63\xe9\x68\x89\x1a\x0b\x95\x08\x5e\x7c\x28\x90\x42\x36\xce\xc4\xd4\x62\x04\x9f\x11\xac\x13\xc6\x79\x9d\x7b\xe9\x46\xb4\x00\x89\x69\xe6\x60\x26\xb2\x29\x76\x41\xa8\x04\xf4\x0c\x8d\x91\xb4\x93\x39\xb8\xc1\x4c\xdf\x83\x4c\x41\x21\x26\xb4\xb8\xd5\xca\x7c\xc5\xc6\x83\x8e\x77\x12\x46\x7f\x52\x0c\xc1\x58\xb8\x51\x74\x29\x1e\x06\xca\x1d\xf7\xab\xb4\x7c\x7c\x0d\x59\xf1\xc5\x69\x71\xdf\xd0\xed\xc2\x6a\x87\x05\x96\x06\xa7\x94\x68\xf3\x82\x85\x2a\x01\xbf\xd3\xf5\x3a\xfe\x35\xed\x4d\x84\xcf\x4f\x2a\xb4\xbc\x19\xf2\x67\x18\xa2\x42\x23\x9c\xd4\x8a\x4b\xc4\x52\x3a\x05\x01\x43\x39\x43\x05\x98\x0c\x31\x02\x5e\x10\x7f\xb4\x1f\xb2\x75\x5e\x12\xfd\xca\x80\xf5\x25\xf1\x22\x61\x80\x01\x07\x43\x9e\xc9\x28\xdc\x23\x57\x11\x9c\xe6\x18\x86\x46\x38\xe4\x5b\x0e\xc1\xe9\xc2\x6b\xb9\x82\x2c\xf6\xc5\xd2\x6c\x7d\x0d\xf9\x99\x39\x27\x07\x32\x85\x7d\x8c\x2e\xfb\x97\x9c\x02\xef\x19\x92\x4c\x1d\x41\x9e\xd3\xe1\x1b\x1d\x0e\xf9\x50\x0a\x0f\xec\x40\xcd\xd0\x58\x2c\x44\x24\x94\x12\x24\x5e\xa9\x52\x27\x0e\xd8\xe8\xa6\xf7\x04\xa3\x4f\x8f\x4b\xab\x74\xf5\xaa\xb4\x5c\xff\xa9\xd5\xa1\xe5\xfa\xd5\x43\xd3\x8f\xce\xd7\x86\xba\x61\x6d\x08\x59\xed\xf8\xe9\xc7\xad\x08\x8e\xee\xea\xea\xa4\xfd\xa6\xe9\xa1\x3b\xde\xe0\x1f\xa3\xbf\xfe\x5b\x33\xf0\xc5\x57\x2b\xcf\xbf\x86\x21\x4d\x50\xab\xe5\xdf\xbd\xe3\xe2\xf4\x1f\x2d\x55\xe0\xfa\xc5\xe9\x4a\xed\x66\xf8\x1b\x1b\xee\xc2\x4e\xd5\x60\x0c\xf3\x0b\xbb\x96\x95\x0f\xa3\x7c\x99\xf9\xe0\x03\x7c\xe3\x0f\x14\xdf\x51\xe1\x6a\xbd\x93\xb5\xaf\x2b\x6e\xbb\xe0\xde\xec\x5e\x2f\x8f\x56\xcc\x2c\x12\x0a\xb5\xf1\xa8\xbd\x82\x80\x5e\xaa\x7d\x8c\xae\xfa\x57\x4b\xd8\x0c\x19\x84\xbd\x0e\x90\xd0\xf7\xef\x10\x90\x00\xbf\x74\xb2\x00\x2f\xcd\x62\x58\x8c\xda\xaf\x83\x28\x16\xec\xb3\x43\x63\x56\x78\x75\x3d\xc4\x55\x76\xdd\xd0\xc7\xfe\x4f\xf7\x71\xc7\xa4\xaa\x0e\x16\xad\xb9\xea\x5f\x2e\xb7\x46\x58\xab\xe3\x57\xd2\x98\x97\x9a\x96\x86\x2a\x6f\x53\xae\xdd\xe6\x98\x2b\xeb\x99\xaf\x99\x03\x53\xa3\xc7\x4f\x73\xa0\xf0\xb4\x57\x5c\xb2\x4e\x49\x87\x4a\x27\x5b\xd1\x21\x29\xd5\xe8\x50\x31\x6f\x2d\x71\x20\x59\x22\x0e\xe4\x0d\xa4\x16\x0b\x69\x2e\x51\xdf\xdf\x4a\xa5\x07\xcc\xa5\x32\x69\x82\x4e\x49\x7d\x8a\x2a\x3f\xb0\xd7\xfc\x0f\x55\xc8\x73\x99\x04\x21\x95\xdb\x43\x7a\xf0\x6e\x51\xfa\x17\x23\xe5\xd7\xc8\xca\xeb\x2a\xaa\x59\x7a\x03\xd3\xaa\x97\xa0\xda\x06\x23\x2f\xc4\xb5\x5b\x59\x5e\x23\xdb\x35\x2d\xb5\x36\xa6\xde\xd5\xe7\x11\x1a\xe4\xff\x63\xb8\xf8\x10\xec\xa0\xde\x05\x99\xbc\x02\xca\xde\xa5\xee\xaf\x95\xb3\x57\xaa\xb6\x21\xad\xf5\x37\x79\x51\xdd\xe7\x81\xda\x1b\x58\x02\xc0\x56\xbd\xdf\xae\xf5\x55\xdb\x2b\x68\xbf\x00\xb3\x6f\x55\x97\x67\x52\xfb\xd3\xd9\x6c\xdf\xdb\x6d\x4b\xdb\x10\x7e\x59\xdd\x46\x0e\xfd\x7f\x00\x00\x00\xff\xff\x11\x90\xf1\x3f\xdf\x18\x00\x00") +var _templateDialectSqlQueryTmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x58\xdd\x6f\x1b\xb9\x11\x7f\x96\xfe\x8a\x39\x23\x3d\xec\x0a\x0a\x65\x2b\x79\x69\x02\x17\x48\x1d\x1f\xa0\xf6\x6c\x5f\x6d\xa3\x7d\x08\x82\x82\xde\x9d\x95\x78\x5e\x91\x32\x49\xc9\x36\x74\xfb\xbf\x17\x33\xe4\xae\x56\x5f\xb1\x75\x77\xe8\xdd\x43\x90\x25\xe7\x93\x33\xbf\xf9\x90\x97\xcb\x41\xaf\x7b\x66\x66\xcf\x56\x8d\x27\x1e\x86\xc7\x27\x7f\x7d\x3b\xb3\xe8\x50\x7b\xf8\x41\x66\x78\x67\xcc\x3d\x8c\x74\x26\xe0\x53\x59\x02\x33\x39\x20\xba\x5d\x60\x2e\xba\xb7\x13\xe5\xc0\x99\xb9\xcd\x10\x32\x93\x23\x28\x07\xa5\xca\x50\x3b\xcc\x61\xae\x73\xb4\xe0\x27\x08\x9f\x66\x32\x9b\x20\x0c\xc5\x71\x4d\x85\xc2\xcc\x75\xde\x55\x9a\xe9\x3f\x8e\xce\xce\x2f\x6f\xce\xa1\x50\x25\x42\xbc\xb3\xc6\x78\xc8\x95\xc5\xcc\x1b\xfb\x0c\xa6\x00\xdf\x32\xe6\x2d\xa2\xe8\xf6\x06\x55\xd5\xed\x2e\x97\x90\x63\xa1\x34\xc2\x51\xae\x64\x89\x99\x1f\xb8\x87\x72\xf0\x30\x47\xfb\x7c\x04\x55\x45\x0c\x6f\x66\xf7\x63\xf8\x70\x0a\x6f\xc4\x4d\x66\x66\x28\x7e\x92\xd9\xbd\x1c\x63\x4d\xbd\x9b\xab\x92\x9c\xfd\x70\x0a\x33\xe9\x32\x59\x36\x8c\x7f\x8f\x94\xc8\x68\x31\x43\xb5\x08\x9c\xcd\x77\x23\x4e\xde\x14\x73\x9d\x41\xb2\xc6\x5b\x55\xd0\x6b\x5b\xa9\xaa\x14\xdc\x43\xf9\xa9\x2c\x93\xcc\x3f\x41\x66\xb4\xc7\x27\x2f\xce\xc2\xff\x29\x24\x5f\xbe\x32\xbf\xb8\x94\x53\x72\xb1\x0f\x68\xad\xb1\x29\x2c\xbb\x1d\x6b\x1e\x1d\x19\xff\xde\x3d\x94\xe2\xda\x3c\xba\x65\xd5\xed\x38\x2c\x39\x4c\x44\xd8\xb0\x2c\xdc\x43\xf9\x2f\x8a\x44\x92\x76\x3b\xaa\x80\xb9\x56\x0f\x73\xdc\xc5\x18\x28\x1f\xa1\x44\x9d\x84\xef\x14\x4e\x4f\xe1\x98\xac\x36\x16\xc4\x67\xe5\xbc\xd2\x99\x27\x75\x55\xb7\xc3\x41\xee\x83\xb4\x63\xf6\xaa\x61\x6b\x9b\x44\xbb\xd3\xb1\xdc\xd2\x57\xe4\xcc\xfc\x53\x1f\x5a\xca\xfa\x40\x0f\x4d\x3f\xb2\xf0\x77\xa7\xa0\x55\xc9\x7e\x58\xf4\x73\xab\xe9\xc8\x41\x61\x1f\x72\x2c\xd0\x32\xbf\x38\x2b\x8d\x43\x32\xbb\x5c\xbe\x25\x6b\x9e\x33\x5a\xce\x2d\x67\xf4\x7a\x65\xbd\xdb\x59\x48\x1b\x5d\xf2\x94\xa0\xe5\x72\xc5\xc7\x61\x67\xa6\x4d\xef\x89\x55\xfc\x60\xcd\x94\x22\x9f\xbc\xde\xc5\x96\x74\x66\x74\xa1\xc6\x9b\x00\x89\xd7\x69\xb7\x16\x5f\x49\xf4\x49\x55\xf7\x20\x64\x9d\x99\xb9\xf6\x7b\xb0\xa5\xb4\xff\xdd\xf0\xb4\x02\xd3\x97\xaf\xce\x5b\xa5\xc7\x4b\xe6\x6f\x95\x97\xe0\xf3\xe8\x33\x79\xe0\xbc\xd4\x1c\xec\x10\x59\x02\xda\x6e\x10\xa6\xf0\xb7\x88\xbb\x68\x61\x1f\x5a\x39\xb8\x0d\xe8\xc2\xb3\xe9\x21\x0d\x4a\x5b\xb4\x72\x3e\xd5\x2e\x22\x5b\x08\x91\xd2\xbf\xf4\x0f\x43\xf0\xf1\xb7\xf1\xab\x0a\xf8\x8e\x6f\x2e\xf1\xc9\x27\xe9\xb6\xa4\xb1\x44\x7b\x4c\x8e\xea\xe6\x56\x55\x1f\x40\x1b\x56\x13\x9a\xeb\x51\xa8\x50\xc2\xb9\x06\xa5\x7d\xfb\x25\xac\xfa\x26\x93\x3a\xf9\x5e\x7f\xcb\xc5\x62\xea\xc5\x39\x19\x2b\xd6\x0d\x15\x52\x95\x98\x83\x45\x99\x2b\x3d\x86\x8c\x02\xff\x01\xfe\xb2\x38\x62\xdf\x82\xe1\xba\x0e\x7e\x05\x7e\xcf\x9f\x94\xdb\x87\xdf\x3b\x63\xca\x36\x80\x75\x7f\x5f\x7a\xda\x85\xb0\xca\xe3\xf6\x3b\x0b\x59\x3a\xdc\xff\xd6\x6c\x82\xd9\x3d\x20\xb9\x84\x3a\xc3\x7d\xcf\x24\xc8\xfe\x8a\xa7\x46\x98\x41\x8f\x60\x7b\x53\xd7\xdd\xb2\xdb\x69\x8d\xa4\x80\x68\x9e\x6c\x5b\x05\x13\x31\x58\x93\x09\xd1\xfe\x84\x84\xa2\xbc\xb8\x95\x77\x25\x26\x9b\x55\xc9\xb7\xe9\x7a\xa5\xd7\x12\xc1\x8b\xc4\x9f\x34\x45\xb3\x29\x1d\xef\xeb\x2a\xe2\x8e\x98\xf8\x93\x10\xe4\x1d\x69\x68\x07\xbd\xb1\xb8\x33\x61\xed\x51\x13\xfd\xd8\x2a\xe1\x17\xbc\xe1\xac\x14\xc6\xc2\x7f\xfb\x30\x63\xb0\x4b\x3d\xc6\x2d\x63\x33\x8b\xb9\xca\xa4\x47\xc7\x6e\xcd\x1a\x3b\xaf\x55\x60\x2c\xa5\x67\x97\xac\x2a\xc0\x14\x85\x0b\xd3\x67\x4b\x8c\x29\x1f\x6b\x8e\x56\x64\x06\x03\x28\xd5\x54\x79\x5a\xa2\xa6\x52\xe7\x92\x17\x1f\x72\x24\xf2\x66\xa5\x9c\x3b\x14\xf0\x1f\x04\xe7\xa5\xf5\x41\xe6\x51\xf9\x09\x2d\x40\x72\x5e\x7a\x58\xc8\x72\x8e\x7d\x90\x3a\x07\xb3\x40\x6b\x15\xed\x64\x1e\xee\xb0\x34\x8f\xa0\x0a\xd0\x88\x39\x2d\x6e\xad\x30\x5f\xb1\xf2\xa4\x17\x8c\xa4\xe2\x47\xf2\x21\x99\x4a\x3f\x11\x17\xf2\x69\xa4\xfd\xbb\x61\xf3\xac\xe0\xdf\x8e\x57\x31\xe1\x63\xa4\xef\xc8\x76\xd4\xda\x63\x86\xb5\xc2\xa9\x39\xba\xbc\x60\xa1\xce\x21\xec\x74\x83\x5e\xe8\xa6\x83\x99\x0c\xef\x53\x1a\x1d\x6f\x86\x7c\x0d\x63\xd4\x68\xa5\x57\x46\x73\x88\x98\xcb\x14\x20\x61\xac\x16\xa8\x01\xf3\x31\x0a\xe0\x05\xf1\x5b\xfb\x21\x6b\xe7\x25\x31\xac\x0c\xd8\x5e\x12\xcf\x73\x06\x18\xb0\x33\x64\x99\x94\xc2\x23\x72\x14\xc1\x1b\xf6\x61\x6c\xa5\x47\xa6\xb2\x0b\xde\x44\xab\xf5\x0a\xb2\xda\x17\x6b\xb5\xed\x35\xe4\xb7\xd4\x39\x19\x50\x05\xbc\x41\x71\x31\xbc\xe0\x27\xf0\x9e\xa1\x48\xd5\x09\x54\x15\x1d\x7e\xa6\xc3\x31\x1f\x6a\xe6\x91\x1b\xe9\x05\x5a\x87\x91\x45\x41\xcd\x41\xec\x8d\x28\x65\xe2\x2d\x2b\xdd\xd7\x4f\x50\xdc\x3e\xaf\xad\xd2\x4d\x57\xe9\xf8\xe1\x4b\xab\x43\xc7\x0f\x9b\x46\x33\x14\x67\x5b\x45\xbd\x63\x6d\x48\x59\xec\xdd\xcb\xcd\x2d\x3a\x47\xb4\xb6\x38\x49\xbf\xdf\xd5\xe8\xde\xed\xb1\x8f\xe2\xa7\x7f\xb6\x14\x7c\x09\xd1\xaa\xaa\xaf\x69\x4a\x15\xd4\xe9\x84\xbe\xf7\x2e\x9e\xfe\x61\x94\x4e\xfc\x30\x9e\xae\xf4\x61\x8a\x7f\x66\xc5\x7d\x38\x28\x1a\x8c\x61\xee\xb0\x5b\xaf\x0a\x6e\xd4\x9d\x99\x0f\xc1\xc1\xf7\xe1\x40\xfe\x9d\x44\x53\xdb\x99\x6c\xdd\x6e\x98\xed\x83\x7f\x7f\x78\xbc\x02\x5a\xb1\x74\x48\x28\x34\x36\xa0\xf6\x0a\x12\xea\x54\x6f\x50\x5c\x0d\xaf\xd6\xb0\x99\x32\x08\x07\x3d\x20\xa6\x5f\x7e\x81\x84\x18\xb8\xd3\xa9\x08\x5e\xaa\xc5\x34\x96\xda\x1f\x07\x51\x8c\xd3\xe7\x80\xc4\x6c\xcc\xd5\x6d\x17\x37\xa7\xeb\x9e\x3c\x0e\x7f\x73\x1e\x0f\x7c\x54\x93\xc1\x98\x9a\xab\xe1\xc5\x7a\x6a\xa4\x73\x26\xfb\x93\x24\xe6\xf7\xaa\x96\x1d\x51\x7e\x4d\xb8\x0e\xab\x63\x8e\x6c\x98\x7c\xbb\x67\x60\x61\xcd\xf4\xe5\x19\x28\xc3\xd8\x8b\x44\x96\xa9\xc7\xa1\x36\xf9\xab\xc6\x21\x09\xb5\xc6\xa1\xe6\xb9\xb5\x36\x03\x49\x13\xcd\x40\xde\x40\x5a\xbe\x90\xe4\xda\xe8\xfb\xbf\x8e\x52\x9e\x54\x2a\xdf\x85\x9c\x7a\xf2\x69\x0a\xfc\xc8\xdd\xf0\xef\x54\xa8\x2a\x95\x27\x29\x45\x3b\x20\x7a\xf4\x79\x15\xf9\x8e\xf3\x38\x6b\x7e\x14\xdf\x78\x9c\x2d\xe3\x25\x6f\xba\xe2\xdf\x70\x0a\x2a\x6f\xdf\x30\x78\xe3\x46\xab\xb7\x50\xdd\xe6\x0c\x50\xd9\xc5\x1a\x2e\xd6\xc1\x11\x25\x6f\xcd\x9a\x85\x3d\xc5\xb3\x62\x5e\x33\x72\x40\x53\x88\x1a\x28\x59\xe2\x1a\xa9\x4c\x28\x00\x81\xfd\x1a\x4b\x16\xd9\x60\xab\x77\x89\xda\x56\x7b\xbb\x68\xf3\xed\x8d\xd0\xee\x61\xdd\x16\x8d\xfd\x10\x4e\x41\xce\x66\xa8\xf3\x64\x8b\xd4\x27\xb5\xed\x55\x68\x8f\x95\xb5\xf1\x24\x84\x58\xa5\x7f\x8f\xc0\x56\x61\x37\x20\xa9\xff\x72\x10\xdb\x09\xc5\xe9\x12\xd5\x78\x72\x67\xac\x7b\x71\x79\xeb\x03\x3d\x21\x6d\x15\xfb\xff\x02\x00\x00\xff\xff\x47\x8e\x50\x69\x88\x15\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: 6367, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + info := bindataFileInfo{name: "template/dialect/sql/query.tmpl", size: 5512, 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 7d79965f4..15965d508 100644 --- a/entc/gen/template/dialect/sql/query.tmpl +++ b/entc/gen/template/dialect/sql/query.tmpl @@ -130,31 +130,16 @@ func ({{ $receiver }} *{{ $builder }}) sqlQuery() *sql.Selector { {{- $n := $ }} {{/* the node we start the query from. */}} {{- $e := $.Scope.Edge }} {{/* the edge we need to genegrate the path to. */}} {{- $receiver := $.Scope.Receiver -}} - id := {{ $receiver }}.{{- if $n.ID.IsString }}id(){{ else }}ID{{ end }} - builder := sql.Dialect({{ $receiver }}.driver.Dialect()) - {{- if $e.M2M }} - {{ $i := 1 }}{{ $j := 0 }}{{- if $e.IsInverse }}{{ $i = 0 }}{{ $j = 1 }}{{ end -}} - t1 := builder.Table({{ $e.Type.Package }}.Table) - t2 := builder.Table({{ $n.Package }}.Table) - t3 := builder.Table({{ $n.Package }}.{{ $e.TableConstant }}) - t4 := builder.Select(t3.C({{ $n.Package }}.{{ $e.PKConstant }}[{{ $i }}])). - From(t3). - Join(t2). - On(t3.C({{ $n.Package }}.{{ $e.PKConstant }}[{{ $j }}]), t2.C({{ $n.Package }}.{{ $n.ID.Constant }})). - Where(sql.EQ(t2.C({{ $n.Package }}.{{ $n.ID.Constant }}), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C({{ $e.Type.Package }}.{{ $e.Type.ID.Constant }}), t4.C({{ $n.Package }}.{{ $e.PKConstant }}[{{ $i }}])) - {{- else if or $e.M2O (and $e.O2O $e.IsInverse) }}{{/* M2O || (O2O with inverse edge) */}} - t1 := builder.Table({{ $e.Type.Package }}.Table) - t2 := builder.Select({{ $n.Package }}.{{ $e.ColumnConstant }}). - From(builder.Table({{ $n.Package }}.{{ $e.TableConstant }})). - Where(sql.EQ({{ $n.Package }}.{{ $n.ID.Constant }}, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C({{ $e.Type.Package }}.{{ $e.Type.ID.Constant }}), t2.C({{ $n.Package }}.{{ $e.ColumnConstant }})) - {{- else }}{{/* O2M || (O2O with assoc edge) */}} - query.sql = builder.Select().From(builder.Table({{ $e.Type.Package }}.Table)). - Where(sql.EQ({{ $n.Package }}.{{ $e.ColumnConstant }}, id)) - {{- end }} + step := &sql.Step{} + step.From.V = id + 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 }}) + query.sql = sql.Neighbors({{ $receiver }}.driver.Dialect(), step) {{ end }} diff --git a/entc/integration/ent/client.go b/entc/integration/ent/client.go index d614e0685..fa8722a12 100644 --- a/entc/integration/ent/client.go +++ b/entc/integration/ent/client.go @@ -245,12 +245,17 @@ func (c *CardClient) QueryOwner(ca *Card) *UserQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := ca.id() - builder := sql.Dialect(ca.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Select(card.OwnerColumn). - From(builder.Table(card.OwnerTable)). - Where(sql.EQ(card.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(user.FieldID), t2.C(card.OwnerColumn)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(ca.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(ca.ID).InE(user.CardLabel).OutV() @@ -457,12 +462,17 @@ func (c *FileClient) QueryOwner(f *File) *UserQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := f.id() - builder := sql.Dialect(f.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Select(file.OwnerColumn). - From(builder.Table(file.OwnerTable)). - Where(sql.EQ(file.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(user.FieldID), t2.C(file.OwnerColumn)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(f.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(f.ID).InE(user.FilesLabel).OutV() @@ -477,12 +487,17 @@ func (c *FileClient) QueryType(f *File) *FileTypeQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := f.id() - builder := sql.Dialect(f.driver.Dialect()) - t1 := builder.Table(filetype.Table) - t2 := builder.Select(file.TypeColumn). - From(builder.Table(file.TypeTable)). - Where(sql.EQ(file.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(filetype.FieldID), t2.C(file.TypeColumn)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(f.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(f.ID).InE(filetype.FilesLabel).OutV() @@ -561,9 +576,17 @@ func (c *FileTypeClient) QueryFiles(ft *FileType) *FileQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := ft.id() - builder := sql.Dialect(ft.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(file.Table)). - Where(sql.EQ(filetype.FilesColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(ft.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(ft.ID).OutE(filetype.FilesLabel).InV() @@ -642,9 +665,17 @@ func (c *GroupClient) QueryFiles(gr *Group) *FileQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := gr.id() - builder := sql.Dialect(gr.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(file.Table)). - Where(sql.EQ(group.FilesColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(gr.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(gr.ID).OutE(group.FilesLabel).InV() @@ -659,9 +690,17 @@ func (c *GroupClient) QueryBlocked(gr *Group) *UserQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := gr.id() - builder := sql.Dialect(gr.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(user.Table)). - Where(sql.EQ(group.BlockedColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(gr.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(gr.ID).OutE(group.BlockedLabel).InV() @@ -676,19 +715,17 @@ func (c *GroupClient) QueryUsers(gr *Group) *UserQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := gr.id() - builder := sql.Dialect(gr.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(group.Table) - t3 := builder.Table(group.UsersTable) - t4 := builder.Select(t3.C(group.UsersPrimaryKey[0])). - From(t3). - Join(t2). - On(t3.C(group.UsersPrimaryKey[1]), t2.C(group.FieldID)). - Where(sql.EQ(t2.C(group.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(group.UsersPrimaryKey[0])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(gr.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(gr.ID).InE(user.GroupsLabel).OutV() @@ -703,12 +740,17 @@ func (c *GroupClient) QueryInfo(gr *Group) *GroupInfoQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := gr.id() - builder := sql.Dialect(gr.driver.Dialect()) - t1 := builder.Table(groupinfo.Table) - t2 := builder.Select(group.InfoColumn). - From(builder.Table(group.InfoTable)). - Where(sql.EQ(group.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(groupinfo.FieldID), t2.C(group.InfoColumn)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(gr.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(gr.ID).OutE(group.InfoLabel).InV() @@ -787,9 +829,17 @@ func (c *GroupInfoClient) QueryGroups(gi *GroupInfo) *GroupQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := gi.id() - builder := sql.Dialect(gi.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(group.Table)). - Where(sql.EQ(groupinfo.GroupsColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(gi.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(gi.ID).InE(group.InfoLabel).OutV() @@ -932,12 +982,17 @@ func (c *NodeClient) QueryPrev(n *Node) *NodeQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := n.id() - builder := sql.Dialect(n.driver.Dialect()) - t1 := builder.Table(node.Table) - t2 := builder.Select(node.PrevColumn). - From(builder.Table(node.PrevTable)). - Where(sql.EQ(node.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(node.FieldID), t2.C(node.PrevColumn)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(n.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(n.ID).InE(node.NextLabel).OutV() @@ -952,9 +1007,17 @@ func (c *NodeClient) QueryNext(n *Node) *NodeQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := n.id() - builder := sql.Dialect(n.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(node.Table)). - Where(sql.EQ(node.NextColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(n.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(n.ID).OutE(node.NextLabel).InV() @@ -1033,12 +1096,17 @@ func (c *PetClient) QueryTeam(pe *Pet) *UserQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := pe.id() - builder := sql.Dialect(pe.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Select(pet.TeamColumn). - From(builder.Table(pet.TeamTable)). - Where(sql.EQ(pet.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(user.FieldID), t2.C(pet.TeamColumn)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(pe.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(pe.ID).InE(user.TeamLabel).OutV() @@ -1053,12 +1121,17 @@ func (c *PetClient) QueryOwner(pe *Pet) *UserQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := pe.id() - builder := sql.Dialect(pe.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Select(pet.OwnerColumn). - From(builder.Table(pet.OwnerTable)). - Where(sql.EQ(pet.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(user.FieldID), t2.C(pet.OwnerColumn)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(pe.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(pe.ID).InE(user.PetsLabel).OutV() @@ -1137,9 +1210,17 @@ func (c *UserClient) QueryCard(u *User) *CardQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := u.id() - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(card.Table)). - Where(sql.EQ(user.CardColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(u.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(u.ID).OutE(user.CardLabel).InV() @@ -1154,9 +1235,17 @@ func (c *UserClient) QueryPets(u *User) *PetQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := u.id() - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(pet.Table)). - Where(sql.EQ(user.PetsColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(u.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(u.ID).OutE(user.PetsLabel).InV() @@ -1171,9 +1260,17 @@ func (c *UserClient) QueryFiles(u *User) *FileQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := u.id() - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(file.Table)). - Where(sql.EQ(user.FilesColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(u.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(u.ID).OutE(user.FilesLabel).InV() @@ -1188,19 +1285,17 @@ func (c *UserClient) QueryGroups(u *User) *GroupQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := u.id() - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(group.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.GroupsTable) - t4 := builder.Select(t3.C(user.GroupsPrimaryKey[1])). - From(t3). - Join(t2). - On(t3.C(user.GroupsPrimaryKey[0]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(group.FieldID), t4.C(user.GroupsPrimaryKey[1])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(u.ID).OutE(user.GroupsLabel).InV() @@ -1215,19 +1310,17 @@ func (c *UserClient) QueryFriends(u *User) *UserQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := u.id() - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.FriendsTable) - t4 := builder.Select(t3.C(user.FriendsPrimaryKey[1])). - From(t3). - Join(t2). - On(t3.C(user.FriendsPrimaryKey[0]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(user.FriendsPrimaryKey[1])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(u.ID).Both(user.FriendsLabel) @@ -1242,19 +1335,17 @@ func (c *UserClient) QueryFollowers(u *User) *UserQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := u.id() - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.FollowersTable) - t4 := builder.Select(t3.C(user.FollowersPrimaryKey[0])). - From(t3). - Join(t2). - On(t3.C(user.FollowersPrimaryKey[1]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(user.FollowersPrimaryKey[0])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(u.ID).InE(user.FollowingLabel).OutV() @@ -1269,19 +1360,17 @@ func (c *UserClient) QueryFollowing(u *User) *UserQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := u.id() - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.FollowingTable) - t4 := builder.Select(t3.C(user.FollowingPrimaryKey[1])). - From(t3). - Join(t2). - On(t3.C(user.FollowingPrimaryKey[0]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(user.FollowingPrimaryKey[1])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(u.ID).OutE(user.FollowingLabel).InV() @@ -1296,9 +1385,17 @@ func (c *UserClient) QueryTeam(u *User) *PetQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := u.id() - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(pet.Table)). - Where(sql.EQ(user.TeamColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(u.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(u.ID).OutE(user.TeamLabel).InV() @@ -1313,9 +1410,17 @@ func (c *UserClient) QuerySpouse(u *User) *UserQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := u.id() - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(user.Table)). - Where(sql.EQ(user.SpouseColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(u.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(u.ID).Both(user.SpouseLabel) @@ -1330,9 +1435,17 @@ func (c *UserClient) QueryChildren(u *User) *UserQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := u.id() - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(user.Table)). - Where(sql.EQ(user.ChildrenColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(u.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(u.ID).InE(user.ParentLabel).OutV() @@ -1347,12 +1460,17 @@ func (c *UserClient) QueryParent(u *User) *UserQuery { switch c.driver.Dialect() { case dialect.MySQL, dialect.Postgres, dialect.SQLite: id := u.id() - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Select(user.ParentColumn). - From(builder.Table(user.ParentTable)). - Where(sql.EQ(user.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(user.FieldID), t2.C(user.ParentColumn)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(u.driver.Dialect(), step) case dialect.Gremlin: query.gremlin = g.V(u.ID).OutE(user.ParentLabel).InV() diff --git a/entc/integration/idtype/ent/client.go b/entc/integration/idtype/ent/client.go index 451ec1284..625a6da1b 100644 --- a/entc/integration/idtype/ent/client.go +++ b/entc/integration/idtype/ent/client.go @@ -164,9 +164,17 @@ func (c *UserClient) GetX(ctx context.Context, id uint64) *User { func (c *UserClient) QuerySpouse(u *User) *UserQuery { query := &UserQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(user.Table)). - Where(sql.EQ(user.SpouseColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } @@ -175,19 +183,17 @@ func (c *UserClient) QuerySpouse(u *User) *UserQuery { func (c *UserClient) QueryFollowers(u *User) *UserQuery { query := &UserQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.FollowersTable) - t4 := builder.Select(t3.C(user.FollowersPrimaryKey[0])). - From(t3). - Join(t2). - On(t3.C(user.FollowersPrimaryKey[1]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(user.FollowersPrimaryKey[0])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } @@ -196,19 +202,17 @@ func (c *UserClient) QueryFollowers(u *User) *UserQuery { func (c *UserClient) QueryFollowing(u *User) *UserQuery { query := &UserQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.FollowingTable) - t4 := builder.Select(t3.C(user.FollowingPrimaryKey[1])). - From(t3). - Join(t2). - On(t3.C(user.FollowingPrimaryKey[0]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(user.FollowingPrimaryKey[1])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } diff --git a/entc/integration/template/ent/client.go b/entc/integration/template/ent/client.go index b99388f2b..eb2fed904 100644 --- a/entc/integration/template/ent/client.go +++ b/entc/integration/template/ent/client.go @@ -240,12 +240,17 @@ func (c *PetClient) GetX(ctx context.Context, id int) *Pet { func (c *PetClient) QueryOwner(pe *Pet) *UserQuery { query := &UserQuery{config: c.config} id := pe.ID - builder := sql.Dialect(pe.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Select(pet.OwnerColumn). - From(builder.Table(pet.OwnerTable)). - Where(sql.EQ(pet.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(user.FieldID), t2.C(pet.OwnerColumn)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(pe.driver.Dialect(), step) return query } @@ -318,9 +323,17 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { func (c *UserClient) QueryPets(u *User) *PetQuery { query := &PetQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(pet.Table)). - Where(sql.EQ(user.PetsColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } @@ -329,19 +342,17 @@ func (c *UserClient) QueryPets(u *User) *PetQuery { func (c *UserClient) QueryFriends(u *User) *UserQuery { query := &UserQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.FriendsTable) - t4 := builder.Select(t3.C(user.FriendsPrimaryKey[1])). - From(t3). - Join(t2). - On(t3.C(user.FriendsPrimaryKey[0]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(user.FriendsPrimaryKey[1])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } diff --git a/examples/edgeindex/ent/client.go b/examples/edgeindex/ent/client.go index 38bb6da45..1bdfd7d2f 100644 --- a/examples/edgeindex/ent/client.go +++ b/examples/edgeindex/ent/client.go @@ -170,9 +170,17 @@ func (c *CityClient) GetX(ctx context.Context, id int) *City { func (c *CityClient) QueryStreets(ci *City) *StreetQuery { query := &StreetQuery{config: c.config} id := ci.ID - builder := sql.Dialect(ci.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(street.Table)). - Where(sql.EQ(city.StreetsColumn, id)) + step := &sql.Step{} + step.From.V = id + step.From.Table = city.Table + step.From.Column = city.FieldID + step.To.Table = street.Table + step.To.Column = street.FieldID + step.Edge.Rel = sql.O2M + step.Edge.Inverse = false + step.Edge.Table = city.StreetsTable + step.Edge.Columns = append(step.Edge.Columns, city.StreetsColumn) + query.sql = sql.Neighbors(ci.driver.Dialect(), step) return query } @@ -245,12 +253,17 @@ func (c *StreetClient) GetX(ctx context.Context, id int) *Street { func (c *StreetClient) QueryCity(s *Street) *CityQuery { query := &CityQuery{config: c.config} id := s.ID - builder := sql.Dialect(s.driver.Dialect()) - t1 := builder.Table(city.Table) - t2 := builder.Select(street.CityColumn). - From(builder.Table(street.CityTable)). - Where(sql.EQ(street.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(city.FieldID), t2.C(street.CityColumn)) + step := &sql.Step{} + step.From.V = id + step.From.Table = street.Table + step.From.Column = street.FieldID + step.To.Table = city.Table + step.To.Column = city.FieldID + step.Edge.Rel = sql.M2O + step.Edge.Inverse = true + step.Edge.Table = street.CityTable + step.Edge.Columns = append(step.Edge.Columns, street.CityColumn) + query.sql = sql.Neighbors(s.driver.Dialect(), step) return query } diff --git a/examples/m2m2types/ent/client.go b/examples/m2m2types/ent/client.go index 24fa0bf51..b00ee8263 100644 --- a/examples/m2m2types/ent/client.go +++ b/examples/m2m2types/ent/client.go @@ -170,19 +170,17 @@ func (c *GroupClient) GetX(ctx context.Context, id int) *Group { func (c *GroupClient) QueryUsers(gr *Group) *UserQuery { query := &UserQuery{config: c.config} id := gr.ID - builder := sql.Dialect(gr.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(group.Table) - t3 := builder.Table(group.UsersTable) - t4 := builder.Select(t3.C(group.UsersPrimaryKey[1])). - From(t3). - Join(t2). - On(t3.C(group.UsersPrimaryKey[0]), t2.C(group.FieldID)). - Where(sql.EQ(t2.C(group.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(group.UsersPrimaryKey[1])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(gr.driver.Dialect(), step) return query } @@ -255,19 +253,17 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { func (c *UserClient) QueryGroups(u *User) *GroupQuery { query := &GroupQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(group.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.GroupsTable) - t4 := builder.Select(t3.C(user.GroupsPrimaryKey[0])). - From(t3). - Join(t2). - On(t3.C(user.GroupsPrimaryKey[1]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(group.FieldID), t4.C(user.GroupsPrimaryKey[0])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } diff --git a/examples/m2mbidi/ent/client.go b/examples/m2mbidi/ent/client.go index 066aadad0..088c35ef0 100644 --- a/examples/m2mbidi/ent/client.go +++ b/examples/m2mbidi/ent/client.go @@ -164,19 +164,17 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { func (c *UserClient) QueryFriends(u *User) *UserQuery { query := &UserQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.FriendsTable) - t4 := builder.Select(t3.C(user.FriendsPrimaryKey[1])). - From(t3). - Join(t2). - On(t3.C(user.FriendsPrimaryKey[0]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(user.FriendsPrimaryKey[1])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } diff --git a/examples/m2mrecur/ent/client.go b/examples/m2mrecur/ent/client.go index bd057249d..a6868dbc5 100644 --- a/examples/m2mrecur/ent/client.go +++ b/examples/m2mrecur/ent/client.go @@ -164,19 +164,17 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { func (c *UserClient) QueryFollowers(u *User) *UserQuery { query := &UserQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.FollowersTable) - t4 := builder.Select(t3.C(user.FollowersPrimaryKey[0])). - From(t3). - Join(t2). - On(t3.C(user.FollowersPrimaryKey[1]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(user.FollowersPrimaryKey[0])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } @@ -185,19 +183,17 @@ func (c *UserClient) QueryFollowers(u *User) *UserQuery { func (c *UserClient) QueryFollowing(u *User) *UserQuery { query := &UserQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.FollowingTable) - t4 := builder.Select(t3.C(user.FollowingPrimaryKey[1])). - From(t3). - Join(t2). - On(t3.C(user.FollowingPrimaryKey[0]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(user.FollowingPrimaryKey[1])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } diff --git a/examples/o2m2types/ent/client.go b/examples/o2m2types/ent/client.go index 577cb32ec..781049886 100644 --- a/examples/o2m2types/ent/client.go +++ b/examples/o2m2types/ent/client.go @@ -170,12 +170,17 @@ func (c *PetClient) GetX(ctx context.Context, id int) *Pet { func (c *PetClient) QueryOwner(pe *Pet) *UserQuery { query := &UserQuery{config: c.config} id := pe.ID - builder := sql.Dialect(pe.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Select(pet.OwnerColumn). - From(builder.Table(pet.OwnerTable)). - Where(sql.EQ(pet.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(user.FieldID), t2.C(pet.OwnerColumn)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(pe.driver.Dialect(), step) return query } @@ -248,9 +253,17 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { func (c *UserClient) QueryPets(u *User) *PetQuery { query := &PetQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(pet.Table)). - Where(sql.EQ(user.PetsColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } diff --git a/examples/o2mrecur/ent/client.go b/examples/o2mrecur/ent/client.go index 949a1b7c3..c98f444d2 100644 --- a/examples/o2mrecur/ent/client.go +++ b/examples/o2mrecur/ent/client.go @@ -164,12 +164,17 @@ func (c *NodeClient) GetX(ctx context.Context, id int) *Node { func (c *NodeClient) QueryParent(n *Node) *NodeQuery { query := &NodeQuery{config: c.config} id := n.ID - builder := sql.Dialect(n.driver.Dialect()) - t1 := builder.Table(node.Table) - t2 := builder.Select(node.ParentColumn). - From(builder.Table(node.ParentTable)). - Where(sql.EQ(node.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(node.FieldID), t2.C(node.ParentColumn)) + step := &sql.Step{} + step.From.V = id + step.From.Table = node.Table + step.From.Column = node.FieldID + step.To.Table = node.Table + step.To.Column = node.FieldID + step.Edge.Rel = sql.M2O + step.Edge.Inverse = true + step.Edge.Table = node.ParentTable + step.Edge.Columns = append(step.Edge.Columns, node.ParentColumn) + query.sql = sql.Neighbors(n.driver.Dialect(), step) return query } @@ -178,9 +183,17 @@ func (c *NodeClient) QueryParent(n *Node) *NodeQuery { func (c *NodeClient) QueryChildren(n *Node) *NodeQuery { query := &NodeQuery{config: c.config} id := n.ID - builder := sql.Dialect(n.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(node.Table)). - Where(sql.EQ(node.ChildrenColumn, id)) + step := &sql.Step{} + step.From.V = id + step.From.Table = node.Table + step.From.Column = node.FieldID + step.To.Table = node.Table + step.To.Column = node.FieldID + step.Edge.Rel = sql.O2M + step.Edge.Inverse = false + step.Edge.Table = node.ChildrenTable + step.Edge.Columns = append(step.Edge.Columns, node.ChildrenColumn) + query.sql = sql.Neighbors(n.driver.Dialect(), step) return query } diff --git a/examples/o2o2types/ent/client.go b/examples/o2o2types/ent/client.go index e414e5bc5..ba900baa6 100644 --- a/examples/o2o2types/ent/client.go +++ b/examples/o2o2types/ent/client.go @@ -170,12 +170,17 @@ func (c *CardClient) GetX(ctx context.Context, id int) *Card { func (c *CardClient) QueryOwner(ca *Card) *UserQuery { query := &UserQuery{config: c.config} id := ca.ID - builder := sql.Dialect(ca.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Select(card.OwnerColumn). - From(builder.Table(card.OwnerTable)). - Where(sql.EQ(card.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(user.FieldID), t2.C(card.OwnerColumn)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(ca.driver.Dialect(), step) return query } @@ -248,9 +253,17 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { func (c *UserClient) QueryCard(u *User) *CardQuery { query := &CardQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(card.Table)). - Where(sql.EQ(user.CardColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } diff --git a/examples/o2obidi/ent/client.go b/examples/o2obidi/ent/client.go index 00c82c0d6..1f5f60d2d 100644 --- a/examples/o2obidi/ent/client.go +++ b/examples/o2obidi/ent/client.go @@ -164,9 +164,17 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { func (c *UserClient) QuerySpouse(u *User) *UserQuery { query := &UserQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(user.Table)). - Where(sql.EQ(user.SpouseColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } diff --git a/examples/o2orecur/ent/client.go b/examples/o2orecur/ent/client.go index 96733e291..bb26ebfd9 100644 --- a/examples/o2orecur/ent/client.go +++ b/examples/o2orecur/ent/client.go @@ -164,12 +164,17 @@ func (c *NodeClient) GetX(ctx context.Context, id int) *Node { func (c *NodeClient) QueryPrev(n *Node) *NodeQuery { query := &NodeQuery{config: c.config} id := n.ID - builder := sql.Dialect(n.driver.Dialect()) - t1 := builder.Table(node.Table) - t2 := builder.Select(node.PrevColumn). - From(builder.Table(node.PrevTable)). - Where(sql.EQ(node.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(node.FieldID), t2.C(node.PrevColumn)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(n.driver.Dialect(), step) return query } @@ -178,9 +183,17 @@ func (c *NodeClient) QueryPrev(n *Node) *NodeQuery { func (c *NodeClient) QueryNext(n *Node) *NodeQuery { query := &NodeQuery{config: c.config} id := n.ID - builder := sql.Dialect(n.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(node.Table)). - Where(sql.EQ(node.NextColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(n.driver.Dialect(), step) return query } diff --git a/examples/start/ent/client.go b/examples/start/ent/client.go index 29c8eafbc..a3bb0f084 100644 --- a/examples/start/ent/client.go +++ b/examples/start/ent/client.go @@ -176,12 +176,17 @@ func (c *CarClient) GetX(ctx context.Context, id int) *Car { func (c *CarClient) QueryOwner(ca *Car) *UserQuery { query := &UserQuery{config: c.config} id := ca.ID - builder := sql.Dialect(ca.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Select(car.OwnerColumn). - From(builder.Table(car.OwnerTable)). - Where(sql.EQ(car.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(user.FieldID), t2.C(car.OwnerColumn)) + step := &sql.Step{} + step.From.V = id + step.From.Table = car.Table + step.From.Column = car.FieldID + step.To.Table = user.Table + step.To.Column = user.FieldID + step.Edge.Rel = sql.M2O + step.Edge.Inverse = true + step.Edge.Table = car.OwnerTable + step.Edge.Columns = append(step.Edge.Columns, car.OwnerColumn) + query.sql = sql.Neighbors(ca.driver.Dialect(), step) return query } @@ -254,19 +259,17 @@ func (c *GroupClient) GetX(ctx context.Context, id int) *Group { func (c *GroupClient) QueryUsers(gr *Group) *UserQuery { query := &UserQuery{config: c.config} id := gr.ID - builder := sql.Dialect(gr.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(group.Table) - t3 := builder.Table(group.UsersTable) - t4 := builder.Select(t3.C(group.UsersPrimaryKey[1])). - From(t3). - Join(t2). - On(t3.C(group.UsersPrimaryKey[0]), t2.C(group.FieldID)). - Where(sql.EQ(t2.C(group.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(group.UsersPrimaryKey[1])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(gr.driver.Dialect(), step) return query } @@ -339,9 +342,17 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { func (c *UserClient) QueryCars(u *User) *CarQuery { query := &CarQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(car.Table)). - Where(sql.EQ(user.CarsColumn, id)) + step := &sql.Step{} + step.From.V = id + step.From.Table = user.Table + step.From.Column = user.FieldID + step.To.Table = car.Table + step.To.Column = car.FieldID + step.Edge.Rel = sql.O2M + step.Edge.Inverse = false + step.Edge.Table = user.CarsTable + step.Edge.Columns = append(step.Edge.Columns, user.CarsColumn) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } @@ -350,19 +361,17 @@ func (c *UserClient) QueryCars(u *User) *CarQuery { func (c *UserClient) QueryGroups(u *User) *GroupQuery { query := &GroupQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(group.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.GroupsTable) - t4 := builder.Select(t3.C(user.GroupsPrimaryKey[0])). - From(t3). - Join(t2). - On(t3.C(user.GroupsPrimaryKey[1]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(group.FieldID), t4.C(user.GroupsPrimaryKey[0])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } diff --git a/examples/traversal/ent/client.go b/examples/traversal/ent/client.go index ca14777b5..854b36a21 100644 --- a/examples/traversal/ent/client.go +++ b/examples/traversal/ent/client.go @@ -176,19 +176,17 @@ func (c *GroupClient) GetX(ctx context.Context, id int) *Group { func (c *GroupClient) QueryUsers(gr *Group) *UserQuery { query := &UserQuery{config: c.config} id := gr.ID - builder := sql.Dialect(gr.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(group.Table) - t3 := builder.Table(group.UsersTable) - t4 := builder.Select(t3.C(group.UsersPrimaryKey[1])). - From(t3). - Join(t2). - On(t3.C(group.UsersPrimaryKey[0]), t2.C(group.FieldID)). - Where(sql.EQ(t2.C(group.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(group.UsersPrimaryKey[1])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(gr.driver.Dialect(), step) return query } @@ -197,12 +195,17 @@ func (c *GroupClient) QueryUsers(gr *Group) *UserQuery { func (c *GroupClient) QueryAdmin(gr *Group) *UserQuery { query := &UserQuery{config: c.config} id := gr.ID - builder := sql.Dialect(gr.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Select(group.AdminColumn). - From(builder.Table(group.AdminTable)). - Where(sql.EQ(group.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(user.FieldID), t2.C(group.AdminColumn)) + step := &sql.Step{} + step.From.V = id + step.From.Table = group.Table + step.From.Column = group.FieldID + step.To.Table = user.Table + step.To.Column = user.FieldID + step.Edge.Rel = sql.M2O + step.Edge.Inverse = false + step.Edge.Table = group.AdminTable + step.Edge.Columns = append(step.Edge.Columns, group.AdminColumn) + query.sql = sql.Neighbors(gr.driver.Dialect(), step) return query } @@ -275,19 +278,17 @@ func (c *PetClient) GetX(ctx context.Context, id int) *Pet { func (c *PetClient) QueryFriends(pe *Pet) *PetQuery { query := &PetQuery{config: c.config} id := pe.ID - builder := sql.Dialect(pe.driver.Dialect()) - t1 := builder.Table(pet.Table) - t2 := builder.Table(pet.Table) - t3 := builder.Table(pet.FriendsTable) - t4 := builder.Select(t3.C(pet.FriendsPrimaryKey[1])). - From(t3). - Join(t2). - On(t3.C(pet.FriendsPrimaryKey[0]), t2.C(pet.FieldID)). - Where(sql.EQ(t2.C(pet.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(pet.FieldID), t4.C(pet.FriendsPrimaryKey[1])) + step := &sql.Step{} + step.From.V = id + step.From.Table = pet.Table + step.From.Column = pet.FieldID + step.To.Table = pet.Table + step.To.Column = pet.FieldID + step.Edge.Rel = sql.M2M + step.Edge.Inverse = false + step.Edge.Table = pet.FriendsTable + step.Edge.Columns = append(step.Edge.Columns, pet.FriendsPrimaryKey...) + query.sql = sql.Neighbors(pe.driver.Dialect(), step) return query } @@ -296,12 +297,17 @@ func (c *PetClient) QueryFriends(pe *Pet) *PetQuery { func (c *PetClient) QueryOwner(pe *Pet) *UserQuery { query := &UserQuery{config: c.config} id := pe.ID - builder := sql.Dialect(pe.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Select(pet.OwnerColumn). - From(builder.Table(pet.OwnerTable)). - Where(sql.EQ(pet.FieldID, id)) - query.sql = builder.Select().From(t1).Join(t2).On(t1.C(user.FieldID), t2.C(pet.OwnerColumn)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(pe.driver.Dialect(), step) return query } @@ -374,9 +380,17 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { func (c *UserClient) QueryPets(u *User) *PetQuery { query := &PetQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(pet.Table)). - Where(sql.EQ(user.PetsColumn, id)) + step := &sql.Step{} + step.From.V = id + 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) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } @@ -385,19 +399,17 @@ func (c *UserClient) QueryPets(u *User) *PetQuery { func (c *UserClient) QueryFriends(u *User) *UserQuery { query := &UserQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(user.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.FriendsTable) - t4 := builder.Select(t3.C(user.FriendsPrimaryKey[1])). - From(t3). - Join(t2). - On(t3.C(user.FriendsPrimaryKey[0]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(user.FieldID), t4.C(user.FriendsPrimaryKey[1])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } @@ -406,19 +418,17 @@ func (c *UserClient) QueryFriends(u *User) *UserQuery { func (c *UserClient) QueryGroups(u *User) *GroupQuery { query := &GroupQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - t1 := builder.Table(group.Table) - t2 := builder.Table(user.Table) - t3 := builder.Table(user.GroupsTable) - t4 := builder.Select(t3.C(user.GroupsPrimaryKey[0])). - From(t3). - Join(t2). - On(t3.C(user.GroupsPrimaryKey[1]), t2.C(user.FieldID)). - Where(sql.EQ(t2.C(user.FieldID), id)) - query.sql = builder.Select(). - From(t1). - Join(t4). - On(t1.C(group.FieldID), t4.C(user.GroupsPrimaryKey[0])) + step := &sql.Step{} + step.From.V = id + 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...) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query } @@ -427,9 +437,17 @@ func (c *UserClient) QueryGroups(u *User) *GroupQuery { func (c *UserClient) QueryManage(u *User) *GroupQuery { query := &GroupQuery{config: c.config} id := u.ID - builder := sql.Dialect(u.driver.Dialect()) - query.sql = builder.Select().From(builder.Table(group.Table)). - Where(sql.EQ(user.ManageColumn, id)) + step := &sql.Step{} + step.From.V = id + step.From.Table = user.Table + step.From.Column = user.FieldID + step.To.Table = group.Table + step.To.Column = group.FieldID + step.Edge.Rel = sql.O2M + step.Edge.Inverse = true + step.Edge.Table = user.ManageTable + step.Edge.Columns = append(step.Edge.Columns, user.ManageColumn) + query.sql = sql.Neighbors(u.driver.Dialect(), step) return query }