making sure counts clear cache properly

Author: orneryd

pkg/cypher/cache.go

@@ -587,6 +587,8 @@ func (sc *SmartQueryCache) Put(cypher string, params map[string]interface{}, res
 
 // InvalidateLabels removes only cache entries that depend on the given labels.
 // This is much more efficient than full invalidation for multi-label workloads.
+// Also invalidates queries with NO labels (like "MATCH (n) RETURN count(n)")
+// since they match all nodes and are affected by any label change.
 func (sc *SmartQueryCache) InvalidateLabels(labels []string) {
 	sc.mu.Lock()
 	defer sc.mu.Unlock()
@@ -602,6 +604,14 @@ func (sc *SmartQueryCache) InvalidateLabels(labels []string) {
 		}
 	}
 
+	// Also invalidate queries with NO labels (they match all nodes)
+	// These queries are affected by ANY node creation/deletion
+	for key, entry := range sc.cache {
+		if len(entry.labels) == 0 {
+			keysToRemove[key] = struct{}{}
+		}
+	}
+
 	// Remove collected entries
 	for key := range keysToRemove {
 		sc.removeEntry(key)

pkg/cypher/count_bug_test.go

@@ -0,0 +1,122 @@
+package cypher
+
+import (
+	"context"
+	"testing"
+
+	"github.com/orneryd/nornicdb/pkg/storage"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestBug_CountReturnsZeroWhenNodesExist reproduces the bug where:
+// - MATCH (n) RETURN n returns actual nodes
+// - MATCH (n) RETURN count(n) returns 0
+// - Storage NodeCount() returns 0
+// But nodes clearly exist in the database.
+func TestBug_CountReturnsZeroWhenNodesExist(t *testing.T) {
+	store := storage.NewMemoryEngine()
+	defer store.Close()
+	exec := NewStorageExecutor(store)
+	ctx := context.Background()
+
+	// Create 5 nodes
+	for i := 0; i < 5; i++ {
+		_, err := exec.Execute(ctx, "CREATE (n:TestNode {idx: $idx})", map[string]any{"idx": i})
+		require.NoError(t, err)
+	}
+
+	// Verify nodes exist by returning them
+	result, err := exec.Execute(ctx, "MATCH (n:TestNode) RETURN n", nil)
+	require.NoError(t, err)
+	actualNodeCount := len(result.Rows)
+	t.Logf("MATCH (n) RETURN n returned %d rows", actualNodeCount)
+	assert.Equal(t, 5, actualNodeCount, "Should return 5 nodes")
+
+	// Now test count(n)
+	result, err = exec.Execute(ctx, "MATCH (n:TestNode) RETURN count(n) as cnt", nil)
+	require.NoError(t, err)
+	require.Len(t, result.Rows, 1)
+	countN := result.Rows[0][0]
+	t.Logf("MATCH (n) RETURN count(n) returned: %v (type: %T)", countN, countN)
+	
+	// Convert to int64 for comparison
+	var countNInt int64
+	switch v := countN.(type) {
+	case int64:
+		countNInt = v
+	case int:
+		countNInt = int64(v)
+	case float64:
+		countNInt = int64(v)
+	}
+	assert.Equal(t, int64(5), countNInt, "count(n) should return 5")
+
+	// Test count(*)
+	result, err = exec.Execute(ctx, "MATCH (n:TestNode) RETURN count(*) as cnt", nil)
+	require.NoError(t, err)
+	require.Len(t, result.Rows, 1)
+	countStar := result.Rows[0][0]
+	t.Logf("MATCH (n) RETURN count(*) returned: %v (type: %T)", countStar, countStar)
+	
+	var countStarInt int64
+	switch v := countStar.(type) {
+	case int64:
+		countStarInt = v
+	case int:
+		countStarInt = int64(v)
+	case float64:
+		countStarInt = int64(v)
+	}
+	assert.Equal(t, int64(5), countStarInt, "count(*) should return 5")
+
+	// Test storage layer NodeCount
+	nodeCount, err := store.NodeCount()
+	require.NoError(t, err)
+	t.Logf("Storage NodeCount() returned: %d", nodeCount)
+	assert.Equal(t, int64(5), nodeCount, "Storage NodeCount should return 5")
+}
+
+// TestBug_CountAfterDeleteAndRecreate tests count behavior after delete/recreate cycle
+func TestBug_CountAfterDeleteAndRecreate(t *testing.T) {
+	store := storage.NewMemoryEngine()
+	defer store.Close()
+	exec := NewStorageExecutor(store)
+	ctx := context.Background()
+
+	// Create initial nodes
+	for i := 0; i < 3; i++ {
+		_, err := exec.Execute(ctx, "CREATE (n:CycleTest {idx: $idx})", map[string]any{"idx": i})
+		require.NoError(t, err)
+	}
+
+	// Verify count
+	nodeCount, _ := store.NodeCount()
+	t.Logf("After initial create: NodeCount = %d", nodeCount)
+	assert.Equal(t, int64(3), nodeCount)
+
+	// Delete all nodes
+	_, err := exec.Execute(ctx, "MATCH (n:CycleTest) DELETE n", nil)
+	require.NoError(t, err)
+
+	nodeCount, _ = store.NodeCount()
+	t.Logf("After delete: NodeCount = %d", nodeCount)
+	assert.Equal(t, int64(0), nodeCount)
+
+	// Recreate nodes
+	for i := 0; i < 5; i++ {
+		_, err := exec.Execute(ctx, "CREATE (n:CycleTest {idx: $idx})", map[string]any{"idx": i})
+		require.NoError(t, err)
+	}
+
+	nodeCount, _ = store.NodeCount()
+	t.Logf("After recreate: NodeCount = %d", nodeCount)
+	assert.Equal(t, int64(5), nodeCount, "NodeCount should be 5 after recreating nodes")
+
+	// Verify with Cypher count
+	result, err := exec.Execute(ctx, "MATCH (n:CycleTest) RETURN count(n) as cnt", nil)
+	require.NoError(t, err)
+	require.Len(t, result.Rows, 1)
+	cypherCount := result.Rows[0][0]
+	t.Logf("Cypher count(n) after recreate: %v", cypherCount)
+}

pkg/cypher/count_direct_return_bug_test.go

@@ -0,0 +1,167 @@
+package cypher
+
+import (
+	"context"
+	"testing"
+
+	"github.com/orneryd/nornicdb/pkg/storage"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestBug_CountDirectReturnVsWithReturn reproduces the bug where:
+// - MATCH (n) RETURN count(n) returns 0 (WRONG)
+// - MATCH (n) WITH n RETURN count(n) returns correct count (CORRECT)
+func TestBug_CountDirectReturnVsWithReturn(t *testing.T) {
+	store := storage.NewMemoryEngine()
+	defer store.Close()
+	exec := NewStorageExecutor(store)
+	ctx := context.Background()
+
+	// Create 10 nodes
+	for i := 0; i < 10; i++ {
+		_, err := exec.Execute(ctx, "CREATE (n:CountTest {idx: $idx})", map[string]any{"idx": i})
+		require.NoError(t, err)
+	}
+
+	// Verify nodes exist
+	result, err := exec.Execute(ctx, "MATCH (n:CountTest) RETURN n", nil)
+	require.NoError(t, err)
+	t.Logf("MATCH (n) RETURN n: %d rows", len(result.Rows))
+	require.Len(t, result.Rows, 10, "Should have 10 nodes")
+
+	// Test 1: Direct count in RETURN (this is the broken query)
+	t.Run("direct_count_in_return", func(t *testing.T) {
+		result, err := exec.Execute(ctx, "MATCH (n:CountTest) RETURN count(n) as cnt", nil)
+		require.NoError(t, err)
+		require.Len(t, result.Rows, 1)
+
+		cnt := result.Rows[0][0]
+		t.Logf("MATCH (n) RETURN count(n): %v (type: %T)", cnt, cnt)
+
+		var countVal int64
+		switch v := cnt.(type) {
+		case int64:
+			countVal = v
+		case int:
+			countVal = int64(v)
+		case float64:
+			countVal = int64(v)
+		}
+		assert.Equal(t, int64(10), countVal, "MATCH (n) RETURN count(n) should return 10")
+	})
+
+	// Test 2: Count with WITH clause (this works correctly)
+	t.Run("count_with_with_clause", func(t *testing.T) {
+		result, err := exec.Execute(ctx, "MATCH (n:CountTest) WITH n RETURN count(n) as cnt", nil)
+		require.NoError(t, err)
+		require.Len(t, result.Rows, 1)
+
+		cnt := result.Rows[0][0]
+		t.Logf("MATCH (n) WITH n RETURN count(n): %v (type: %T)", cnt, cnt)
+
+		var countVal int64
+		switch v := cnt.(type) {
+		case int64:
+			countVal = v
+		case int:
+			countVal = int64(v)
+		case float64:
+			countVal = int64(v)
+		}
+		assert.Equal(t, int64(10), countVal, "MATCH (n) WITH n RETURN count(n) should return 10")
+	})
+
+	// Test 3: count(*) direct
+	t.Run("count_star_direct", func(t *testing.T) {
+		result, err := exec.Execute(ctx, "MATCH (n:CountTest) RETURN count(*) as cnt", nil)
+		require.NoError(t, err)
+		require.Len(t, result.Rows, 1)
+
+		cnt := result.Rows[0][0]
+		t.Logf("MATCH (n) RETURN count(*): %v (type: %T)", cnt, cnt)
+
+		var countVal int64
+		switch v := cnt.(type) {
+		case int64:
+			countVal = v
+		case int:
+			countVal = int64(v)
+		case float64:
+			countVal = int64(v)
+		}
+		assert.Equal(t, int64(10), countVal, "MATCH (n) RETURN count(*) should return 10")
+	})
+
+	// Test 4: count without label filter
+	t.Run("count_all_nodes_direct", func(t *testing.T) {
+		result, err := exec.Execute(ctx, "MATCH (n) RETURN count(n) as cnt", nil)
+		require.NoError(t, err)
+		require.Len(t, result.Rows, 1)
+
+		cnt := result.Rows[0][0]
+		t.Logf("MATCH (n) RETURN count(n) [all nodes]: %v (type: %T)", cnt, cnt)
+
+		var countVal int64
+		switch v := cnt.(type) {
+		case int64:
+			countVal = v
+		case int:
+			countVal = int64(v)
+		case float64:
+			countVal = int64(v)
+		}
+		assert.Equal(t, int64(10), countVal, "MATCH (n) RETURN count(n) [all nodes] should return 10")
+	})
+}
+
+// TestBug_CountAfterDeleteRecreate tests count behavior after delete/recreate
+func TestBug_CountAfterDeleteRecreate(t *testing.T) {
+	store := storage.NewMemoryEngine()
+	defer store.Close()
+	exec := NewStorageExecutor(store)
+	ctx := context.Background()
+
+	// Create initial nodes
+	for i := 0; i < 5; i++ {
+		_, err := exec.Execute(ctx, "CREATE (n:Cycle {idx: $idx})", map[string]any{"idx": i})
+		require.NoError(t, err)
+	}
+
+	// Verify initial count
+	result, err := exec.Execute(ctx, "MATCH (n:Cycle) RETURN count(n) as cnt", nil)
+	require.NoError(t, err)
+	t.Logf("Initial count: %v", result.Rows[0][0])
+
+	// Delete all
+	_, err = exec.Execute(ctx, "MATCH (n:Cycle) DELETE n", nil)
+	require.NoError(t, err)
+
+	// Verify delete count
+	result, err = exec.Execute(ctx, "MATCH (n:Cycle) RETURN count(n) as cnt", nil)
+	require.NoError(t, err)
+	t.Logf("After delete count: %v", result.Rows[0][0])
+
+	// Recreate
+	for i := 0; i < 3; i++ {
+		_, err := exec.Execute(ctx, "CREATE (n:Cycle {idx: $idx, recreated: true})", map[string]any{"idx": i + 100})
+		require.NoError(t, err)
+	}
+
+	// Verify recreate count
+	result, err = exec.Execute(ctx, "MATCH (n:Cycle) RETURN count(n) as cnt", nil)
+	require.NoError(t, err)
+	cnt := result.Rows[0][0]
+	t.Logf("After recreate count: %v", cnt)
+
+	var countVal int64
+	switch v := cnt.(type) {
+	case int64:
+		countVal = v
+	case int:
+		countVal = int64(v)
+	case float64:
+		countVal = int64(v)
+	}
+	assert.Equal(t, int64(3), countVal, "Count after recreate should be 3")
+}