index

type Change ¶

type Change struct {
	Op       ChangeOp
	Node     graph.NodeID
	Dst      graph.NodeID // edge changes only
	Property uint32       // 0 when not a property change
	Label    uint32       // 0 when not a label change

	// OldValue and NewValue are present only for property changes.
	// They are typed as any so this package stays generic across
	// every PropertyValue kind without importing the lpg package.
	OldValue any
	NewValue any
}

Change describes a single mutation observed by the Manager. Each subscriber inspects the relevant fields and decides whether to update its own state.

Property and Label fields are interned identifiers from the owning graph's registries (lpg.PropertyKeyID / lpg.LabelID), surfaced as uint32 so this package does not import the lpg package and create a cycle.

func (c Change) IsEdgeChange() bool

type ChangeOp ¶

type ChangeOp uint8

ChangeOp tags the shape of a Change.

const (
	OpAddNodeLabel ChangeOp = iota + 1
	OpRemoveNodeLabel
	OpSetNodeProperty
	OpDelNodeProperty
	OpAddEdgeLabel
	OpRemoveEdgeLabel
	OpSetEdgeProperty
	OpDelEdgeProperty
)

type Manager ¶

type Manager struct {
	// contains filtered or unexported fields
}

Manager owns the set of named indexes attached to a graph and fans out mutations to every subscriber.

Manager is safe for concurrent use.

package main

import (
	"errors"
	"fmt"

	"github.com/FlavioCFOliveira/GoGraph/graph/index"
	"github.com/FlavioCFOliveira/GoGraph/graph/index/label"
)

func main() {
	m := index.NewManager()

	if err := m.CreateIndex("by_label", label.NewNodeIndex()); err != nil {
		fmt.Println("unexpected:", err)
	}

	// Re-registering the same name is rejected.
	err := m.CreateIndex("by_label", label.NewNodeIndex())
	fmt.Println("duplicate is ErrIndexExists:", errors.Is(err, index.ErrIndexExists))

	fmt.Println("count:", m.Count())
	fmt.Println("names:", m.ListIndexes())
}

Output:
duplicate is ErrIndexExists: true
count: 1
names: [by_label]

func NewManager() *Manager

func (m *Manager) Apply(c Change)

package main

import (
	"fmt"

	"github.com/FlavioCFOliveira/GoGraph/graph"
	"github.com/FlavioCFOliveira/GoGraph/graph/index"
	"github.com/FlavioCFOliveira/GoGraph/graph/index/label"
)

func main() {
	const labelPerson = uint32(7)

	m := index.NewManager()
	_ = m.CreateIndex("node_labels", label.NewNodeIndex())

	// A mutation observed by the owning graph is fanned out to every
	// subscriber. Here two nodes acquire the Person label.
	m.Apply(index.Change{Op: index.OpAddNodeLabel, Node: graph.NodeID(1), Label: labelPerson})
	m.Apply(index.Change{Op: index.OpAddNodeLabel, Node: graph.NodeID(4), Label: labelPerson})

	// Recover the concrete index to run a query.
	sub, _ := m.GetIndex("node_labels")
	idx := sub.(*label.Index)

	fmt.Println("kind:", idx.Kind())
	fmt.Println("Person count:", idx.Count(labelPerson))
	fmt.Println("Person members:", idx.Scan(labelPerson))
}

Output:
kind: label
Person count: 2
Person members: [1 4]

func (m *Manager) ApplyBatch(changes []Change)

func (m *Manager) Count() int

func (m *Manager) CreateIndex(name string, sub Subscriber) error

func (m *Manager) DropIndex(name string) error

func (m *Manager) GetIndex(name string) (Subscriber, error)

func (m *Manager) ListIndexes() []string

type Serializer ¶

type Serializer interface {
	Serialize(w io.Writer) error
	Deserialize(r io.Reader) error
}

Serializer is implemented by indexes that can persist and restore their internal state through an io.Writer / io.Reader pair. The Manager type-asserts every registered Subscriber to this interface during snapshot writes; subscribers that do not implement Serializer are silently skipped (rebuild-on-restart).

Implementations must:

• Write a fixed self-describing header (magic + format version) so a future format bump can be detected on read.
• Cover the entire on-disk payload with a CRC32C trailer (uint32 little-endian) so corruption surfaces as ErrIndexCorrupted.
• Be safe for concurrent reads from other goroutines while Serialize executes (typically by holding the index's own RLock for the duration of the write).

Deserialize replaces the receiver's state with the contents of r. On any structural problem or CRC mismatch the function returns a wrapped ErrIndexCorrupted and leaves the receiver in its previous state.

type Subscriber ¶

type Subscriber interface {
	Apply(Change)
	// Kind returns a short stable identifier of the underlying index
	// implementation, used for introspection (e.g. "label", "hash",
	// "btree").
	Kind() string
}

Subscriber is implemented by every concrete index that wishes to receive change events from the Manager. The Apply method must be idempotent: replays of the same change must not produce duplicate state.