golang/ent
1
0
Fork 0
mirror of https://github.com/ent/ent.git synced 2026-05-22 09:31:45 +03:00
Code Issues Packages Projects Releases Wiki Activity

dialect/sqlgraph: add builder with functional options for neighbors steps

Browse Source 
Summary: Pull Request resolved: https://github.com/facebookincubator/ent/pull/199

Reviewed By: alexsn

Differential Revision: D18707950

fbshipit-source-id: 77e5308dc4f984306c131d8541cbbd60d82a1488
This commit is contained in:
Ariel Mashraki
2019-11-26 12:22:08 -08:00
committed by Facebook Github Bot
parent 413bbad8d8
commit 6fe565f059
2 changed files with 185 additions and 319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
dialect/sql/graph.go
View File

@@ -67,6 +67,54 @@ type Step struct {
}
}
// StepOption allows configuring Steps using functional options.
type StepOption func(*Step)
// From sets the source of the step.
func From(table, column string, v ...interface{}) StepOption {
return func(s *Step) {
s.From.Table = table
s.From.Column = column
if len(v) > 0 {
s.From.V = v[0]
}
}
}
// To sets the destination of the step.
func To(table, column string) StepOption {
return func(s *Step) {
s.To.Table = table
s.To.Column = column
}
}
// Edge sets the edge info for getting the neighbors.
func Edge(rel Rel, inverse bool, table string, columns ...string) StepOption {
return func(s *Step) {
s.Edge.Rel = rel
s.Edge.Table = table
s.Edge.Columns = columns
s.Edge.Inverse = inverse
}
}
// NewStep gets list of options and returns a configured step.
//
// NewStep(
// From("table", "pk", V),
// To("table", "pk"),
// Edge("name", O2M, "fk"),
// )
//
func NewStep(opts ...StepOption) *Step {
s := &Step{}
for _, opt := range opts {
opt(s)
}
return s
}
// Neighbors returns a Selector for evaluating the path-step
// and getting the neighbors of one vertex.
func Neighbors(dialect string, s *Step) (q *Selector) {

456
dialect/sql/graph_test.go
View File

@@ -20,178 +20,103 @@ func TestNeighbors(t *testing.T) {
}{
{
name: "O2O/1type",
input: func() *Step {
step := &Step{}
// Since the relation is on the same table,
// V used as a reference value.
step.From.V = 1
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "users"
step.To.Column = "id"
step.Edge.Rel = O2O
step.Edge.Table = "users"
step.Edge.Columns = []string{"spouse_id"}
return step
}(),
// Since the relation is on the same table,
// V used as a reference value.
input: NewStep(
From("users", "id", 1),
To("users", "id"),
Edge(O2O, false, "users", "spouse_id"),
),
wantQuery: "SELECT * FROM `users` WHERE `spouse_id` = ?",
wantArgs: []interface{}{1},
},
{
name: "O2O/1type/inverse",
input: func() *Step {
step := &Step{}
step.From.V = 1
step.From.Table = "nodes"
step.From.Column = "id"
step.To.Table = "nodes"
step.To.Column = "id"
step.Edge.Rel = O2O
step.Edge.Table = "nodes"
step.Edge.Inverse = true
step.Edge.Columns = []string{"prev_id"}
return step
}(),
input: NewStep(
From("nodes", "id", 1),
To("nodes", "id"),
Edge(O2O, true, "nodes", "prev_id"),
),
wantQuery: "SELECT * FROM `nodes` JOIN (SELECT `prev_id` FROM `nodes` WHERE `id` = ?) AS `t1` ON `nodes`.`id` = `t1`.`prev_id`",
wantArgs: []interface{}{1},
},
{
name: "O2M/1type",
input: func() *Step {
step := &Step{}
step.From.V = 1
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "users"
step.To.Column = "id"
step.Edge.Rel = O2M
step.Edge.Table = "users"
step.Edge.Columns = []string{"parent_id"}
return step
}(),
input: NewStep(
From("users", "id", 1),
To("users", "id"),
Edge(O2M, false, "users", "parent_id"),
),
wantQuery: "SELECT * FROM `users` WHERE `parent_id` = ?",
wantArgs: []interface{}{1},
},
{
name: "O2O/2types",
input: func() *Step {
step := &Step{}
step.From.V = 2
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "card"
step.To.Column = "id"
step.Edge.Rel = O2O
step.Edge.Table = "cards"
step.Edge.Columns = []string{"owner_id"}
return step
}(),
input: NewStep(
From("users", "id", 2),
To("card", "id"),
Edge(O2O, false, "cards", "owner_id"),
),
wantQuery: "SELECT * FROM `card` WHERE `owner_id` = ?",
wantArgs: []interface{}{2},
},
{
name: "O2O/2types/inverse",
input: func() *Step {
step := &Step{}
step.From.V = 2
step.From.Table = "card"
step.From.Column = "id"
step.To.Table = "users"
step.To.Column = "id"
step.Edge.Rel = O2O
step.Edge.Table = "cards"
step.Edge.Inverse = true
step.Edge.Columns = []string{"owner_id"}
return step
}(),
input: NewStep(
From("cards", "id", 2),
To("users", "id"),
Edge(O2O, true, "cards", "owner_id"),
),
wantQuery: "SELECT * FROM `users` JOIN (SELECT `owner_id` FROM `cards` WHERE `id` = ?) AS `t1` ON `users`.`id` = `t1`.`owner_id`",
wantArgs: []interface{}{2},
},
{
name: "O2M/2types",
input: func() *Step {
step := &Step{}
step.From.V = 1
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "pets"
step.To.Column = "id"
step.Edge.Rel = O2M
step.Edge.Table = "pets"
step.Edge.Columns = []string{"owner_id"}
return step
}(),
input: NewStep(
From("users", "id", 1),
To("pets", "id"),
Edge(O2M, false, "pets", "owner_id"),
),
wantQuery: "SELECT * FROM `pets` WHERE `owner_id` = ?",
wantArgs: []interface{}{1},
},
{
name: "M2O/2types/inverse",
input: func() *Step {
step := &Step{}
step.From.V = 2
step.From.Table = "pets"
step.From.Column = "id"
step.To.Table = "users"
step.To.Column = "id"
step.Edge.Rel = M2O
step.Edge.Inverse = true
step.Edge.Table = "pets"
step.Edge.Columns = []string{"owner_id"}
return step
}(),
input: NewStep(
From("pets", "id", 2),
To("users", "id"),
Edge(M2O, true, "pets", "owner_id"),
),
wantQuery: "SELECT * FROM `users` JOIN (SELECT `owner_id` FROM `pets` WHERE `id` = ?) AS `t1` ON `users`.`id` = `t1`.`owner_id`",
wantArgs: []interface{}{2},
},
{
name: "M2O/1type/inverse",
input: func() *Step {
step := &Step{}
step.From.V = 2
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "users"
step.To.Column = "id"
step.Edge.Rel = M2O
step.Edge.Inverse = true
step.Edge.Table = "users"
step.Edge.Columns = []string{"parent_id"}
return step
}(),
input: NewStep(
From("users", "id", 2),
To("users", "id"),
Edge(M2O, true, "users", "parent_id"),
),
wantQuery: "SELECT * FROM `users` JOIN (SELECT `parent_id` FROM `users` WHERE `id` = ?) AS `t1` ON `users`.`id` = `t1`.`parent_id`",
wantArgs: []interface{}{2},
},
{
name: "M2M/2type",
input: func() *Step {
step := &Step{}
step.From.V = 2
step.From.Table = "groups"
step.From.Column = "id"
step.To.Table = "users"
step.To.Column = "id"
step.Edge.Rel = M2M
step.Edge.Table = "user_groups"
step.Edge.Columns = []string{"group_id", "user_id"}
return step
}(),
input: NewStep(
From("groups", "id", 2),
To("users", "id"),
Edge(M2M, false, "user_groups", "group_id", "user_id"),
),
wantQuery: "SELECT * FROM `users` JOIN (SELECT `user_groups`.`user_id` FROM `user_groups` WHERE `user_groups`.`group_id` = ?) AS `t1` ON `users`.`id` = `t1`.`user_id`",
wantArgs: []interface{}{2},
},
{
name: "M2M/2type/inverse",
input: func() *Step {
step := &Step{}
step.From.V = 2
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "groups"
step.To.Column = "id"
step.Edge.Rel = M2M
step.Edge.Inverse = true
step.Edge.Table = "user_groups"
step.Edge.Columns = []string{"group_id", "user_id"}
return step
}(),
input: NewStep(
From("users", "id", 2),
To("groups", "id"),
Edge(M2M, true, "user_groups", "group_id", "user_id"),
),
wantQuery: "SELECT * FROM `groups` JOIN (SELECT `user_groups`.`group_id` FROM `user_groups` WHERE `user_groups`.`user_id` = ?) AS `t1` ON `groups`.`id` = `t1`.`group_id`",
wantArgs: []interface{}{2},
},
@@ -215,52 +140,31 @@ func TestSetNeighbors(t *testing.T) {
}{
{
name: "O2M/2types",
input: func() *Step {
step := &Step{}
step.From.V = Select().From(Table("users")).Where(EQ("name", "a8m"))
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "pets"
step.To.Column = "id"
step.Edge.Rel = O2M
step.Edge.Table = "pets"
step.Edge.Columns = []string{"owner_id"}
return step
}(),
input: NewStep(
From("users", "id", Select().From(Table("users")).Where(EQ("name", "a8m"))),
To("pets", "id"),
Edge(O2M, false, "users", "owner_id"),
),
wantQuery: `SELECT * FROM "pets" JOIN (SELECT "users"."id" FROM "users" WHERE "name" = $1) AS "t1" ON "pets"."owner_id" = "t1"."id"`,
wantArgs: []interface{}{"a8m"},
},
{
name: "M2O/2types",
input: func() *Step {
step := &Step{}
step.From.V = Select().From(Table("pets")).Where(EQ("name", "pedro"))
step.From.Table = "pets"
step.From.Column = "id"
step.To.Table = "users"
step.To.Column = "id"
step.Edge.Rel = M2O
step.Edge.Table = "pets"
step.Edge.Columns = []string{"owner_id"}
return step
}(),
input: NewStep(
From("pets", "id", Select().From(Table("pets")).Where(EQ("name", "pedro"))),
To("users", "id"),
Edge(M2O, true, "pets", "owner_id"),
),
wantQuery: `SELECT * FROM "users" JOIN (SELECT "pets"."owner_id" FROM "pets" WHERE "name" = $1) AS "t1" ON "users"."id" = "t1"."owner_id"`,
wantArgs: []interface{}{"pedro"},
},
{
name: "M2M/2types",
input: func() *Step {
step := &Step{}
step.From.V = Select().From(Table("users")).Where(EQ("name", "a8m"))
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "groups"
step.To.Column = "id"
step.Edge.Rel = M2M
step.Edge.Table = "user_groups"
step.Edge.Columns = []string{"user_id", "group_id"}
return step
}(),
input: NewStep(
From("users", "id", Select().From(Table("users")).Where(EQ("name", "a8m"))),
To("groups", "id"),
Edge(M2M, false, "user_groups", "user_id", "group_id"),
),
wantQuery: `
SELECT *
FROM "groups"
@@ -275,19 +179,11 @@ JOIN
},
{
name: "M2M/2types/inverse",
input: func() *Step {
step := &Step{}
step.From.V = Select().From(Table("groups")).Where(EQ("name", "GitHub"))
step.From.Table = "groups"
step.From.Column = "id"
step.To.Table = "users"
step.To.Column = "id"
step.Edge.Rel = M2M
step.Edge.Inverse = true
step.Edge.Table = "user_groups"
step.Edge.Columns = []string{"user_id", "group_id"}
return step
}(),
input: NewStep(
From("groups", "id", Select().From(Table("groups")).Where(EQ("name", "GitHub"))),
To("users", "id"),
Edge(M2M, true, "user_groups", "user_id", "group_id"),
),
wantQuery: `
SELECT *
FROM "users"
@@ -321,105 +217,66 @@ func TestHasNeighbors(t *testing.T) {
}{
{
name: "O2O/1type",
step: func() *Step {
// A nodes table; linked-list (next->prev). The "prev"
// node holds association pointer. The neighbors query
// here checks if a node "has-next".
step := &Step{}
step.From.Table = "nodes"
step.From.Column = "id"
step.To.Table = "nodes"
step.To.Column = "id"
step.Edge.Rel = O2O
step.Edge.Table = "nodes"
step.Edge.Columns = []string{"prev_id"}
return step
}(),
// A nodes table; linked-list (next->prev). The "prev"
// node holds association pointer. The neighbors query
// here checks if a node "has-next".
step: NewStep(
From("nodes", "id"),
To("nodes", "id"),
Edge(O2O, false, "nodes", "prev_id"),
),
selector: Select("*").From(Table("nodes")),
wantQuery: "SELECT * FROM `nodes` WHERE `nodes`.`id` IN (SELECT `nodes`.`prev_id` FROM `nodes` WHERE `nodes`.`prev_id` IS NOT NULL)",
},
{
name: "O2O/1type/inverse",
step: func() *Step {
// Same example as above, but the neighbors
// query checks if a node "has-previous".
step := &Step{}
step.From.Table = "nodes"
step.From.Column = "id"
step.To.Table = "nodes"
step.To.Column = "id"
step.Edge.Rel = O2O
step.Edge.Inverse = true
step.Edge.Table = "nodes"
step.Edge.Columns = []string{"prev_id"}
return step
}(),
// Same example as above, but the neighbors
// query checks if a node "has-previous".
step: NewStep(
From("nodes", "id"),
To("nodes", "id"),
Edge(O2O, true, "nodes", "prev_id"),
),
selector: Select("*").From(Table("nodes")),
wantQuery: "SELECT * FROM `nodes` WHERE `nodes`.`prev_id` IS NOT NULL",
},
{
name: "O2M/2type2",
step: func() *Step {
step := &Step{}
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "pets"
step.To.Column = "id"
step.Edge.Rel = O2M
step.Edge.Table = "pets"
step.Edge.Columns = []string{"owner_id"}
return step
}(),
step: NewStep(
From("users", "id"),
To("pets", "id"),
Edge(O2M, false, "pets", "owner_id"),
),
selector: Select("*").From(Table("users")),
wantQuery: "SELECT * FROM `users` WHERE `users`.`id` IN (SELECT `pets`.`owner_id` FROM `pets` WHERE `pets`.`owner_id` IS NOT NULL)",
},
{
name: "M2O/2type2",
step: func() *Step {
step := &Step{}
step.From.Table = "pets"
step.From.Column = "id"
step.To.Table = "users"
step.To.Column = "id"
step.Edge.Rel = M2O
step.Edge.Inverse = true
step.Edge.Table = "pets"
step.Edge.Columns = []string{"owner_id"}
return step
}(),
step: NewStep(
From("pets", "id"),
To("users", "id"),
Edge(M2O, true, "pets", "owner_id"),
),
selector: Select("*").From(Table("pets")),
wantQuery: "SELECT * FROM `pets` WHERE `pets`.`owner_id` IS NOT NULL",
},
{
name: "M2M/2types",
step: func() *Step {
step := &Step{}
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "groups"
step.To.Column = "id"
step.Edge.Rel = M2M
step.Edge.Table = "user_groups"
step.Edge.Columns = []string{"user_id", "group_id"}
return step
}(),
step: NewStep(
From("users", "id"),
To("groups", "id"),
Edge(M2M, false, "user_groups", "user_id", "group_id"),
),
selector: Select("*").From(Table("users")),
wantQuery: "SELECT * FROM `users` WHERE `users`.`id` IN (SELECT `user_groups`.`user_id` FROM `user_groups`)",
},
{
name: "M2M/2types/inverse",
step: func() *Step {
step := &Step{}
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "groups"
step.To.Column = "id"
step.Edge.Rel = M2M
step.Edge.Inverse = true
step.Edge.Table = "group_users"
step.Edge.Columns = []string{"group_id", "user_id"}
return step
}(),
step: NewStep(
From("users", "id"),
To("groups", "id"),
Edge(M2M, true, "group_users", "group_id", "user_id"),
),
selector: Select("*").From(Table("users")),
wantQuery: "SELECT * FROM `users` WHERE `users`.`id` IN (SELECT `group_users`.`user_id` FROM `group_users`)",
},
@@ -445,17 +302,11 @@ func TestHasNeighborsWith(t *testing.T) {
}{
{
name: "O2O",
step: func() *Step {
step := &Step{}
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "cards"
step.To.Column = "id"
step.Edge.Rel = O2O
step.Edge.Table = "cards"
step.Edge.Columns = []string{"owner_id"}
return step
}(),
step: NewStep(
From("users", "id"),
To("cards", "id"),
Edge(O2O, false, "cards", "owner_id"),
),
selector: Dialect("postgres").Select("*").From(Table("users")),
predicate: func(s *Selector) {
s.Where(EQ("expired", false))
@@ -465,18 +316,11 @@ func TestHasNeighborsWith(t *testing.T) {
},
{
name: "O2O/inverse",
step: func() *Step {
step := &Step{}
step.From.Table = "cards"
step.From.Column = "id"
step.To.Table = "users"
step.To.Column = "id"
step.Edge.Rel = O2O
step.Edge.Table = "cards"
step.Edge.Inverse = true
step.Edge.Columns = []string{"owner_id"}
return step
}(),
step: NewStep(
From("cards", "id"),
To("users", "id"),
Edge(O2O, true, "cards", "owner_id"),
),
selector: Dialect("postgres").Select("*").From(Table("cards")),
predicate: func(s *Selector) {
s.Where(EQ("name", "a8m"))
@@ -486,17 +330,11 @@ func TestHasNeighborsWith(t *testing.T) {
},
{
name: "O2M",
step: func() *Step {
step := &Step{}
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "pets"
step.To.Column = "id"
step.Edge.Rel = O2M
step.Edge.Table = "pets"
step.Edge.Columns = []string{"owner_id"}
return step
}(),
step: NewStep(
From("users", "id"),
To("pets", "id"),
Edge(O2M, false, "pets", "owner_id"),
),
selector: Dialect("postgres").Select("*").
From(Table("users")).
Where(EQ("last_name", "mashraki")),
@@ -508,18 +346,11 @@ func TestHasNeighborsWith(t *testing.T) {
},
{
name: "M2O",
step: func() *Step {
step := &Step{}
step.From.Table = "pets"
step.From.Column = "id"
step.To.Table = "users"
step.To.Column = "id"
step.Edge.Rel = M2O
step.Edge.Table = "pets"
step.Edge.Inverse = true
step.Edge.Columns = []string{"owner_id"}
return step
}(),
step: NewStep(
From("pets", "id"),
To("users", "id"),
Edge(M2O, true, "pets", "owner_id"),
),
selector: Dialect("postgres").Select("*").
From(Table("pets")).
Where(EQ("name", "pedro")),
@@ -531,17 +362,11 @@ func TestHasNeighborsWith(t *testing.T) {
},
{
name: "M2M",
step: func() *Step {
step := &Step{}
step.From.Table = "users"
step.From.Column = "id"
step.To.Table = "groups"
step.To.Column = "id"
step.Edge.Rel = M2M
step.Edge.Table = "user_groups"
step.Edge.Columns = []string{"user_id", "group_id"}
return step
}(),
step: NewStep(
From("users", "id"),
To("groups", "id"),
Edge(M2M, false, "user_groups", "user_id", "group_id"),
),
selector: Dialect("postgres").Select("*").From(Table("users")),
predicate: func(s *Selector) {
s.Where(EQ("name", "GitHub"))
@@ -557,18 +382,11 @@ WHERE "users"."id" IN
},
{
name: "M2M/inverse",
step: func() *Step {
step := &Step{}
step.From.Table = "groups"
step.From.Column = "id"
step.To.Table = "users"
step.To.Column = "id"
step.Edge.Rel = M2M
step.Edge.Table = "user_groups"
step.Edge.Inverse = true
step.Edge.Columns = []string{"user_id", "group_id"}
return step
}(),
step: NewStep(
From("groups", "id"),
To("users", "id"),
Edge(M2M, true, "user_groups", "user_id", "group_id"),
),
selector: Dialect("postgres").Select("*").From(Table("groups")),
predicate: func(s *Selector) {
s.Where(EQ("name", "a8m"))