Source File
	desugar.go

Belonging Package
	github.com/pancsta/gochickpeas/gql/gqlparser

// Desugar: query normalization that runs once on the parsed AST before
// binding/planning. This is a verbatim copy of gql/internal/semantics/
// desugar.go (which cannot be imported outside the module) with the local
// aliases substituted for the ast package. Keep in sync with upstream.
//
// Lowers non-literal inline pattern property values: a constant value
// ((t:Tag {name: 'Hot'}), {id: $p}) stays on the fast props seek path, but
// an expression value ((t:Tag {name: tagVar}), {since: a.created}) is
// rewritten to a WHERE var.key = value equality conjunct on the (possibly
// synthesized) node/relationship variable, so pattern matching never
// evaluates an expression inside a pattern.
//
// Idempotent: a second pass finds the PropExprs already drained.
package gqlparser

import (
	"fmt"

	"github.com/pancsta/gochickpeas/gql/internal/ast"
)

// Desugar normalizes q in place. A synthetic-variable counter threads
// through so an anonymous node/relationship carrying a non-literal inline
// property gets a stable name to compare on.
func Desugar(q *Query) error {
	ctr := 0
	return desugarParts(q.Parts, &ctr)
}

func desugarParts(parts []QueryPart, ctr *int) error {
	for i := range parts {
		part := &parts[i]
		for _, clause := range part.Clauses {
			if err := desugarClause(clause, ctr); err != nil {
				return err
			}
		}
		if err := desugarProjection(&part.Ret, ctr); err != nil {
			return err
		}
	}
	return nil
}

func desugarClause(c Clause, ctr *int) error {
	switch n := c.(type) {
	case *Match:
		for i := range n.Patterns {
			if err := lowerPatternProps(&n.Patterns[i], &n.Where, ctr); err != nil {
				return err
			}
		}
		return desugarExpr(n.Where, ctr)
	case *With:
		if err := desugarProjection(&n.Proj, ctr); err != nil {
			return err
		}
		return desugarExpr(n.Where, ctr)
	case *ShortestPath:
		if err := lowerPatternProps(&n.Pattern, &n.Where, ctr); err != nil {
			return err
		}
		if n.Weight != nil && n.Weight.Kind == CostExpr {
			if err := desugarExpr(n.Weight.Expr, ctr); err != nil {
				return err
			}
		}
		return desugarExpr(n.Where, ctr)
	case *PathBind:
		if err := lowerPatternProps(&n.Pattern, &n.Where, ctr); err != nil {
			return err
		}
		return desugarExpr(n.Where, ctr)
	case *CallProc:
		for _, a := range n.Args {
			if err := desugarExpr(a, ctr); err != nil {
				return err
			}
		}
		return nil
	case *Unwind:
		return desugarExpr(n.Expr, ctr)
	case *CallSubquery:
		return desugarParts(n.Query.Parts, ctr)
	}
	return nil
}

func desugarProjection(p *Projection, ctr *int) error {
	for i := range p.Items {
		if err := desugarExpr(p.Items[i].Expr, ctr); err != nil {
			return err
		}
	}
	for i := range p.OrderBy {
		if err := desugarExpr(p.OrderBy[i].Expr, ctr); err != nil {
			return err
		}
	}
	return nil
}

// desugarExpr recurses an expression, lowering inline props inside
// EXISTS {} / COUNT {} / pattern-comprehension subpatterns into the
// subquery's own WHERE.
func desugarExpr(e Expr, ctr *int) error {
	var err error
	ast.Walk(e, func(x ast.Expr) bool {
		switch n := x.(type) {
		case *Exists:
			err = lowerPatternProps(n.Pattern, &n.Where, ctr)
		case *CountSub:
			err = lowerPatternProps(n.Pattern, &n.Where, ctr)
		case *PatternComp:
			err = lowerPatternProps(n.Pattern, &n.Where, ctr)
		}
		return err == nil
	})
	return err
}

// lowerPatternProps lowers every non-literal inline property in pattern to
// an equality conjunct ANDed into where.
func lowerPatternProps(p *Pattern, where *Expr, ctr *int) error {
	lowerNodeProps(&p.Start, where, ctr)
	for i := range p.Hops {
		if err := lowerRelProps(&p.Hops[i].Rel, where, ctr); err != nil {
			return err
		}
		lowerNodeProps(&p.Hops[i].Node, where, ctr)
	}
	return nil
}

func lowerNodeProps(n *NodePat, where *Expr, ctr *int) {
	if n.LabelExpr != nil {
		andInto(where, &HasLabelExpr{Var: ensureVar(&n.Var, ctr), Expr: n.LabelExpr})
		n.LabelExpr = nil
	}
	if n.Where != nil {
		andInto(where, n.Where)
		n.Where = nil
	}
	if len(n.PropExprs) == 0 {
		return
	}
	v := ensureVar(&n.Var, ctr)
	for _, pe := range n.PropExprs {
		andInto(where, eqConj(v, pe.Key, pe.Val))
	}
	n.PropExprs = nil
}

func lowerRelProps(r *RelPat, where *Expr, ctr *int) error {
	if r.Where != nil {
		if r.Length != nil {
			return desugarPlanErrf("an inline predicate on a variable-length relationship is not supported (Tier 1)")
		}
		andInto(where, r.Where)
		r.Where = nil
	}
	if len(r.PropExprs) == 0 {
		return nil
	}
	if r.Length != nil {
		return desugarPlanErrf("a non-literal inline property on a variable-length relationship is not supported (Tier 1)")
	}
	v := ensureVar(&r.Var, ctr)
	for _, pe := range r.PropExprs {
		andInto(where, eqConj(v, pe.Key, pe.Val))
	}
	r.PropExprs = nil
	return nil
}

// ensureVar is the variable a lowered equality compares on: the pattern
// element's own name, or a fresh __ip{n} for an anonymous element.
func ensureVar(slot *string, ctr *int) string {
	if *slot != "" {
		return *slot
	}
	v := fmt.Sprintf("__ip%d", *ctr)
	*ctr++
	*slot = v
	return v
}

func eqConj(v, key string, val Expr) Expr {
	return &Binary{
		Op:  OpEq,
		LHS: &Prop{Var: v, Key: key},
		RHS: val,
	}
}

func andInto(where *Expr, conj Expr) {
	if *where == nil {
		*where = conj
		return
	}
	*where = &Binary{Op: OpAnd, LHS: *where, RHS: conj}
}

// desugarPlanErrf mirrors semantics.planErrf: a planning-restriction error.
func desugarPlanErrf(format string, args ...any) error {
	return fmt.Errorf(format, args...)
}

The pages are generated with Golds v0.8.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.