25707480509

Committed 12 May 2026 01:24AM UTC coverage: 84.081% (-0.5%) from 84.61%

Build # 25707480509

Build Type

push

github

Committed by

orneryd

Commit Message

fix(test) flush span kind propert missing

Coverage Stats

1 of 1 new or added line in 1 file covered. (100.0%)

5095 existing lines in 65 files now uncovered.

123467 of 146843 relevant lines covered (84.08%)

0.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.74

/pkg/multidb/storage_size_cache.go

package multidb

import (
        "fmt"

        "github.com/orneryd/nornicdb/pkg/storage"
)

// ensureStorageSizeInitialized performs one-time exact size calculation from storage
// and caches the result for O(1) future reads.
func (m *DatabaseManager) ensureStorageSizeInitialized(databaseName string, engine storage.Engine) error {
        m.mu.RLock()
        info, exists := m.databases[databaseName]
        m.mu.RUnlock()
        if !exists {
                return ErrDatabaseNotFound
        }

        info.sizeMu.RLock()
        if info.sizeInitialized {
                info.sizeMu.RUnlock()
                return nil
        }
        info.sizeMu.RUnlock()

        nodeSize, edgeSize, err := m.calculateStorageSizeFromEngine(engine)
        if err != nil {
                return err
        }

        info.sizeMu.Lock()
        if !info.sizeInitialized {
                info.nodeSize = nodeSize
                info.edgeSize = edgeSize
                info.totalSize = nodeSize + edgeSize
                info.sizeInitialized = true
        }
        info.sizeMu.Unlock()
        return nil
}

// markStorageSizeDirty marks cached size as stale. The next read/operation will
// recalculate from storage.
func (m *DatabaseManager) markStorageSizeDirty(databaseName string) {
        m.mu.RLock()
        info, exists := m.databases[databaseName]
        m.mu.RUnlock()
        if !exists {
                return
        }
        info.sizeMu.Lock()
        info.sizeInitialized = false
        info.sizeMu.Unlock()
}

// applyStorageSizeDelta updates cached size counters in O(1). If a previous operation
// marked the cache dirty, deltas are ignored until re-initialization.
func (m *DatabaseManager) applyStorageSizeDelta(databaseName string, nodeDelta, edgeDelta int64) {
        m.mu.RLock()
        info, exists := m.databases[databaseName]
        m.mu.RUnlock()
        if !exists {
                return
        }
        info.sizeMu.Lock()
        defer info.sizeMu.Unlock()
        if !info.sizeInitialized {
                return
        }
        info.nodeSize += nodeDelta
        info.edgeSize += edgeDelta
        info.totalSize += nodeDelta + edgeDelta
        if info.nodeSize < 0 {
                info.nodeSize = 0
        }
        if info.edgeSize < 0 {
                info.edgeSize = 0
        }
        if info.totalSize < 0 {
                info.totalSize = 0
        }
}

func (m *DatabaseManager) calculateStorageSizeFromEngine(engine storage.Engine) (int64, int64, error) {
        var nodeSize int64
        var edgeSize int64

        nodes, err := engine.AllNodes()
        if err != nil {
                return 0, 0, fmt.Errorf("failed to get all nodes for size calculation: %w", err)
        }
        for _, node := range nodes {
                size, sizeErr := calculateNodeSize(node)
                if sizeErr != nil {
                        return 0, 0, fmt.Errorf("failed to calculate node size: %w", sizeErr)
                }
                nodeSize += size
        }

        edges, err := engine.AllEdges()
        if err != nil {
                return 0, 0, fmt.Errorf("failed to get all edges for size calculation: %w", err)
        }
        for _, edge := range edges {
                size, sizeErr := calculateEdgeSize(edge)
                if sizeErr != nil {
                        return 0, 0, fmt.Errorf("failed to calculate edge size: %w", sizeErr)
                }
                edgeSize += size
        }

        return nodeSize, edgeSize, nil
}

1	package multidb
2
3	import (
4	"fmt"
5
6	"github.com/orneryd/nornicdb/pkg/storage"
7	)
8
9	// ensureStorageSizeInitialized performs one-time exact size calculation from storage
10	// and caches the result for O(1) future reads.
11	func (m *DatabaseManager) ensureStorageSizeInitialized(databaseName string, engine storage.Engine) error {	1✔
12	m.mu.RLock()	1✔
13	info, exists := m.databases[databaseName]	1✔
14	m.mu.RUnlock()	1✔
15	if !exists {	1✔
16	return ErrDatabaseNotFound	×
17	}	×
18
19	info.sizeMu.RLock()	1✔
20	if info.sizeInitialized {	2✔
21	info.sizeMu.RUnlock()	1✔
22	return nil	1✔
23	}	1✔
24	info.sizeMu.RUnlock()	1✔
25		1✔
26	nodeSize, edgeSize, err := m.calculateStorageSizeFromEngine(engine)	1✔
27	if err != nil {	1✔
28	return err	×
29	}	×
30
31	info.sizeMu.Lock()	1✔
32	if !info.sizeInitialized {	2✔
33	info.nodeSize = nodeSize	1✔
34	info.edgeSize = edgeSize	1✔
35	info.totalSize = nodeSize + edgeSize	1✔
36	info.sizeInitialized = true	1✔
37	}	1✔
38	info.sizeMu.Unlock()	1✔
39	return nil	1✔
40	}
41
42	// markStorageSizeDirty marks cached size as stale. The next read/operation will
43	// recalculate from storage.
44	func (m *DatabaseManager) markStorageSizeDirty(databaseName string) {	1✔
45	m.mu.RLock()	1✔
46	info, exists := m.databases[databaseName]	1✔
47	m.mu.RUnlock()	1✔
48	if !exists {	1✔
49	return	×
50	}	×
51	info.sizeMu.Lock()	1✔
52	info.sizeInitialized = false	1✔
53	info.sizeMu.Unlock()	1✔
54	}
55
56	// applyStorageSizeDelta updates cached size counters in O(1). If a previous operation
57	// marked the cache dirty, deltas are ignored until re-initialization.
58	func (m *DatabaseManager) applyStorageSizeDelta(databaseName string, nodeDelta, edgeDelta int64) {	1✔
59	m.mu.RLock()	1✔
60	info, exists := m.databases[databaseName]	1✔
61	m.mu.RUnlock()	1✔
62	if !exists {	2✔
63	return	1✔
64	}	1✔
65	info.sizeMu.Lock()	1✔
66	defer info.sizeMu.Unlock()	1✔
67	if !info.sizeInitialized {	2✔
68	return	1✔
69	}	1✔
70	info.nodeSize += nodeDelta	1✔
71	info.edgeSize += edgeDelta	1✔
72	info.totalSize += nodeDelta + edgeDelta	1✔
73	if info.nodeSize < 0 {	1✔
74	info.nodeSize = 0	×
75	}	×
76	if info.edgeSize < 0 {	1✔
UNCOV 77	info.edgeSize = 0	×
UNCOV 78	}	×
79	if info.totalSize < 0 {	1✔
80	info.totalSize = 0	×
81	}	×
82	}
83
84	func (m *DatabaseManager) calculateStorageSizeFromEngine(engine storage.Engine) (int64, int64, error) {	1✔
85	var nodeSize int64	1✔
86	var edgeSize int64	1✔
87		1✔
88	nodes, err := engine.AllNodes()	1✔
89	if err != nil {	1✔
90	return 0, 0, fmt.Errorf("failed to get all nodes for size calculation: %w", err)	×
91	}	×
92	for _, node := range nodes {	2✔
93	size, sizeErr := calculateNodeSize(node)	1✔
94	if sizeErr != nil {	1✔
95	return 0, 0, fmt.Errorf("failed to calculate node size: %w", sizeErr)	×
96	}	×
97	nodeSize += size	1✔
98	}
99
100	edges, err := engine.AllEdges()	1✔
101	if err != nil {	1✔
102	return 0, 0, fmt.Errorf("failed to get all edges for size calculation: %w", err)	×
103	}	×
104	for _, edge := range edges {	2✔
105	size, sizeErr := calculateEdgeSize(edge)	1✔
106	if sizeErr != nil {	1✔
107	return 0, 0, fmt.Errorf("failed to calculate edge size: %w", sizeErr)	×
108	}	×
109	edgeSize += size	1✔
110	}
111
112	return nodeSize, edgeSize, nil	1✔
113	}

orneryd / NornicDB / 25707480509

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous