115 lines
3.3 KiB
Go
115 lines
3.3 KiB
Go
package db
|
|
|
|
import (
|
|
"fmt"
|
|
"context"
|
|
"database/sql"
|
|
)
|
|
|
|
type Repo struct{ DB *sql.DB }
|
|
|
|
func NewRepo(db *sql.DB) *Repo { return &Repo{DB: db} }
|
|
|
|
// --- Conversations ---
|
|
const qCreateConversation = `
|
|
INSERT INTO conversations (owner_id, title) VALUES (?, ?);
|
|
`
|
|
func (r *Repo) CreateConversation(ctx context.Context, ownerID int64, title string) (int64, error) {
|
|
res, err := r.DB.ExecContext(ctx, qCreateConversation, ownerID, title)
|
|
if err != nil { return 0, err }
|
|
return res.LastInsertId()
|
|
}
|
|
|
|
const qListConversations = `
|
|
SELECT id, owner_id, title, created_at
|
|
FROM conversations
|
|
WHERE owner_id = ?
|
|
ORDER BY created_at DESC, id DESC;
|
|
`
|
|
func (r *Repo) ListConversations(ctx context.Context, ownerID int64) (*sql.Rows, error) {
|
|
return r.DB.QueryContext(ctx, qListConversations, ownerID)
|
|
}
|
|
|
|
// --- Nodes (commits) ---
|
|
const qCreateNode = `
|
|
INSERT INTO nodes (conversation_id, author_kind, content) VALUES (?, ?, ?);
|
|
`
|
|
func (r *Repo) CreateNode(ctx context.Context, convID int64, authorKind, content string) (int64, error) {
|
|
res, err := r.DB.ExecContext(ctx, qCreateNode, convID, authorKind, content)
|
|
if err != nil { return 0, err }
|
|
return res.LastInsertId()
|
|
}
|
|
|
|
// --- Branches ---
|
|
const qCreateBranch = `
|
|
INSERT INTO branches (conversation_id, name, head_node_id) VALUES (?, ?, ?)
|
|
ON DUPLICATE KEY UPDATE head_node_id = VALUES(head_node_id);
|
|
`
|
|
func (r *Repo) CreateOrUpdateBranch(ctx context.Context, convID int64, name string, headNodeID int64) (int64, error) {
|
|
res, err := r.DB.ExecContext(ctx, qCreateBranch, convID, name, headNodeID)
|
|
if err != nil { return 0, err }
|
|
return res.LastInsertId()
|
|
}
|
|
|
|
const qGetBranch = `
|
|
SELECT id, conversation_id, name, head_node_id, created_at
|
|
FROM branches
|
|
WHERE conversation_id = ? AND name = ?
|
|
LIMIT 1;
|
|
`
|
|
func (r *Repo) GetBranch(ctx context.Context, convID int64, name string) *sql.Row {
|
|
return r.DB.QueryRowContext(ctx, qGetBranch, convID, name)
|
|
}
|
|
|
|
const qMoveBranchHead = `
|
|
UPDATE branches SET head_node_id = ? WHERE id = ?;
|
|
`
|
|
func (r *Repo) MoveBranchHead(ctx context.Context, branchID, newHead int64) error {
|
|
_, err := r.DB.ExecContext(ctx, qMoveBranchHead, newHead, branchID)
|
|
return err
|
|
}
|
|
|
|
// --- Edges (DAG) ---
|
|
const qCycleGuard = `
|
|
WITH RECURSIVE downchain AS (
|
|
SELECT e.child_id
|
|
FROM edges e
|
|
WHERE e.parent_id = ?
|
|
UNION ALL
|
|
SELECT e.child_id
|
|
FROM edges e
|
|
JOIN downchain d ON d.child_id = e.parent_id
|
|
)
|
|
SELECT 1 FROM downchain WHERE child_id = ? LIMIT 1;
|
|
`
|
|
|
|
const qInsertEdge = `INSERT IGNORE INTO edges (parent_id, child_id) VALUES (?, ?);`
|
|
|
|
func (r *Repo) LinkEdgeCycleSafe(ctx context.Context, tx *sql.Tx, parentID, childID int64) error {
|
|
// cycle check: is parent reachable from child already?
|
|
var one int
|
|
err := tx.QueryRowContext(ctx, qCycleGuard, childID, parentID).Scan(&one)
|
|
if err != nil && err != sql.ErrNoRows {
|
|
return err
|
|
}
|
|
if err == nil {
|
|
// found a row -> would create a cycle
|
|
return fmt.Errorf("cycle detected: %d -> %d", parentID, childID)
|
|
}
|
|
_, err = tx.ExecContext(ctx, qInsertEdge, parentID, childID)
|
|
return err
|
|
}
|
|
|
|
// --- Ancestor step (latest parent) ---
|
|
const qLatestParent = `
|
|
SELECT p.id, p.conversation_id, p.author_kind, p.content, p.created_at
|
|
FROM edges e
|
|
JOIN nodes p ON p.id = e.parent_id
|
|
WHERE e.child_id = ?
|
|
ORDER BY p.created_at DESC, p.id DESC
|
|
LIMIT 1;
|
|
`
|
|
func (r *Repo) LatestParent(ctx context.Context, childID int64) *sql.Row {
|
|
return r.DB.QueryRowContext(ctx, qLatestParent, childID)
|
|
}
|