refactor(query): extract shared helpers to eliminate duckdb/sqlite duplication (#137)

```
# Summary

  - Extract 7 duplicate data-mapping methods from duckdb.go and sqlite.go into a new shared.go file with a tablePrefix parameter (""
  for SQLite, "sqlite_db." for DuckDB's sqlite_scan fallback)
  - Reduce duplicate code from ~191 lines across 7 regions to ~80 lines across 2 regions (residual duplication is in ListMessages row
  scanning and GetGmailIDsByFilter query construction, which differ structurally between engines)
  - Remove unused imports (bytes, compress/zlib, io, mime) from both engine files

# Extracted helpers

  ┌───────────────────────────┬────────────────────────────────────────────────────────┐
  │         Function          │                        Purpose                         │
  ├───────────────────────────┼────────────────────────────────────────────────────────┤
  │ fetchLabelsForMessageList │ Batch label fetching for message list views            │
  ├───────────────────────────┼────────────────────────────────────────────────────────┤
  │ fetchMessageLabelsDetail  │ Label fetching for single message detail               │
  ├───────────────────────────┼────────────────────────────────────────────────────────┤
  │ fetchParticipantsShared   │ Participant fetching for message detail                │
  ├───────────────────────────┼────────────────────────────────────────────────────────┤
  │ fetchAttachmentsShared    │ Attachment fetching for message detail                 │
  ├───────────────────────────┼────────────────────────────────────────────────────────┤
  │ extractBodyFromRawShared  │ MIME body extraction from compressed raw data          │
  ├───────────────────────────┼────────────────────────────────────────────────────────┤
  │ getMessageByQueryShared   │ Full message detail retrieval (orchestrates the above) │
  ├───────────────────────────┼────────────────────────────────────────────────────────┤
  │ collectGmailIDs           │ Row scanning for Gmail ID queries                      │
  └───────────────────────────┴────────────────────────────────────────────────────────┘

# Test plan

  - go build ./... compiles cleanly
  - go vet ./... passes
  - make test — all tests pass
  - samesame --match 20 internal/query/*.go confirms duplicate regions eliminated (7 → 2)

  🤖 Generated with Claude Code
```

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Wes McKinney <wesmckinn+git@gmail.com>

Author: 3 people

.githooks/post-commit

@@ -1,13 +1,10 @@
 package query
 
 import (
-	"bytes"
-	"compress/zlib"
 	"context"
 	"database/sql"
 	"encoding/json"
 	"fmt"
-	"io"
 	"log"
 	"path/filepath"
 	"runtime"
@@ -17,7 +14,6 @@ import (
 	"time"
 
 	_ "github.com/marcboeker/go-duckdb"
-	"github.com/wesm/msgvault/internal/mime"
 	"github.com/wesm/msgvault/internal/search"
 )
 
@@ -1161,41 +1157,7 @@ func (e *DuckDBEngine) fetchLabelsForMessages(ctx context.Context, messages []Me
 		return nil
 	}
 
-	// Build message ID list
-	ids := make([]interface{}, len(messages))
-	placeholders := make([]string, len(messages))
-	idToIndex := make(map[int64]int)
-	for i, msg := range messages {
-		ids[i] = msg.ID
-		placeholders[i] = "?"
-		idToIndex[msg.ID] = i
-	}
-
-	query := fmt.Sprintf(`
-		SELECT ml.message_id, l.name
-		FROM sqlite_db.message_labels ml
-		JOIN sqlite_db.labels l ON l.id = ml.label_id
-		WHERE ml.message_id IN (%s)
-	`, strings.Join(placeholders, ","))
-
-	rows, err := e.db.QueryContext(ctx, query, ids...)
-	if err != nil {
-		return err
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var msgID int64
-		var labelName string
-		if err := rows.Scan(&msgID, &labelName); err != nil {
-			return err
-		}
-		if idx, ok := idToIndex[msgID]; ok {
-			messages[idx].Labels = append(messages[idx].Labels, labelName)
-		}
-	}
-
-	return rows.Err()
+	return fetchLabelsForMessageList(ctx, e.db, "sqlite_db.", messages)
 }
 
 // GetMessage retrieves a full message from SQLite.
@@ -1240,205 +1202,7 @@ func (e *DuckDBEngine) GetAttachment(ctx context.Context, id int64) (*Attachment
 }
 
 func (e *DuckDBEngine) getMessageByQuery(ctx context.Context, whereClause string, args ...interface{}) (*MessageDetail, error) {
-	query := fmt.Sprintf(`
-		SELECT
-			m.id,
-			m.source_message_id,
-			m.conversation_id,
-			COALESCE(c.source_conversation_id, ''),
-			COALESCE(m.subject, ''),
-			COALESCE(m.snippet, ''),
-			m.sent_at,
-			m.received_at,
-			COALESCE(m.size_estimate, 0),
-			m.has_attachments
-		FROM sqlite_db.messages m
-		LEFT JOIN sqlite_db.conversations c ON c.id = m.conversation_id
-		WHERE %s
-	`, whereClause)
-
-	var msg MessageDetail
-	var sentAt, receivedAt sql.NullTime
-	err := e.db.QueryRowContext(ctx, query, args...).Scan(
-		&msg.ID,
-		&msg.SourceMessageID,
-		&msg.ConversationID,
-		&msg.SourceConversationID,
-		&msg.Subject,
-		&msg.Snippet,
-		&sentAt,
-		&receivedAt,
-		&msg.SizeEstimate,
-		&msg.HasAttachments,
-	)
-	if err == sql.ErrNoRows {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, fmt.Errorf("get message: %w", err)
-	}
-
-	if sentAt.Valid {
-		msg.SentAt = sentAt.Time
-	}
-	if receivedAt.Valid {
-		t := receivedAt.Time
-		msg.ReceivedAt = &t
-	}
-
-	// Fetch body from separate table (PK lookup)
-	var bodyText, bodyHTML sql.NullString
-	err = e.db.QueryRowContext(ctx, `
-		SELECT body_text, body_html FROM sqlite_db.message_bodies WHERE message_id = ?
-	`, msg.ID).Scan(&bodyText, &bodyHTML)
-	if err == nil {
-		if bodyText.Valid {
-			msg.BodyText = bodyText.String
-		}
-		if bodyHTML.Valid {
-			msg.BodyHTML = bodyHTML.String
-		}
-	} else if err != sql.ErrNoRows {
-		return nil, fmt.Errorf("get message body: %w", err)
-	}
-
-	// If body is empty, try to extract from raw MIME
-	if msg.BodyText == "" && msg.BodyHTML == "" {
-		if body, err := e.extractBodyFromRaw(ctx, msg.ID); err == nil && body != "" {
-			msg.BodyText = body
-		}
-	}
-
-	// Fetch participants
-	if err := e.fetchParticipants(ctx, &msg); err != nil {
-		return nil, fmt.Errorf("fetch participants: %w", err)
-	}
-
-	// Fetch labels
-	if err := e.fetchMessageLabels(ctx, &msg); err != nil {
-		return nil, fmt.Errorf("fetch labels: %w", err)
-	}
-
-	// Fetch attachments
-	if err := e.fetchAttachments(ctx, &msg); err != nil {
-		return nil, fmt.Errorf("fetch attachments: %w", err)
-	}
-
-	return &msg, nil
-}
-
-// extractBodyFromRaw extracts text body from compressed MIME data.
-func (e *DuckDBEngine) extractBodyFromRaw(ctx context.Context, messageID int64) (string, error) {
-	var compressed []byte
-	var compression sql.NullString
-
-	err := e.db.QueryRowContext(ctx, `
-		SELECT raw_data, compression FROM sqlite_db.message_raw WHERE message_id = ?
-	`, messageID).Scan(&compressed, &compression)
-	if err != nil {
-		return "", err
-	}
-
-	var rawData []byte
-	if compression.Valid && compression.String == "zlib" {
-		r, err := zlib.NewReader(bytes.NewReader(compressed))
-		if err != nil {
-			return "", err
-		}
-		defer r.Close()
-		rawData, err = io.ReadAll(r)
-		if err != nil {
-			return "", err
-		}
-	} else {
-		rawData = compressed
-	}
-
-	// Parse MIME and extract text
-	parsed, err := mime.Parse(rawData)
-	if err != nil {
-		return "", err
-	}
-
-	return parsed.GetBodyText(), nil
-}
-
-func (e *DuckDBEngine) fetchParticipants(ctx context.Context, msg *MessageDetail) error {
-	rows, err := e.db.QueryContext(ctx, `
-		SELECT mr.recipient_type, p.email_address, COALESCE(mr.display_name, p.display_name, '')
-		FROM sqlite_db.message_recipients mr
-		JOIN sqlite_db.participants p ON p.id = mr.participant_id
-		WHERE mr.message_id = ?
-	`, msg.ID)
-	if err != nil {
-		return err
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var recipType, email, name string
-		if err := rows.Scan(&recipType, &email, &name); err != nil {
-			return err
-		}
-		addr := Address{Email: email, Name: name}
-		switch recipType {
-		case "from":
-			msg.From = append(msg.From, addr)
-		case "to":
-			msg.To = append(msg.To, addr)
-		case "cc":
-			msg.Cc = append(msg.Cc, addr)
-		case "bcc":
-			msg.Bcc = append(msg.Bcc, addr)
-		}
-	}
-
-	return rows.Err()
-}
-
-func (e *DuckDBEngine) fetchMessageLabels(ctx context.Context, msg *MessageDetail) error {
-	rows, err := e.db.QueryContext(ctx, `
-		SELECT l.name
-		FROM sqlite_db.message_labels ml
-		JOIN sqlite_db.labels l ON l.id = ml.label_id
-		WHERE ml.message_id = ?
-	`, msg.ID)
-	if err != nil {
-		return err
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var name string
-		if err := rows.Scan(&name); err != nil {
-			return err
-		}
-		msg.Labels = append(msg.Labels, name)
-	}
-
-	return rows.Err()
-}
-
-func (e *DuckDBEngine) fetchAttachments(ctx context.Context, msg *MessageDetail) error {
-	rows, err := e.db.QueryContext(ctx, `
-		SELECT id, COALESCE(filename, ''), COALESCE(mime_type, ''), COALESCE(size, 0), COALESCE(content_hash, '')
-		FROM sqlite_db.attachments
-		WHERE message_id = ?
-	`, msg.ID)
-	if err != nil {
-		return err
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var att AttachmentInfo
-		if err := rows.Scan(&att.ID, &att.Filename, &att.MimeType, &att.Size, &att.ContentHash); err != nil {
-			return err
-		}
-		msg.Attachments = append(msg.Attachments, att)
-	}
-
-	return rows.Err()
+	return getMessageByQueryShared(ctx, e.db, "sqlite_db.", whereClause, args...)
 }
 
 // Search performs a Gmail-style search query.
@@ -1769,20 +1533,7 @@ func (e *DuckDBEngine) GetGmailIDsByFilter(ctx context.Context, filter MessageFi
 	}
 	defer rows.Close()
 
-	var ids []string
-	for rows.Next() {
-		var id string
-		if err := rows.Scan(&id); err != nil {
-			return nil, fmt.Errorf("scan gmail id: %w", err)
-		}
-		ids = append(ids, id)
-	}
-
-	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("iterate gmail ids: %w", err)
-	}
-
-	return ids, nil
+	return collectGmailIDs(rows)
 }
 
 // HasParquetData checks if Parquet files exist and are usable.