all: move sqlgraph to its own package

2026-05-28 09:49:08 +03:00 · 2019-12-17 18:22:07 +02:00
parent 58b5389275
commit 0cc74b5297
101 changed files with 4359 additions and 5072 deletions
--- a/examples/o2mrecur/ent/node/where.go
+++ b/examples/o2mrecur/ent/node/where.go
@@ -8,6 +8,7 @@ package node

 import (
 	"github.com/facebookincubator/ent/dialect/sql"
+	"github.com/facebookincubator/ent/dialect/sql/sqlgraph"
 	"github.com/facebookincubator/ent/examples/o2mrecur/ent/predicate"
 )

@@ -22,120 +23,109 @@ func ID(id int) predicate.Node {

 // IDEQ applies the EQ predicate on the ID field.
 func IDEQ(id int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			s.Where(sql.EQ(s.C(FieldID), id))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldID), id))
+	},
 	)
 }

 // IDNEQ applies the NEQ predicate on the ID field.
 func IDNEQ(id int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			s.Where(sql.NEQ(s.C(FieldID), id))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		s.Where(sql.NEQ(s.C(FieldID), id))
+	},
 	)
 }

 // IDIn applies the In predicate on the ID field.
 func IDIn(ids ...int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			// if not arguments were provided, append the FALSE constants,
-			// since we can't apply "IN ()". This will make this predicate falsy.
-			if len(ids) == 0 {
-				s.Where(sql.False())
-				return
-			}
-			v := make([]interface{}, len(ids))
-			for i := range v {
-				v[i] = ids[i]
-			}
-			s.Where(sql.In(s.C(FieldID), v...))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		// if not arguments were provided, append the FALSE constants,
+		// since we can't apply "IN ()". This will make this predicate falsy.
+		if len(ids) == 0 {
+			s.Where(sql.False())
+			return
+		}
+		v := make([]interface{}, len(ids))
+		for i := range v {
+			v[i] = ids[i]
+		}
+		s.Where(sql.In(s.C(FieldID), v...))
+	},
 	)
 }

 // IDNotIn applies the NotIn predicate on the ID field.
 func IDNotIn(ids ...int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			// if not arguments were provided, append the FALSE constants,
-			// since we can't apply "IN ()". This will make this predicate falsy.
-			if len(ids) == 0 {
-				s.Where(sql.False())
-				return
-			}
-			v := make([]interface{}, len(ids))
-			for i := range v {
-				v[i] = ids[i]
-			}
-			s.Where(sql.NotIn(s.C(FieldID), v...))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		// if not arguments were provided, append the FALSE constants,
+		// since we can't apply "IN ()". This will make this predicate falsy.
+		if len(ids) == 0 {
+			s.Where(sql.False())
+			return
+		}
+		v := make([]interface{}, len(ids))
+		for i := range v {
+			v[i] = ids[i]
+		}
+		s.Where(sql.NotIn(s.C(FieldID), v...))
+	},
 	)
 }

 // IDGT applies the GT predicate on the ID field.
 func IDGT(id int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			s.Where(sql.GT(s.C(FieldID), id))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		s.Where(sql.GT(s.C(FieldID), id))
+	},
 	)
 }

 // IDGTE applies the GTE predicate on the ID field.
 func IDGTE(id int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			s.Where(sql.GTE(s.C(FieldID), id))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		s.Where(sql.GTE(s.C(FieldID), id))
+	},
 	)
 }

 // IDLT applies the LT predicate on the ID field.
 func IDLT(id int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			s.Where(sql.LT(s.C(FieldID), id))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		s.Where(sql.LT(s.C(FieldID), id))
+	},
 	)
 }

 // IDLTE applies the LTE predicate on the ID field.
 func IDLTE(id int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			s.Where(sql.LTE(s.C(FieldID), id))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		s.Where(sql.LTE(s.C(FieldID), id))
+	},
 	)
 }

 // Value applies equality check predicate on the "value" field. It's identical to ValueEQ.
 func Value(v int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			s.Where(sql.EQ(s.C(FieldValue), v))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldValue), v))
+	},
 	)
 }

 // ValueEQ applies the EQ predicate on the "value" field.
 func ValueEQ(v int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			s.Where(sql.EQ(s.C(FieldValue), v))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldValue), v))
+	},
 	)
 }

 // ValueNEQ applies the NEQ predicate on the "value" field.
 func ValueNEQ(v int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			s.Where(sql.NEQ(s.C(FieldValue), v))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		s.Where(sql.NEQ(s.C(FieldValue), v))
+	},
 	)
 }

@@ -145,16 +135,15 @@ func ValueIn(vs ...int) predicate.Node {
 	for i := range v {
 		v[i] = vs[i]
 	}
-	return predicate.Node(
-		func(s *sql.Selector) {
-			// if not arguments were provided, append the FALSE constants,
-			// since we can't apply "IN ()". This will make this predicate falsy.
-			if len(vs) == 0 {
-				s.Where(sql.False())
-				return
-			}
-			s.Where(sql.In(s.C(FieldValue), v...))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		// if not arguments were provided, append the FALSE constants,
+		// since we can't apply "IN ()". This will make this predicate falsy.
+		if len(vs) == 0 {
+			s.Where(sql.False())
+			return
+		}
+		s.Where(sql.In(s.C(FieldValue), v...))
+	},
 	)
 }

@@ -164,116 +153,107 @@ func ValueNotIn(vs ...int) predicate.Node {
 	for i := range v {
 		v[i] = vs[i]
 	}
-	return predicate.Node(
-		func(s *sql.Selector) {
-			// if not arguments were provided, append the FALSE constants,
-			// since we can't apply "IN ()". This will make this predicate falsy.
-			if len(vs) == 0 {
-				s.Where(sql.False())
-				return
-			}
-			s.Where(sql.NotIn(s.C(FieldValue), v...))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		// if not arguments were provided, append the FALSE constants,
+		// since we can't apply "IN ()". This will make this predicate falsy.
+		if len(vs) == 0 {
+			s.Where(sql.False())
+			return
+		}
+		s.Where(sql.NotIn(s.C(FieldValue), v...))
+	},
 	)
 }

 // ValueGT applies the GT predicate on the "value" field.
 func ValueGT(v int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			s.Where(sql.GT(s.C(FieldValue), v))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		s.Where(sql.GT(s.C(FieldValue), v))
+	},
 	)
 }

 // ValueGTE applies the GTE predicate on the "value" field.
 func ValueGTE(v int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			s.Where(sql.GTE(s.C(FieldValue), v))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		s.Where(sql.GTE(s.C(FieldValue), v))
+	},
 	)
 }

 // ValueLT applies the LT predicate on the "value" field.
 func ValueLT(v int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			s.Where(sql.LT(s.C(FieldValue), v))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		s.Where(sql.LT(s.C(FieldValue), v))
+	},
 	)
 }

 // ValueLTE applies the LTE predicate on the "value" field.
 func ValueLTE(v int) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			s.Where(sql.LTE(s.C(FieldValue), v))
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		s.Where(sql.LTE(s.C(FieldValue), v))
+	},
 	)
 }

 // HasParent applies the HasEdge predicate on the "parent" edge.
 func HasParent() predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			step := sql.NewStep(
-				sql.From(Table, FieldID),
-				sql.To(ParentTable, FieldID),
-				sql.Edge(sql.M2O, true, ParentTable, ParentColumn),
-			)
-			sql.HasNeighbors(s, step)
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.To(ParentTable, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, ParentTable, ParentColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	},
 	)
 }

 // HasParentWith applies the HasEdge predicate on the "parent" edge with a given conditions (other predicates).
 func HasParentWith(preds ...predicate.Node) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			step := sql.NewStep(
-				sql.From(Table, FieldID),
-				sql.To(Table, FieldID),
-				sql.Edge(sql.M2O, true, ParentTable, ParentColumn),
-			)
-			sql.HasNeighborsWith(s, step, func(s *sql.Selector) {
-				for _, p := range preds {
-					p(s)
-				}
-			})
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.To(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, ParentTable, ParentColumn),
+		)
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	},
 	)
 }

 // HasChildren applies the HasEdge predicate on the "children" edge.
 func HasChildren() predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			step := sql.NewStep(
-				sql.From(Table, FieldID),
-				sql.To(ChildrenTable, FieldID),
-				sql.Edge(sql.O2M, false, ChildrenTable, ChildrenColumn),
-			)
-			sql.HasNeighbors(s, step)
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.To(ChildrenTable, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, ChildrenTable, ChildrenColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	},
 	)
 }

 // HasChildrenWith applies the HasEdge predicate on the "children" edge with a given conditions (other predicates).
 func HasChildrenWith(preds ...predicate.Node) predicate.Node {
-	return predicate.Node(
-		func(s *sql.Selector) {
-			step := sql.NewStep(
-				sql.From(Table, FieldID),
-				sql.To(Table, FieldID),
-				sql.Edge(sql.O2M, false, ChildrenTable, ChildrenColumn),
-			)
-			sql.HasNeighborsWith(s, step, func(s *sql.Selector) {
-				for _, p := range preds {
-					p(s)
-				}
-			})
-		},
+	return predicate.Node(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.To(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, ChildrenTable, ChildrenColumn),
+		)
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	},
 	)
 }