query

func New ¶

func New[N comparable, W any](g *lpg.Graph[N, W], c *csr.CSR[W]) *Engine[N, W]

New returns an Engine wrapping g and the CSR snapshot c.

func WithLabel ¶

func WithLabel[N comparable, W any](name string) Predicate[N, W]

WithLabel returns a Predicate selecting nodes carrying the given label.

func WithProperty ¶

func WithProperty[N comparable, W any](key string, expected lpg.PropertyValue) Predicate[N, W]

WithProperty returns a Predicate selecting nodes whose named property is EQUAL to the given expected value.

Equality semantics ¶

The relation is openCypher EQUALITY, not comparability and not equivalence:

• INTEGER and FLOAT are one numeric kind, compared EXACTLY. An lpg.Int64Value of 5 is equal to an lpg.Float64Value of 5, and an int64 is never widened to float64, so 4611686018427387905 and 4611686018427387900 stay distinct even though both round to 2^62.
• A NaN expected value is equal to nothing, and nothing is equal to a NaN-valued property — including another NaN. Equality is the relation in which NaN = NaN is FALSE; under equivalence it is true, and that other relation is not what this predicate implements.
• STRING, BOOLEAN, BYTES and TIME are equal within their own kind. Note that openCypher's equatability is WIDER than its comparability, so for these kinds this predicate matches where the degenerate WithRange [v, v] does not: they are equatable but not ordered scalars.
• Every other cross-kind pair is not equal. INTEGER x FLOAT is the sole off-diagonal entry openCypher unifies, so a number is never equal to a string.

Index acceleration ¶

When the owning graph carries an index covering the predicate's (label, property) pair — and the same Pattern.Vertex call also constrains that label — the engine narrows the working set from the index before any property is read. A STRING or BOOLEAN equality is served EXACTLY from a bound hash index of that key type and the per-node comparison is skipped; a NUMERIC equality is served as a SUPERSET from the float64-keyed numeric btree companion and the exact comparison still runs over what the seek left. Either way the answer is identical to the answer the same query returns with no index present (see index_seek.go).

package main

import (
	"fmt"

	"github.com/FlavioCFOliveira/GoGraph/graph/adjlist"
	"github.com/FlavioCFOliveira/GoGraph/graph/csr"
	"github.com/FlavioCFOliveira/GoGraph/graph/lpg"
	"github.com/FlavioCFOliveira/GoGraph/graph/query"
)

// buildSocialGraph returns a tiny labelled property graph and its CSR
// snapshot: two :Person nodes (alice, bob) who both BOUGHT a :Product
// (widget).
func buildSocialGraph() (*lpg.Graph[string, int], *csr.CSR[int]) {
	g := lpg.New[string, int](adjlist.Config{Directed: true})
	for _, p := range []string{"alice", "bob"} {
		_ = g.AddNode(p)
		_ = g.SetNodeLabel(p, "Person")
		_ = g.SetNodeProperty(p, "name", lpg.StringValue(p))
	}
	_ = g.AddNode("widget")
	_ = g.SetNodeLabel("widget", "Product")
	_ = g.AddEdge("alice", "widget", 0)
	_ = g.AddEdge("bob", "widget", 0)
	return g, csr.BuildFromAdjList(g.AdjList())
}

func main() {
	g, snap := buildSocialGraph()
	eng := query.New(g, snap)

	match := eng.Match().Vertex(
		query.WithProperty[string, int]("name", lpg.StringValue("alice")),
	)

	fmt.Println("count:", match.Cardinality())
	fmt.Println("keys:", match.Collect())
}

Output:
count: 1
keys: [alice]

func WithRange ¶ added in v0.6.0

func WithRange[N comparable, W any](key string, lo, hi lpg.PropertyValue) Predicate[N, W]

WithRange returns a Predicate selecting nodes whose named property lies in the inclusive interval [lo, hi].

Comparison semantics ¶

The two bound tests — v >= lo and v <= hi — are INDEPENDENT, exactly as openCypher's comparability rules make them, so lo and hi need not share a kind. A bound test holds only when the two values are comparable AND the relation is true:

• STRING against STRING: byte-wise order.
• INTEGER against INTEGER, FLOAT against FLOAT, and INTEGER against FLOAT: one numeric order, compared EXACTLY. An int64 is never widened to float64, so 4611686018427387905 and 4611686018427387900 stay distinct even though both round to the same float64 (2^62).
• Every other pair — a number against a string, or either side a stored lpg.PropBool, lpg.PropBytes, lpg.PropTime or lpg.PropList — is not comparable, and its bound test is false. (A Cypher temporal value is delivered to the property layer as a TAGGED PropString, not as a PropTime, so it is ordered as a string; that is unchanged by #2600.)

A NaN operand makes every comparison FALSE (never null), which is the IEEE-754 outcome openCypher adopts: a NaN property value never matches, and a NaN bound matches nothing.

Index acceleration ¶

When the owning graph carries a btree index covering the predicate's (label, property) pair — and the same Pattern.Vertex call also constrains that label — the engine narrows the working set from the index with one O(log n + k) seek before any property is read. What happens next depends on whether that seek is exact:

• A STRING range is served EXACTLY, so the per-node comparison is skipped entirely and no property is read.
• A NUMERIC range is served from a float64-keyed index whose keys round above 2^53, so the seek is only a SUPERSET: the exact comparison above still runs, but over what the seek left rather than over the whole working set.

Either way the answer is identical to the answer the same query returns with no index present.