Batch community and membership inserts during rebuild

Community rebuild issued one INSERT per community and one per membership
(N+1: a namespace with thousands of nodes meant thousands of round
trips), and loaded full node rows only to read id/file_path. Use
CreateInBatches for both community and membership rows and Select only
the columns grouping needs.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: tae2089

internal/analysis/community/service.go

@@ -11,6 +11,10 @@ import (
 	"gorm.io/gorm"
 )
 
+// communityInsertBatchSize bounds the row count per bulk insert during community rebuild so a
+// large namespace does not issue one INSERT per community or per membership.
+const communityInsertBatchSize = 500
+
 // Config controls directory-based community grouping.
 // @intent define how file paths are collapsed into module community keys
 type Config struct {
@@ -105,10 +109,11 @@ func deleteCommunities(tx *gorm.DB, ns string) error {
 
 // groupNodesByDirectory loads namespace nodes and buckets them by directory key.
 // @intent produce the directory-keyed node groups that drive community creation
+// @domainRule only id and file_path are needed for grouping and membership, so avoid loading full node rows.
 func groupNodesByDirectory(tx *gorm.DB, ctx context.Context, depth int) (map[string][]model.Node, error) {
 	var nodes []model.Node
 	ns := ctxns.FromContext(ctx)
-	if err := tx.Where("namespace = ?", ns).Find(&nodes).Error; err != nil {
+	if err := tx.Model(&model.Node{}).Select("id", "file_path").Where("namespace = ?", ns).Find(&nodes).Error; err != nil {
 		return nil, err
 	}
 
@@ -126,33 +131,42 @@ func groupNodesByDirectory(tx *gorm.DB, ctx context.Context, depth int) (map[str
 // @sideEffect inserts into communities and community_memberships tables
 // @return community lookup by key plus per-node directory key map
 func createCommunitiesAndMemberships(tx *gorm.DB, groups map[string][]model.Node, ns string) (map[string]*model.Community, map[uint]string, error) {
-	communityMap := map[string]*model.Community{}
+	communities := make([]model.Community, 0, len(groups))
 	for key := range groups {
-		c := model.Community{
+		communities = append(communities, model.Community{
 			Namespace: ns,
 			Key:       key,
 			Label:     key,
 			Strategy:  "directory",
-		}
-		if err := tx.Create(&c).Error; err != nil {
+		})
+	}
+	if len(communities) > 0 {
+		if err := tx.CreateInBatches(communities, communityInsertBatchSize).Error; err != nil {
 			return nil, nil, err
 		}
-		communityMap[key] = &c
+	}
+	communityMap := make(map[string]*model.Community, len(communities))
+	for i := range communities {
+		communityMap[communities[i].Key] = &communities[i]
 	}
 
 	nodeComm := map[uint]string{}
-	for key, ns := range groups {
-		for _, n := range ns {
-			m := model.CommunityMembership{
-				CommunityID: communityMap[key].ID,
+	memberships := make([]model.CommunityMembership, 0, len(groups))
+	for key, nodes := range groups {
+		communityID := communityMap[key].ID
+		for _, n := range nodes {
+			memberships = append(memberships, model.CommunityMembership{
+				CommunityID: communityID,
 				NodeID:      n.ID,
-			}
-			if err := tx.Create(&m).Error; err != nil {
-				return nil, nil, err
-			}
+			})
 			nodeComm[n.ID] = key
 		}
 	}
+	if len(memberships) > 0 {
+		if err := tx.CreateInBatches(memberships, communityInsertBatchSize).Error; err != nil {
+			return nil, nil, err
+		}
+	}
 
 	return communityMap, nodeComm, nil
 }

internal/analysis/community/service_test.go

@@ -3,7 +3,9 @@ package community
 import (
 	"context"
 	"fmt"
+	"strings"
 	"testing"
+	"time"
 
 	"github.com/tae2089/code-context-graph/internal/ctxns"
 	"github.com/tae2089/code-context-graph/internal/model"
@@ -63,6 +65,42 @@ func seedEdge(t *testing.T, db *gorm.DB, from, to uint) {
 	}
 }
 
+type insertCountLogger struct {
+	gormlogger.Interface
+	membershipInserts int
+}
+
+func (l *insertCountLogger) LogMode(gormlogger.LogLevel) gormlogger.Interface { return l }
+func (l *insertCountLogger) Trace(_ context.Context, _ time.Time, fc func() (string, int64), _ error) {
+	sql, _ := fc()
+	if strings.Contains(sql, "INSERT INTO") && strings.Contains(sql, "community_memberships") {
+		l.membershipInserts++
+	}
+}
+
+func TestRebuild_BatchesMembershipInserts(t *testing.T) {
+	counter := &insertCountLogger{Interface: gormlogger.Discard}
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{Logger: counter})
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	if err := gormstore.New(db).AutoMigrate(); err != nil {
+		t.Fatalf("migrate: %v", err)
+	}
+	// 40 nodes in one directory => 40 memberships that must not be 40 separate INSERTs.
+	for i := uint(1); i <= 40; i++ {
+		seedNode(t, db, i, fmt.Sprintf("N%d", i), fmt.Sprintf("pkg/f%d.go", i))
+	}
+
+	counter.membershipInserts = 0
+	if _, err := New(db).Rebuild(context.Background(), Config{Depth: 1}); err != nil {
+		t.Fatal(err)
+	}
+	if counter.membershipInserts != 1 {
+		t.Fatalf("expected memberships to insert in a single batch, got %d INSERT statements", counter.membershipInserts)
+	}
+}
+
 func TestRebuild_GroupsByDirectory(t *testing.T) {
 	db := setupDB(t)
 	seedNode(t, db, 1, "X", "a/x.go")