graph

package
v2.84.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 29, 2026 License: MIT Imports: 30 Imported by: 1

Documentation

Index

Constants

View Source 
const (
	// RDFTermIRI represents an IRI/resource term.
	RDFTermIRI = "iri"
	// RDFTermBlankNode represents a blank node term.
	RDFTermBlankNode = "blank_node"
	// RDFTermLiteral represents a literal term.
	RDFTermLiteral = "literal"
)
View Source 
const (
	SHACLNamespace = "http://www.w3.org/ns/shacl#"
	RDFNamespace   = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
	XSDNamespace   = "http://www.w3.org/2001/XMLSchema#"

	SHACLNodeShape     = SHACLNamespace + "NodeShape"
	SHACLPropertyShape = SHACLNamespace + "PropertyShape"
	SHACLProperty      = SHACLNamespace + "property"
	SHACLPath          = SHACLNamespace + "path"
	SHACLTargetClass   = SHACLNamespace + "targetClass"
	SHACLTargetNode    = SHACLNamespace + "targetNode"
	SHACLDatatype      = SHACLNamespace + "datatype"
	SHACLMinCount      = SHACLNamespace + "minCount"
	SHACLMaxCount      = SHACLNamespace + "maxCount"
	SHACLMinInclusive  = SHACLNamespace + "minInclusive"
	SHACLMaxInclusive  = SHACLNamespace + "maxInclusive"
	SHACLPattern       = SHACLNamespace + "pattern"
	SHACLIn            = SHACLNamespace + "in"
	SHACLNodeKind      = SHACLNamespace + "nodeKind"
	SHACLClass         = SHACLNamespace + "class"
	SHACLSeverity      = SHACLNamespace + "severity"
	SHACLMessage       = SHACLNamespace + "message"

	SHACLSeverityInfo      = SHACLNamespace + "Info"
	SHACLSeverityWarning   = SHACLNamespace + "Warning"
	SHACLSeverityViolation = SHACLNamespace + "Violation"

	SHACLIRI                = SHACLNamespace + "IRI"
	SHACLBlankNode          = SHACLNamespace + "BlankNode"
	SHACLLiteral            = SHACLNamespace + "Literal"
	SHACLBlankNodeOrIRI     = SHACLNamespace + "BlankNodeOrIRI"
	SHACLBlankNodeOrLiteral = SHACLNamespace + "BlankNodeOrLiteral"
	SHACLIRIOrLiteral       = SHACLNamespace + "IRIOrLiteral"

	RDFType = RDFNamespace + "type"
)

SHACL IRIs

View Source 
const (
	// SPARQLQuerySelect executes a tabular SELECT query.
	SPARQLQuerySelect = "select"
	// SPARQLQueryAsk executes a boolean ASK query.
	SPARQLQueryAsk = "ask"
	// SPARQLQueryConstruct executes a graph-producing CONSTRUCT query.
	SPARQLQueryConstruct = "construct"
	// SPARQLQueryDescribe executes a graph-producing DESCRIBE query.
	SPARQLQueryDescribe = "describe"
	// SPARQLQueryInsertData executes an INSERT DATA update.
	SPARQLQueryInsertData = "insert_data"
	// SPARQLQueryDeleteData executes a DELETE DATA update.
	SPARQLQueryDeleteData = "delete_data"
	// SPARQLQueryDeleteWhere executes a DELETE WHERE update.
	SPARQLQueryDeleteWhere = "delete_where"
	// SPARQLQueryModify executes INSERT ... WHERE / DELETE ... INSERT ... WHERE style updates.
	SPARQLQueryModify = "modify"
)

Variables

This section is empty.

Functions

This section is empty.

Types

type BatchEdgeOperation 

type BatchEdgeOperation struct {
	Edges []*GraphEdge
}

BatchEdgeOperation represents a batch operation for edges

type BatchGraphOperation 

type BatchGraphOperation struct {
	NodeUpserts []*GraphNode
	NodeDeletes []string
	EdgeUpserts []*GraphEdge
	EdgeDeletes []string
}

BatchGraphOperation allows multiple graph operations in a single transaction

type BatchNodeOperation 

type BatchNodeOperation struct {
	Nodes []*GraphNode
}

BatchNodeOperation represents a batch operation for nodes

type BatchResult 

type BatchResult struct {
	SuccessCount int
	FailedCount  int
	Errors       []error
}

BatchResult contains the results of a batch operation.

A batch is partial by design: one rejected row does not roll the others back, so the batch functions report per-row failures here and reserve their error return for failures of the batch itself (transaction, prepare, commit). That makes it easy to lose writes without noticing — a caller that only checks err sees success for a batch in which every row was rejected. Call Err to fold the per-row failures back into a normal error before reporting success upwards.

func (*BatchResult) Err added in v2.69.0 

func (r *BatchResult) Err() error

Err returns the per-row failures of a batch joined into a single error, or nil when every row the caller supplied was written.

Only rows that actually failed are reported: the delete batches count ids that matched nothing as failed without recording an error, because "not there" is not a failure to delete. The upsert batches record an error for every failure they count.

type Community 

type Community struct {
	ID    int      `json:"id"`
	Nodes []string `json:"nodes"`
	Score float64  `json:"score"` // Modularity score
}

Community represents a detected community of nodes

type EdgePrediction 

type EdgePrediction struct {
	FromNodeID string  `json:"from_node_id"`
	ToNodeID   string  `json:"to_node_id"`
	Score      float64 `json:"score"`
	Method     string  `json:"method"`
}

EdgePrediction represents a predicted edge with confidence score

type ExportFormat 

type ExportFormat string

ExportFormat represents supported export formats 

const (
	FormatGraphML ExportFormat = "graphml"
	FormatGEXF    ExportFormat = "gexf"
	FormatJSON    ExportFormat = "json"
)

func DetectFormat 

func DetectFormat(reader io.Reader) (ExportFormat, error)

DetectFormat attempts to detect the format of the input

type GEXFAttValue 

type GEXFAttValue struct {
	For   string `xml:"for,attr"`
	Value string `xml:"value,attr"`
}

GEXFAttValue represents a GEXF attribute value

type GEXFAttr 

type GEXFAttr struct {
	ID    string `xml:"id,attr"`
	Title string `xml:"title,attr"`
	Type  string `xml:"type,attr"`
}

GEXFAttr represents a GEXF attribute

type GEXFAttrs 

type GEXFAttrs struct {
	Class string     `xml:"class,attr"`
	Attrs []GEXFAttr `xml:"attribute"`
}

GEXFAttrs represents GEXF attributes

type GEXFDocument 

type GEXFDocument struct {
	XMLName xml.Name  `xml:"gexf"`
	XMLNS   string    `xml:"xmlns,attr"`
	Version string    `xml:"version,attr"`
	Meta    GEXFMeta  `xml:"meta"`
	Graph   GEXFGraph `xml:"graph"`
}

GEXFDocument represents a GEXF document

type GEXFEdge 

type GEXFEdge struct {
	ID     string  `xml:"id,attr"`
	Source string  `xml:"source,attr"`
	Target string  `xml:"target,attr"`
	Weight float64 `xml:"weight,attr,omitempty"`
	Type   string  `xml:"type,attr,omitempty"`
}

GEXFEdge represents a GEXF edge

type GEXFEdges 

type GEXFEdges struct {
	Edges []GEXFEdge `xml:"edge"`
}

GEXFEdges represents GEXF edges container

type GEXFGraph 

type GEXFGraph struct {
	Mode            string    `xml:"mode,attr"`
	DefaultEdgeType string    `xml:"defaultedgetype,attr"`
	Attributes      GEXFAttrs `xml:"attributes"`
	Nodes           GEXFNodes `xml:"nodes"`
	Edges           GEXFEdges `xml:"edges"`
}

GEXFGraph represents a GEXF graph

type GEXFMeta 

type GEXFMeta struct {
	Creator     string `xml:"creator"`
	Description string `xml:"description"`
}

GEXFMeta represents GEXF metadata

type GEXFNode 

type GEXFNode struct {
	ID        string         `xml:"id,attr"`
	Label     string         `xml:"label,attr"`
	AttValues []GEXFAttValue `xml:"attvalues>attvalue"`
}

GEXFNode represents a GEXF node

type GEXFNodes 

type GEXFNodes struct {
	Nodes []GEXFNode `xml:"node"`
}

GEXFNodes represents GEXF nodes container

type GraphEdge 

type GraphEdge struct {
	ID         string                 `json:"id"`
	FromNodeID string                 `json:"from_node_id"`
	ToNodeID   string                 `json:"to_node_id"`
	EdgeType   string                 `json:"edge_type,omitempty"`
	Weight     float64                `json:"weight"`
	Properties map[string]interface{} `json:"properties,omitempty"`
	Vector     []float32              `json:"vector,omitempty"` // Optional edge embedding
	CreatedAt  time.Time              `json:"created_at"`
}

GraphEdge represents a directed edge between two nodes

type GraphFilter 

type GraphFilter struct {
	NodeTypes []string `json:"node_types,omitempty"`
	EdgeTypes []string `json:"edge_types,omitempty"`
	MaxDepth  int      `json:"max_depth,omitempty"`
}

GraphFilter defines filtering options for graph queries

type GraphMLData 

type GraphMLData struct {
	Key   string `xml:"key,attr"`
	Value string `xml:",chardata"`
}

GraphMLData represents GraphML data

type GraphMLDocument 

type GraphMLDocument struct {
	XMLName xml.Name     `xml:"graphml"`
	XMLNS   string       `xml:"xmlns,attr"`
	Keys    []GraphMLKey `xml:"key"`
	Graph   GraphMLGraph `xml:"graph"`
}

GraphMLDocument represents a GraphML document

type GraphMLEdge 

type GraphMLEdge struct {
	ID     string        `xml:"id,attr"`
	Source string        `xml:"source,attr"`
	Target string        `xml:"target,attr"`
	Data   []GraphMLData `xml:"data"`
}

GraphMLEdge represents a GraphML edge

type GraphMLGraph 

type GraphMLGraph struct {
	ID          string        `xml:"id,attr"`
	EdgeDefault string        `xml:"edgedefault,attr"`
	Nodes       []GraphMLNode `xml:"node"`
	Edges       []GraphMLEdge `xml:"edge"`
}

GraphMLGraph represents a GraphML graph

type GraphMLKey 

type GraphMLKey struct {
	ID       string `xml:"id,attr"`
	For      string `xml:"for,attr"`
	AttrName string `xml:"attr.name,attr"`
	AttrType string `xml:"attr.type,attr"`
}

GraphMLKey represents a GraphML key definition

type GraphMLNode 

type GraphMLNode struct {
	ID   string        `xml:"id,attr"`
	Data []GraphMLData `xml:"data"`
}

GraphMLNode represents a GraphML node

type GraphNode 

type GraphNode struct {
	ID         string                 `json:"id"`
	Vector     []float32              `json:"vector"`
	Content    string                 `json:"content,omitempty"`
	NodeType   string                 `json:"node_type,omitempty"`
	Properties map[string]interface{} `json:"properties,omitempty"`
	CreatedAt  time.Time              `json:"created_at"`
	UpdatedAt  time.Time              `json:"updated_at"`
}

GraphNode represents a node in the graph with vector embedding

type GraphResult 

type GraphResult struct {
	Nodes []*GraphNode `json:"nodes"`
	Edges []*GraphEdge `json:"edges"`
}

GraphResult represents a subgraph or query result

type GraphStatistics 

type GraphStatistics struct {
	NodeCount           int     `json:"node_count"`
	EdgeCount           int     `json:"edge_count"`
	AverageDegree       float64 `json:"average_degree"`
	Density             float64 `json:"density"`
	ConnectedComponents int     `json:"connected_components"`
}

GraphStatistics represents overall graph statistics

type GraphStore 

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

GraphStore provides graph operations on top of the vector store

func NewGraphStore 

func NewGraphStore(s *core.SQLiteStore) *GraphStore

NewGraphStore creates a new graph store from a SQLite store.

func NewGraphStoreOn added in v2.82.0 

func NewGraphStoreOn(db *sql.DB, d sqldialect.Dialect, host vectorHost) *GraphStore

NewGraphStoreOn creates a graph store over any database this dialect can speak, for a host that supplies the vector-side settings.

The same tables and the same queries as NewGraphStore — the graph layer has no SQLite-only SQL in it, which is what makes one implementation over two databases possible rather than two implementations to keep in step.

func (*GraphStore) CommunityDetection 

func (g *GraphStore) CommunityDetection(ctx context.Context) ([]Community, error)

CommunityDetection performs community detection using the Louvain method Optimized to reduce DB queries.

func (*GraphStore) CompactIRI added in v2.16.0 

func (g *GraphStore) CompactIRI(ctx context.Context, value string) (string, error)

CompactIRI compacts an IRI using the longest matching namespace prefix when available.

func (*GraphStore) Connected 

func (g *GraphStore) Connected(ctx context.Context, nodeID1, nodeID2 string, maxDepth int) (bool, error)

Connected checks if two nodes are connected within a given depth

func (*GraphStore) DeleteEdge 

func (g *GraphStore) DeleteEdge(ctx context.Context, edgeID string) error

DeleteEdge removes an edge from the graph

func (*GraphStore) DeleteEdgesBatch 

func (g *GraphStore) DeleteEdgesBatch(ctx context.Context, edgeIDs []string) (*BatchResult, error)

DeleteEdgesBatch deletes multiple edges in a single transaction

func (*GraphStore) DeleteNamespace added in v2.16.0 

func (g *GraphStore) DeleteNamespace(ctx context.Context, prefix string) error

DeleteNamespace removes one user-defined namespace mapping.

func (*GraphStore) DeleteNode 

func (g *GraphStore) DeleteNode(ctx context.Context, nodeID string) error

DeleteNode removes a node and all its edges

func (*GraphStore) DeleteNodesBatch 

func (g *GraphStore) DeleteNodesBatch(ctx context.Context, nodeIDs []string) (*BatchResult, error)

DeleteNodesBatch deletes multiple nodes in a single transaction

func (*GraphStore) DeleteTriple added in v2.16.0 

func (g *GraphStore) DeleteTriple(ctx context.Context, triple RDFTriple) error

DeleteTriple removes one RDF triple/quad by its normalized content.

func (*GraphStore) DeleteTriples added in v2.16.0 

func (g *GraphStore) DeleteTriples(ctx context.Context, pattern TriplePattern) (int, error)

DeleteTriples removes all triples matched by the given pattern.

func (*GraphStore) EnableHNSWIndex 

func (g *GraphStore) EnableHNSWIndex(dimensions int) error

EnableHNSWIndex enables HNSW indexing for the graph store

func (*GraphStore) ExecuteBatch 

func (g *GraphStore) ExecuteBatch(ctx context.Context, ops *BatchGraphOperation) (*BatchResult, error)

ExecuteBatch executes multiple graph operations in a single transaction

func (*GraphStore) ExecuteBatchTx added in v2.14.1 

func (g *GraphStore) ExecuteBatchTx(ctx context.Context, tx *sql.Tx, ops *BatchGraphOperation) (*BatchResult, error)

ExecuteBatchTx applies a batch of graph operations inside an existing transaction.

func (*GraphStore) ExecuteSPARQL added in v2.16.0 

func (g *GraphStore) ExecuteSPARQL(ctx context.Context, query string) (*SPARQLResult, error)

ExecuteSPARQL runs a practical SPARQL SELECT/ASK subset against the embedded RDF layer.

func (*GraphStore) ExpandIRI added in v2.16.0 

func (g *GraphStore) ExpandIRI(ctx context.Context, value string) (string, error)

ExpandIRI expands a compact IRI using registered namespaces when possible.

func (*GraphStore) ExplainTriple added in v2.16.0 

func (g *GraphStore) ExplainTriple(ctx context.Context, tripleID string) (*RDFSInferenceExplanation, error)

ExplainTriple returns whether a triple is explicit or inferred and its immediate provenance.

func (*GraphStore) ExplainTripleTrace added in v2.16.0 

func (g *GraphStore) ExplainTripleTrace(ctx context.Context, tripleID string, depth int) ([]RDFSInferenceTraceEntry, error)

ExplainTripleTrace recursively expands provenance for a triple into a flattened trace list.

func (*GraphStore) ExplainTriplesByPattern added in v2.18.0 

func (g *GraphStore) ExplainTriplesByPattern(ctx context.Context, pattern TriplePattern, depth int) ([]RDFSInferenceMatchExplanation, error)

ExplainTriplesByPattern expands explanations for all triples matched by the given pattern.

func (*GraphStore) Export 

func (g *GraphStore) Export(ctx context.Context, writer io.Writer, format ExportFormat) error

Export exports the graph in the specified format

func (*GraphStore) ExportGEXF 

func (g *GraphStore) ExportGEXF(ctx context.Context, writer io.Writer) error

ExportGEXF exports the graph to GEXF format

func (*GraphStore) ExportGraphML 

func (g *GraphStore) ExportGraphML(ctx context.Context, writer io.Writer) error

ExportGraphML exports the graph to GraphML format

func (*GraphStore) ExportJSON 

func (g *GraphStore) ExportJSON(ctx context.Context, writer io.Writer) error

ExportJSON exports the graph to JSON format

func (*GraphStore) ExportRDF added in v2.16.0 

func (g *GraphStore) ExportRDF(ctx context.Context, writer io.Writer, format RDFFormat) error

ExportRDF writes triples in the requested RDF format.

func (*GraphStore) FindTriples added in v2.16.0 

func (g *GraphStore) FindTriples(ctx context.Context, pattern TriplePattern) ([]RDFTriple, error)

FindTriples queries triples by pattern.

func (*GraphStore) GetAllNodes 

func (g *GraphStore) GetAllNodes(ctx context.Context, filter *GraphFilter) ([]*GraphNode, error)

GetAllNodes retrieves all nodes with optional filtering

func (*GraphStore) GetEdges 

func (g *GraphStore) GetEdges(ctx context.Context, nodeID string, direction string) ([]*GraphEdge, error)

GetEdges retrieves edges for a node.

Ordered by id, which matters more than it looks: this feeds Neighbors, and Neighbors feeds graph-mode retrieval. Without an ORDER BY, SQLite happens to return insertion order while PostgreSQL returns whatever the plan produced — so the same question could retrieve a different set of chunks on the two backends, and a different set on PostgreSQL from one run to the next once the table had been updated.

func (*GraphStore) GetEdgesBatch 

func (g *GraphStore) GetEdgesBatch(ctx context.Context, edgeIDs []string) ([]*GraphEdge, error)

GetEdgesBatch retrieves multiple edges by their IDs

func (*GraphStore) GetGraphStatistics 

func (g *GraphStore) GetGraphStatistics(ctx context.Context) (*GraphStatistics, error)

GetGraphStatistics computes statistics about the graph

func (*GraphStore) GetNode 

func (g *GraphStore) GetNode(ctx context.Context, nodeID string) (*GraphNode, error)

GetNode retrieves a node by ID

func (*GraphStore) GetNodesBatch 

func (g *GraphStore) GetNodesBatch(ctx context.Context, nodeIDs []string) ([]*GraphNode, error)

GetNodesBatch retrieves multiple nodes by their IDs

func (*GraphStore) GetTriple added in v2.16.0 

func (g *GraphStore) GetTriple(ctx context.Context, id string) (*RDFTriple, error)

GetTriple fetches one RDF triple by ID.

func (*GraphStore) GraphVectorSearch 

func (g *GraphStore) GraphVectorSearch(ctx context.Context, startNodeID string, vector []float32, opts TraversalOptions) ([]*HybridResult, error)

GraphVectorSearch performs vector search within a graph neighborhood

func (*GraphStore) HNSWHybridSearch 

func (g *GraphStore) HNSWHybridSearch(ctx context.Context, query *HybridQuery) ([]*HybridResult, error)

HNSWHybridSearch combines HNSW search with graph proximity

func (*GraphStore) HNSWSearch 

func (g *GraphStore) HNSWSearch(ctx context.Context, query []float32, k int, threshold float64) ([]*HybridResult, error)

HNSWSearch performs HNSW-accelerated vector search

func (*GraphStore) HybridSearch 

func (g *GraphStore) HybridSearch(ctx context.Context, query *HybridQuery) ([]*HybridResult, error)

HybridSearch performs a combined vector and graph search

func (*GraphStore) Import 

func (g *GraphStore) Import(ctx context.Context, reader io.Reader, format ExportFormat) error

Import imports a graph in the specified format

func (*GraphStore) ImportGEXF 

func (g *GraphStore) ImportGEXF(ctx context.Context, reader io.Reader) error

ImportGEXF imports a graph from GEXF format

func (*GraphStore) ImportGraphML 

func (g *GraphStore) ImportGraphML(ctx context.Context, reader io.Reader) error

ImportGraphML imports a graph from GraphML format

func (*GraphStore) ImportJSON 

func (g *GraphStore) ImportJSON(ctx context.Context, reader io.Reader) error

ImportJSON imports a graph from JSON format

func (*GraphStore) ImportRDF added in v2.16.0 

func (g *GraphStore) ImportRDF(ctx context.Context, reader io.Reader, format RDFFormat) (int, error)

ImportRDF parses and stores triples from supported RDF serializations.

func (*GraphStore) InferenceSummary added in v2.18.0 

func (g *GraphStore) InferenceSummary(ctx context.Context) (*RDFSInferenceSummary, error)

InferenceSummary returns explicit/inferred counts and an inference-rule breakdown.

func (*GraphStore) InitGraphSchema 

func (g *GraphStore) InitGraphSchema(ctx context.Context) error

InitGraphSchema creates the graph tables if they don't exist.

It is cheap to call repeatedly: after the first success this store remembers that its schema is ready and returns without touching SQLite, so write paths can guard themselves with it instead of trusting the caller to have done so.

func (*GraphStore) ListNamespaces added in v2.16.0 

func (g *GraphStore) ListNamespaces(ctx context.Context) ([]Namespace, error)

ListNamespaces returns built-in and user-defined namespaces.

func (*GraphStore) MergeEntities added in v2.26.0 

func (g *GraphStore) MergeEntities(ctx context.Context, canonicalID string, aliasIDs []string) error

MergeEntities collapses surface-form duplicate nodes into one canonical node: every edge referencing an alias is repointed to canonicalID, self-loops created by the merge are dropped, and the alias nodes are deleted. Used for entity resolution (e.g. unifying "r0" / "DRBD resource" / "resources" into one entity).

func (*GraphStore) Neighbors 

func (g *GraphStore) Neighbors(ctx context.Context, nodeID string, opts TraversalOptions) ([]*GraphNode, error)

Neighbors performs a breadth-first search to find neighboring nodes

func (*GraphStore) PageRank 

func (g *GraphStore) PageRank(ctx context.Context, iterations int, dampingFactor float64) ([]PageRankResult, error)

PageRank calculates PageRank scores for all nodes in the graph Optimized to load only topology (IDs and Edges) instead of full node objects.

func (*GraphStore) PredictEdges 

func (g *GraphStore) PredictEdges(ctx context.Context, nodeID string, topK int) ([]EdgePrediction, error)

PredictEdges predicts potential edges using various methods

func (*GraphStore) RefreshRDFSInferences added in v2.16.0 

func (g *GraphStore) RefreshRDFSInferences(ctx context.Context) (*RDFSInferenceRefreshResult, error)

RefreshRDFSInferences recomputes and persists inferred triples using an RDFS-lite ruleset.

func (*GraphStore) RefreshRDFSInferencesIncremental added in v2.18.0 

func (g *GraphStore) RefreshRDFSInferencesIncremental(ctx context.Context, changedTriples []RDFTriple) (*RDFSInferenceRefreshResult, error)

RefreshRDFSInferencesIncremental recomputes inferred triples only for the neighborhood affected by the supplied changed explicit triples.

func (*GraphStore) ShortestPath 

func (g *GraphStore) ShortestPath(ctx context.Context, fromID, toID string) (*PathResult, error)

ShortestPath finds the shortest path between two nodes using BFS

func (*GraphStore) SimilarityInGraph 

func (g *GraphStore) SimilarityInGraph(ctx context.Context, nodeID string, opts core.SearchOptions) ([]*HybridResult, error)

SimilarityInGraph finds nodes similar to a given node within the graph

func (*GraphStore) Subgraph 

func (g *GraphStore) Subgraph(ctx context.Context, nodeIDs []string) (*GraphResult, error)

Subgraph extracts a subgraph containing specified nodes and their connections

func (*GraphStore) SyncDeletedNodeIDs added in v2.14.1 

func (g *GraphStore) SyncDeletedNodeIDs(_ context.Context, nodeIDs []string)

SyncDeletedNodeIDs removes committed graph-node deletions from the optional HNSW index.

func (*GraphStore) SyncUpsertedNodes added in v2.14.1 

func (g *GraphStore) SyncUpsertedNodes(_ context.Context, nodes []*GraphNode)

SyncUpsertedNodes updates the optional graph HNSW index after nodes were committed through ExecuteBatchTx.

func (*GraphStore) UpsertEdge 

func (g *GraphStore) UpsertEdge(ctx context.Context, edge *GraphEdge) error

UpsertEdge inserts or updates an edge in the graph

func (*GraphStore) UpsertEdgesBatch 

func (g *GraphStore) UpsertEdgesBatch(ctx context.Context, edges []*GraphEdge) (*BatchResult, error)

UpsertEdgesBatch inserts or updates multiple edges in a single transaction

func (*GraphStore) UpsertNamespace added in v2.16.0 

func (g *GraphStore) UpsertNamespace(ctx context.Context, ns Namespace) error

UpsertNamespace stores or replaces one namespace mapping.

func (*GraphStore) UpsertNode 

func (g *GraphStore) UpsertNode(ctx context.Context, node *GraphNode) error

UpsertNode inserts or updates a node in the graph

func (*GraphStore) UpsertNodesBatch 

func (g *GraphStore) UpsertNodesBatch(ctx context.Context, nodes []*GraphNode) (*BatchResult, error)

UpsertNodesBatch inserts or updates multiple nodes in a single transaction

func (*GraphStore) UpsertTriple added in v2.16.0 

func (g *GraphStore) UpsertTriple(ctx context.Context, triple *RDFTriple) error

UpsertTriple writes one RDF triple/quad and mirrors it into the property graph tables.

func (*GraphStore) UpsertTriplesBatch added in v2.16.0 

func (g *GraphStore) UpsertTriplesBatch(ctx context.Context, triples []*RDFTriple) (*BatchResult, error)

UpsertTriplesBatch writes multiple RDF triples/quads.

func (*GraphStore) ValidateSHACL added in v2.18.0 

func (g *GraphStore) ValidateSHACL(ctx context.Context, shapeTriples []RDFTriple) (*SHACLReport, error)

ValidateSHACL runs SHACL validation against the graph store using the provided shapes.

type HNSWGraphIndex 

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

HNSWGraphIndex provides HNSW-accelerated graph searches

type HybridQuery 

type HybridQuery struct {
	Vector          []float32     `json:"vector,omitempty"`
	StartNodeID     string        `json:"start_node_id,omitempty"`
	CenterNodes     []string      `json:"center_nodes,omitempty"`
	GraphFilter     *GraphFilter  `json:"graph_filter,omitempty"`
	TopK            int           `json:"top_k"`
	Threshold       float64       `json:"threshold,omitempty"`
	VectorThreshold float64       `json:"vector_threshold,omitempty"`
	TotalThreshold  float64       `json:"total_threshold,omitempty"`
	VectorWeight    float64       `json:"vector_weight"`
	GraphWeight     float64       `json:"graph_weight"`
	Weights         HybridWeights `json:"weights"`
}

HybridQuery represents a combined vector and graph query

type HybridResult 

type HybridResult struct {
	Node          *GraphNode `json:"node"`
	VectorScore   float64    `json:"vector_score"`
	GraphScore    float64    `json:"graph_score"`
	CombinedScore float64    `json:"combined_score"`
	TotalScore    float64    `json:"total_score"`
	Path          []string   `json:"path,omitempty"` // Path from start node
	Distance      int        `json:"distance"`       // Graph distance from start
}

HybridResult represents a result from hybrid search

type HybridWeights 

type HybridWeights struct {
	VectorWeight float64 `json:"vector_weight"` // Weight for vector similarity
	GraphWeight  float64 `json:"graph_weight"`  // Weight for graph proximity
	EdgeWeight   float64 `json:"edge_weight"`   // Weight for edge strength
}

HybridWeights defines the weights for hybrid scoring

type Namespace added in v2.16.0 

type Namespace struct {
	Prefix string `json:"prefix"`
	URI    string `json:"uri"`
}

Namespace represents a prefix to IRI mapping.

type PageRankResult 

type PageRankResult struct {
	NodeID string  `json:"node_id"`
	Score  float64 `json:"score"`
}

PageRankResult represents the PageRank score for a node

type PathResult 

type PathResult struct {
	Nodes    []*GraphNode `json:"nodes"`
	Edges    []*GraphEdge `json:"edges"`
	Distance int          `json:"distance"`
	Weight   float64      `json:"weight"`
}

PathResult represents a path in the graph

type RDFFormat added in v2.16.0 

type RDFFormat string

RDFFormat represents a supported RDF serialization format. 

const (
	// RDFFormatNTriples exports triples in N-Triples syntax.
	RDFFormatNTriples RDFFormat = "ntriples"
	// RDFFormatNQuads exports statements in N-Quads syntax when graph names are present.
	RDFFormatNQuads RDFFormat = "nquads"
	// RDFFormatTurtle exports statements in a Turtle-like syntax with prefixes when possible.
	RDFFormatTurtle RDFFormat = "turtle"
	// RDFFormatTriG exports quads in TriG syntax with graph blocks.
	RDFFormatTriG RDFFormat = "trig"
)

type RDFSInferenceExplanation added in v2.16.0 

type RDFSInferenceExplanation struct {
	Triple           RDFTriple `json:"triple"`
	Explicit         bool      `json:"explicit"`
	Rule             string    `json:"rule,omitempty"`
	SupportTripleIDs []string  `json:"support_triple_ids,omitempty"`
}

RDFSInferenceExplanation returns provenance information for one triple.

type RDFSInferenceMatchExplanation added in v2.18.0 

type RDFSInferenceMatchExplanation struct {
	Explanation RDFSInferenceExplanation  `json:"explanation"`
	Trace       []RDFSInferenceTraceEntry `json:"trace,omitempty"`
}

RDFSInferenceMatchExplanation combines explanation and optional trace for one matched triple.

type RDFSInferenceRefreshResult added in v2.16.0 

type RDFSInferenceRefreshResult struct {
	ExplicitCount         int  `json:"explicit_count"`
	InferredCount         int  `json:"inferred_count"`
	Incremental           bool `json:"incremental,omitempty"`
	AffectedExplicitCount int  `json:"affected_explicit_count,omitempty"`
	RemovedInferredCount  int  `json:"removed_inferred_count,omitempty"`
}

RDFSInferenceRefreshResult summarizes a refresh of inferred triples.

type RDFSInferenceSummary added in v2.18.0 

type RDFSInferenceSummary struct {
	ExplicitCount int            `json:"explicit_count"`
	InferredCount int            `json:"inferred_count"`
	Rules         map[string]int `json:"rules,omitempty"`
}

RDFSInferenceSummary provides persisted inference counts and rule breakdowns.

type RDFSInferenceTraceEntry added in v2.16.0 

type RDFSInferenceTraceEntry struct {
	TripleID       string                   `json:"triple_id"`
	ParentTripleID string                   `json:"parent_triple_id,omitempty"`
	Depth          int                      `json:"depth"`
	Explanation    RDFSInferenceExplanation `json:"explanation"`
	Truncated      bool                     `json:"truncated,omitempty"`
}

RDFSInferenceTraceEntry is one flattened node in an explanation trace.

type RDFTerm added in v2.16.0 

type RDFTerm struct {
	Kind     string `json:"kind"`
	Value    string `json:"value"`
	Datatype string `json:"datatype,omitempty"`
	Language string `json:"language,omitempty"`
}

RDFTerm represents one RDF term.

func NewBlankNode added in v2.16.0 

func NewBlankNode(value string) RDFTerm

NewBlankNode creates a blank node term.

func NewIRI added in v2.16.0 

func NewIRI(value string) RDFTerm

NewIRI creates an IRI term.

func NewLangLiteral added in v2.16.0 

func NewLangLiteral(value, language string) RDFTerm

NewLangLiteral creates a language-tagged literal term.

func NewLiteral added in v2.16.0 

func NewLiteral(value string) RDFTerm

NewLiteral creates a plain literal term.

func NewTypedLiteral added in v2.16.0 

func NewTypedLiteral(value, datatype string) RDFTerm

NewTypedLiteral creates a typed literal term.

func (RDFTerm) String added in v2.16.0 

func (t RDFTerm) String() string

String renders the term using RDF-compatible syntax.

type RDFTriple added in v2.16.0 

type RDFTriple struct {
	ID         string   `json:"id,omitempty"`
	Subject    RDFTerm  `json:"subject"`
	Predicate  RDFTerm  `json:"predicate"`
	Object     RDFTerm  `json:"object"`
	Graph      *RDFTerm `json:"graph,omitempty"`
	Inferred   bool     `json:"inferred,omitempty"`
	Rule       string   `json:"rule,omitempty"`
	SupportIDs []string `json:"support_ids,omitempty"`
}

RDFTriple represents one RDF triple or quad when Graph is set.

func (RDFTriple) String added in v2.16.0 

func (t RDFTriple) String() string

String renders the triple/quad using RDF syntax.

type SHACLReport added in v2.18.0 

type SHACLReport struct {
	Conforms bool                    `json:"conforms"`
	Results  []SHACLValidationResult `json:"results,omitempty"`
}

SHACLReport contains the outcome of SHACL validation.

type SHACLValidationResult added in v2.18.0 

type SHACLValidationResult struct {
	FocusNode RDFTerm `json:"focus_node"`
	Path      RDFTerm `json:"path"`
	Value     RDFTerm `json:"value,omitempty"`
	Message   string  `json:"message"`
	Severity  string  `json:"severity"`
	Source    RDFTerm `json:"source_shape"`
}

SHACLValidationResult represents a single constraint violation.

type SPARQLResult added in v2.16.0 

type SPARQLResult struct {
	QueryType string               `json:"query_type"`
	Vars      []string             `json:"vars,omitempty"`
	Bindings  []map[string]RDFTerm `json:"bindings,omitempty"`
	Triples   []RDFTriple          `json:"triples,omitempty"`
	Boolean   bool                 `json:"boolean,omitempty"`
	Count     int                  `json:"count"`
}

SPARQLResult contains the result of executing a SPARQL query.

type SimpleHNSW 

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

SimpleHNSW implements a simplified HNSW-like index for vector search

func NewSimpleHNSW 

func NewSimpleHNSW(dimensions int, maxConns int) *SimpleHNSW

NewSimpleHNSW creates a new simplified HNSW index

func (*SimpleHNSW) Add 

func (h *SimpleHNSW) Add(id string, vector []float32) error

Add inserts a vector into the HNSW index

func (*SimpleHNSW) Remove 

func (h *SimpleHNSW) Remove(nodeID string)

Remove removes a node from the index

func (*SimpleHNSW) Search 

func (h *SimpleHNSW) Search(query []float32, k int) []searchCandidate

Search performs HNSW search

type TraversalOptions 

type TraversalOptions struct {
	MaxDepth  int      `json:"max_depth"`
	EdgeTypes []string `json:"edge_types,omitempty"`
	NodeTypes []string `json:"node_types,omitempty"`
	Direction string   `json:"direction"` // "out", "in", "both"
	Limit     int      `json:"limit"`
}

TraversalOptions defines options for graph traversal

type TriplePattern added in v2.16.0 

type TriplePattern struct {
	Subject   *RDFTerm `json:"subject,omitempty"`
	Predicate *RDFTerm `json:"predicate,omitempty"`
	Object    *RDFTerm `json:"object,omitempty"`
	Graph     *RDFTerm `json:"graph,omitempty"`
	Inferred  *bool    `json:"inferred,omitempty"`
	Limit     int      `json:"limit,omitempty"`
}

TriplePattern filters triple lookup operations. Nil fields behave as wildcards.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.