Visualizando todo grafo com anzograph

backend_go/graph_export.go

@@ -5,89 +5,87 @@ type termKey struct {
 	key      string
 }
 
-type termMeta struct {
-	termType string
-	iri      string
+type graphAccumulator struct {
+	includeBNodes bool
+	nodeLimit     int
+	nodeIDByKey   map[termKey]uint32
+	nodes         []Node
+	edges         []Edge
+	preds         *PredicateDict
 }
 
-func graphFromSparqlBindings(
-	bindings []map[string]sparqlTerm,
-	nodeLimit int,
-	includeBNodes bool,
-) (nodes []Node, edges []Edge) {
-	nodeIDByKey := map[termKey]uint32{}
-	nodeMeta := make([]termMeta, 0, min(nodeLimit, 4096))
+func newGraphAccumulator(nodeLimit int, includeBNodes bool, edgeCapHint int, preds *PredicateDict) *graphAccumulator {
+	if preds == nil {
+		preds = NewPredicateDict(nil)
+	}
+	return &graphAccumulator{
+		includeBNodes: includeBNodes,
+		nodeLimit:     nodeLimit,
+		nodeIDByKey:   make(map[termKey]uint32),
+		nodes:         make([]Node, 0, min(nodeLimit, 4096)),
+		edges:         make([]Edge, 0, min(edgeCapHint, 4096)),
+		preds:         preds,
+	}
+}
 
-	getOrAdd := func(term sparqlTerm) (uint32, bool) {
-		if term.Type == "" || term.Value == "" {
-			return 0, false
-		}
-		if term.Type == "literal" {
-			return 0, false
-		}
-
-		var key termKey
-		var meta termMeta
-
-		if term.Type == "bnode" {
-			if !includeBNodes {
-				return 0, false
-			}
-			key = termKey{termType: "bnode", key: term.Value}
-			meta = termMeta{termType: "bnode", iri: "_:" + term.Value}
-		} else {
-			key = termKey{termType: "uri", key: term.Value}
-			meta = termMeta{termType: "uri", iri: term.Value}
-		}
-
-		if existing, ok := nodeIDByKey[key]; ok {
-			return existing, true
-		}
-		if len(nodeMeta) >= nodeLimit {
-			return 0, false
-		}
-		nid := uint32(len(nodeMeta))
-		nodeIDByKey[key] = nid
-		nodeMeta = append(nodeMeta, meta)
-		return nid, true
+func (g *graphAccumulator) getOrAddNode(term sparqlTerm) (uint32, bool) {
+	if term.Type == "" || term.Value == "" {
+		return 0, false
+	}
+	if term.Type == "literal" {
+		return 0, false
 	}
 
+	var key termKey
+	var node Node
+
+	if term.Type == "bnode" {
+		if !g.includeBNodes {
+			return 0, false
+		}
+		key = termKey{termType: "bnode", key: term.Value}
+		node = Node{ID: 0, TermType: "bnode", IRI: "_:" + term.Value, Label: nil, X: 0, Y: 0}
+	} else {
+		key = termKey{termType: "uri", key: term.Value}
+		node = Node{ID: 0, TermType: "uri", IRI: term.Value, Label: nil, X: 0, Y: 0}
+	}
+
+	if existing, ok := g.nodeIDByKey[key]; ok {
+		return existing, true
+	}
+	if len(g.nodes) >= g.nodeLimit {
+		return 0, false
+	}
+	nid := uint32(len(g.nodes))
+	g.nodeIDByKey[key] = nid
+	node.ID = nid
+	g.nodes = append(g.nodes, node)
+	return nid, true
+}
+
+func (g *graphAccumulator) addBindings(bindings []map[string]sparqlTerm) {
 	for _, b := range bindings {
 		sTerm := b["s"]
 		oTerm := b["o"]
 		pTerm := b["p"]
 
-		sid, okS := getOrAdd(sTerm)
-		oid, okO := getOrAdd(oTerm)
+		sid, okS := g.getOrAddNode(sTerm)
+		oid, okO := g.getOrAddNode(oTerm)
 		if !okS || !okO {
 			continue
 		}
 
-		pred := pTerm.Value
-		if pred == "" {
+		predID, ok := g.preds.GetOrAdd(pTerm.Value)
+		if !ok {
 			continue
 		}
 
-		edges = append(edges, Edge{
-			Source:    sid,
-			Target:    oid,
-			Predicate: pred,
+		g.edges = append(g.edges, Edge{
+			Source:      sid,
+			Target:      oid,
+			PredicateID: predID,
 		})
 	}
-
-	nodes = make([]Node, len(nodeMeta))
-	for i, m := range nodeMeta {
-		nodes[i] = Node{
-			ID:       uint32(i),
-			TermType: m.termType,
-			IRI:      m.iri,
-			Label:    nil,
-			X:        0,
-			Y:        0,
-		}
-	}
-
-	return nodes, edges
 }
 
 func min(a, b int) int {