Method evalEdge

dialect/sql/sqlgraph/entql.go:243–294

evalEdge evaluates has-edge and has-edge-with calls.

(name string, exprs ...entql.Expr)

// evalEdge evaluates has-edge and has-edge-with calls.
func (e *state) evalEdge(name string, exprs ...entql.Expr) *sql.Predicate {
	edge, ok := e.context.Edges[name]
	expect(ok, "edge %q was not found for node %q", name, e.context.Type)
	var fromC, toC string
	switch {
	case edge.To.ID != nil:
		toC = edge.To.ID.Column
	// Edge-owner points to its edge schema.
	case edge.To.CompositeID != nil && !edge.Spec.Inverse:
		toC = edge.To.CompositeID[0].Column
	// Edge-backref points to its edge schema.
	case edge.To.CompositeID != nil && edge.Spec.Inverse:
		toC = edge.To.CompositeID[1].Column
	default:
		panic(evalError{fmt.Sprintf("expect id definition for edge %q", name)})
	}
	switch {
	case e.context.ID != nil:
		fromC = e.context.ID.Column
	case e.context.CompositeID != nil && (edge.Spec.Rel == M2O || (edge.Spec.Rel == O2O && edge.Spec.Inverse)):
		// An edge-schema with a composite id can query
		// only edges that it owns (holds the foreign-key).
	default:
		panic(evalError{fmt.Sprintf("unexpected edge-query from an edge-schema %q", e.context.Type)})
	}
	step := NewStep(
		From(e.context.Table, fromC),
		To(edge.To.Table, toC),
		Edge(edge.Spec.Rel, edge.Spec.Inverse, edge.Spec.Table, edge.Spec.Columns...),
	)
	selector := e.selector.Clone().SetP(nil)
	selector.SetTotal(e.Total())
	if len(exprs) == 0 {
		HasNeighbors(selector, step)
		return selector.P()
	}
	HasNeighborsWith(selector, step, func(s *sql.Selector) {
		for _, expr := range exprs {
			if cx, ok := expr.(*entql.CallExpr); ok && cx.Func == FuncSelector {
				expect(len(cx.Args) == 1, "invalid number of arguments for %s", FuncSelector)
				wrapped, ok := cx.Args[0].(wrappedFunc)
				expect(ok, "invalid argument for %s: %T", FuncSelector, cx.Args[0])
				wrapped.Func(s)
			} else {
				p, err := evalExpr(edge.To, s, expr)
				expect(err == nil, "edge evaluation failed for %s->%s: %s", e.context.Type, name, err)
				s.Where(p)
			}
		}
	})
	return selector.P()
}

func (e *state) field(f *entql.Field) string {
	_, ok := e.context.Fields[f.Name]