- 4 大修复: 缺口分类向量化 + Schema 23字段 + Consolidation走Rust IPC + Client SDK - BGE ONNX: deploy/bge_embed_server.py + systemd unit,1024维本地推理 - Rust sidecar: 8模块完整,DBSCAN/衰减/修剪/质量回溯/整合报告 - Go: zhiyid 7821端口,37个API端点,多Agent架构
666 lines
19 KiB
Go
666 lines
19 KiB
Go
// 织忆 MemoryWeave — SQLite 持久存储后端(CGO,实现 LanceDB 接口)
|
|
package storage
|
|
|
|
/*
|
|
#cgo LDFLAGS: -lsqlite3
|
|
#include <sqlite3.h>
|
|
#include <stdlib.h>
|
|
*/
|
|
import "C"
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"sort"
|
|
"sync"
|
|
"time"
|
|
"unsafe"
|
|
|
|
"github.com/xiaoxue/memoryweave/internal/models"
|
|
)
|
|
|
|
// SQLiteClient CGO 直连 SQLite3,实现 LanceDB 接口。
|
|
// 生产环境持久化存储,替代 MemLanceClient。
|
|
type SQLiteClient struct {
|
|
mu sync.RWMutex
|
|
db *C.sqlite3
|
|
path string
|
|
}
|
|
|
|
func NewSQLiteClient(dbPath string) (*SQLiteClient, error) {
|
|
if dbPath == "" {
|
|
dbPath = "/var/lib/zhiyi/data/memoryweave.db"
|
|
}
|
|
|
|
cPath := C.CString(dbPath)
|
|
defer C.free(unsafe.Pointer(cPath))
|
|
|
|
var db *C.sqlite3
|
|
rc := C.sqlite3_open(cPath, &db)
|
|
if rc != C.SQLITE_OK {
|
|
errMsg := C.GoString(C.sqlite3_errmsg(db))
|
|
C.sqlite3_close(db)
|
|
return nil, fmt.Errorf("sqlite open: %s", errMsg)
|
|
}
|
|
|
|
// 性能优化
|
|
C.sqlite3_exec(db, C.CString("PRAGMA journal_mode=WAL"), nil, nil, nil)
|
|
C.sqlite3_exec(db, C.CString("PRAGMA synchronous=NORMAL"), nil, nil, nil)
|
|
C.sqlite3_exec(db, C.CString("PRAGMA busy_timeout=5000"), nil, nil, nil)
|
|
C.sqlite3_exec(db, C.CString("PRAGMA cache_size=-20000"), nil, nil, nil)
|
|
|
|
sc := &SQLiteClient{db: db, path: dbPath}
|
|
if err := sc.migrate(); err != nil {
|
|
C.sqlite3_close(db)
|
|
return nil, err
|
|
}
|
|
return sc, nil
|
|
}
|
|
|
|
func (sc *SQLiteClient) Close() error {
|
|
sc.mu.Lock()
|
|
defer sc.mu.Unlock()
|
|
if sc.db != nil {
|
|
C.sqlite3_close(sc.db)
|
|
sc.db = nil
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ─── migration ────────────────────────────────────────
|
|
|
|
func (sc *SQLiteClient) migrate() error {
|
|
sqls := []string{
|
|
`CREATE TABLE IF NOT EXISTS memories (
|
|
id TEXT PRIMARY KEY,
|
|
agent_id TEXT NOT NULL,
|
|
namespace TEXT NOT NULL DEFAULT '',
|
|
content TEXT NOT NULL,
|
|
category TEXT NOT NULL DEFAULT 'general',
|
|
vector BLOB,
|
|
tier TEXT NOT NULL DEFAULT 'normal',
|
|
importance REAL DEFAULT 1.0,
|
|
quality_score REAL DEFAULT 0.0,
|
|
recall_count INTEGER DEFAULT 0,
|
|
useful_count INTEGER DEFAULT 0,
|
|
not_useful_count INTEGER DEFAULT 0,
|
|
freshness TEXT DEFAULT 'fresh',
|
|
version INTEGER DEFAULT 1,
|
|
version_history TEXT DEFAULT '[]',
|
|
source TEXT DEFAULT '',
|
|
volatile_flag INTEGER DEFAULT 0,
|
|
is_deleted INTEGER DEFAULT 0,
|
|
depends_on TEXT DEFAULT '[]',
|
|
derived_from TEXT DEFAULT '',
|
|
last_recalled_at TEXT DEFAULT '',
|
|
created_at TEXT NOT NULL,
|
|
updated_at TEXT NOT NULL
|
|
)`,
|
|
`CREATE TABLE IF NOT EXISTS episodes (
|
|
id TEXT PRIMARY KEY,
|
|
agent_id TEXT NOT NULL,
|
|
namespace TEXT NOT NULL DEFAULT '',
|
|
content TEXT NOT NULL,
|
|
category TEXT NOT NULL DEFAULT 'general',
|
|
distilled_to TEXT DEFAULT '',
|
|
distill_status TEXT DEFAULT 'pending',
|
|
created_at TEXT NOT NULL
|
|
)`,
|
|
`CREATE TABLE IF NOT EXISTS tombstones (
|
|
id TEXT PRIMARY KEY,
|
|
original_id TEXT NOT NULL,
|
|
content_snapshot TEXT DEFAULT '',
|
|
namespace TEXT DEFAULT '',
|
|
reason TEXT NOT NULL DEFAULT '',
|
|
merged_into TEXT DEFAULT '',
|
|
deleted_at TEXT NOT NULL
|
|
)`,
|
|
`CREATE TABLE IF NOT EXISTS version_history (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
memory_id TEXT NOT NULL,
|
|
version INTEGER NOT NULL,
|
|
content TEXT NOT NULL,
|
|
source TEXT DEFAULT '',
|
|
reason TEXT DEFAULT '',
|
|
timestamp TEXT NOT NULL,
|
|
FOREIGN KEY (memory_id) REFERENCES memories(id)
|
|
)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_memories_namespace ON memories(namespace)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_memories_deleted ON memories(is_deleted)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_episodes_agent ON episodes(agent_id)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_version_history_mem ON version_history(memory_id)`,
|
|
}
|
|
|
|
for _, s := range sqls {
|
|
if err := sc.exec(s); err != nil {
|
|
return fmt.Errorf("migrate: %w", err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ─── CGO helpers ──────────────────────────────────────
|
|
|
|
func (sc *SQLiteClient) exec(sql string) error {
|
|
cSQL := C.CString(sql)
|
|
defer C.free(unsafe.Pointer(cSQL))
|
|
|
|
var errMsg *C.char
|
|
rc := C.sqlite3_exec(sc.db, cSQL, nil, nil, &errMsg)
|
|
if rc != C.SQLITE_OK {
|
|
msg := C.GoString(errMsg)
|
|
C.sqlite3_free(unsafe.Pointer(errMsg))
|
|
return fmt.Errorf("sqlite: %s", msg)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (sc *SQLiteClient) execWithArgs(sql string, args ...interface{}) error {
|
|
cSQL := C.CString(sql)
|
|
defer C.free(unsafe.Pointer(cSQL))
|
|
|
|
var stmt *C.sqlite3_stmt
|
|
rc := C.sqlite3_prepare_v2(sc.db, cSQL, C.int(len(sql)), &stmt, nil)
|
|
if rc != C.SQLITE_OK {
|
|
return fmt.Errorf("sqlite prepare: %s", C.GoString(C.sqlite3_errmsg(sc.db)))
|
|
}
|
|
defer C.sqlite3_finalize(stmt)
|
|
|
|
for i, arg := range args {
|
|
idx := C.int(i + 1)
|
|
switch v := arg.(type) {
|
|
case nil:
|
|
C.sqlite3_bind_null(stmt, idx)
|
|
case int:
|
|
C.sqlite3_bind_int64(stmt, idx, C.sqlite3_int64(v))
|
|
case int64:
|
|
C.sqlite3_bind_int64(stmt, idx, C.sqlite3_int64(v))
|
|
case float64:
|
|
C.sqlite3_bind_double(stmt, idx, C.double(v))
|
|
case bool:
|
|
if v {
|
|
C.sqlite3_bind_int(stmt, idx, 1)
|
|
} else {
|
|
C.sqlite3_bind_int(stmt, idx, 0)
|
|
}
|
|
case string:
|
|
cStr := C.CString(v)
|
|
C.sqlite3_bind_text(stmt, idx, cStr, C.int(len(v)), (*[0]byte)(C.free))
|
|
case []byte:
|
|
if len(v) == 0 {
|
|
C.sqlite3_bind_null(stmt, idx)
|
|
} else {
|
|
C.sqlite3_bind_blob(stmt, idx, unsafe.Pointer(&v[0]), C.int(len(v)), nil)
|
|
}
|
|
default:
|
|
return fmt.Errorf("unsupported arg type %T", arg)
|
|
}
|
|
}
|
|
|
|
rc = C.sqlite3_step(stmt)
|
|
if rc != C.SQLITE_DONE && rc != C.SQLITE_ROW {
|
|
return fmt.Errorf("sqlite step: %s", C.GoString(C.sqlite3_errmsg(sc.db)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type sqliteRow map[string]interface{}
|
|
|
|
func (sc *SQLiteClient) query(sql string) ([]sqliteRow, error) {
|
|
cSQL := C.CString(sql)
|
|
defer C.free(unsafe.Pointer(cSQL))
|
|
|
|
var stmt *C.sqlite3_stmt
|
|
rc := C.sqlite3_prepare_v2(sc.db, cSQL, C.int(len(sql)), &stmt, nil)
|
|
if rc != C.SQLITE_OK {
|
|
return nil, fmt.Errorf("sqlite prepare: %s", C.GoString(C.sqlite3_errmsg(sc.db)))
|
|
}
|
|
defer C.sqlite3_finalize(stmt)
|
|
|
|
var rows []sqliteRow
|
|
for {
|
|
rc = C.sqlite3_step(stmt)
|
|
if rc == C.SQLITE_DONE {
|
|
break
|
|
}
|
|
if rc != C.SQLITE_ROW {
|
|
return nil, fmt.Errorf("sqlite step: %s", C.GoString(C.sqlite3_errmsg(sc.db)))
|
|
}
|
|
|
|
colCount := int(C.sqlite3_column_count(stmt))
|
|
row := make(sqliteRow, colCount)
|
|
for i := 0; i < colCount; i++ {
|
|
name := C.GoString(C.sqlite3_column_name(stmt, C.int(i)))
|
|
colType := C.sqlite3_column_type(stmt, C.int(i))
|
|
switch colType {
|
|
case C.SQLITE_INTEGER:
|
|
row[name] = int64(C.sqlite3_column_int64(stmt, C.int(i)))
|
|
case C.SQLITE_FLOAT:
|
|
row[name] = float64(C.sqlite3_column_double(stmt, C.int(i)))
|
|
case C.SQLITE_TEXT:
|
|
row[name] = C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, C.int(i)))))
|
|
case C.SQLITE_BLOB:
|
|
n := int(C.sqlite3_column_bytes(stmt, C.int(i)))
|
|
ptr := C.sqlite3_column_blob(stmt, C.int(i))
|
|
blob := make([]byte, n)
|
|
if n > 0 {
|
|
copy(blob, (*[1 << 30]byte)(ptr)[:n])
|
|
}
|
|
row[name] = blob
|
|
case C.SQLITE_NULL:
|
|
row[name] = nil
|
|
}
|
|
}
|
|
rows = append(rows, row)
|
|
}
|
|
return rows, nil
|
|
}
|
|
|
|
// ─── vector helpers ───────────────────────────────────
|
|
|
|
func vectorToBlob(v []float32) []byte {
|
|
buf := new(bytes.Buffer)
|
|
for _, f := range v {
|
|
binary.Write(buf, binary.LittleEndian, f)
|
|
}
|
|
return buf.Bytes()
|
|
}
|
|
|
|
func blobToVector(b []byte) []float32 {
|
|
if len(b) == 0 {
|
|
return nil
|
|
}
|
|
vec := make([]float32, len(b)/4)
|
|
buf := bytes.NewReader(b)
|
|
for i := range vec {
|
|
binary.Read(buf, binary.LittleEndian, &vec[i])
|
|
}
|
|
return vec
|
|
}
|
|
|
|
// ─── LanceDB 接口 ─────────────────────────────────────
|
|
|
|
func (sc *SQLiteClient) InsertEpisode(agentID, namespace, content, category string) (string, error) {
|
|
id := fmt.Sprintf("ep_%d", time.Now().UnixNano())
|
|
now := time.Now().Format(time.RFC3339)
|
|
sc.mu.Lock()
|
|
defer sc.mu.Unlock()
|
|
return id, sc.execWithArgs(
|
|
"INSERT INTO episodes(id,agent_id,namespace,content,category,created_at) VALUES(?,?,?,?,?,?)",
|
|
id, agentID, namespace, content, category, now,
|
|
)
|
|
}
|
|
|
|
func (sc *SQLiteClient) InsertMemory(m models.MemoryRecord) error {
|
|
now := time.Now().Format(time.RFC3339)
|
|
vecBlob := vectorToBlob(m.Vector)
|
|
sc.mu.Lock()
|
|
defer sc.mu.Unlock()
|
|
return sc.execWithArgs(
|
|
`INSERT INTO memories(id,agent_id,namespace,content,category,vector,tier,importance,quality_score,
|
|
source,depends_on,derived_from,version,created_at,updated_at) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,1,?,?)`,
|
|
m.ID, m.AgentID, m.Namespace, m.Content, m.Category, vecBlob, m.Tier,
|
|
1.0, m.QualityScore, "", "[]", "", now, now,
|
|
)
|
|
}
|
|
|
|
func (sc *SQLiteClient) Insert(table string, record any) error {
|
|
sc.mu.Lock()
|
|
defer sc.mu.Unlock()
|
|
|
|
now := time.Now().Format(time.RFC3339)
|
|
switch r := record.(type) {
|
|
case models.MemoryRecord:
|
|
return sc.InsertMemory(r)
|
|
case models.EpisodeRecord:
|
|
return sc.execWithArgs(
|
|
"INSERT INTO episodes(id,agent_id,namespace,content,category,distilled_to,distill_status,created_at) VALUES(?,?,?,?,?,?,?,?)",
|
|
r.ID, r.AgentID, r.Namespace, r.Content, r.Category, "", "pending", now,
|
|
)
|
|
case models.TombstoneRecord:
|
|
delTime := r.CreatedAt.Format(time.RFC3339)
|
|
return sc.execWithArgs(
|
|
"INSERT INTO tombstones(id,original_id,content_snapshot,namespace,reason,merged_into,deleted_at) VALUES(?,?,?,?,?,?,?)",
|
|
r.ID, r.OriginalID, "", "", r.Reason, "", delTime,
|
|
)
|
|
default:
|
|
return fmt.Errorf("sqlite: unsupported record type %T", record)
|
|
}
|
|
}
|
|
|
|
func (sc *SQLiteClient) Search(table string, vector []float32, topK int, namespaceFilter string) ([]models.MemoryRecord, error) {
|
|
sc.mu.RLock()
|
|
defer sc.mu.RUnlock()
|
|
|
|
// 加载所有未被删除的记录 + 向量 (按 importance 加权排序)
|
|
query := "SELECT id, content, category, namespace, vector, importance, created_at FROM memories WHERE is_deleted=0"
|
|
if namespaceFilter != "" {
|
|
query += " AND namespace='" + sanitizeIdent(namespaceFilter) + "'"
|
|
}
|
|
|
|
rows, err := sc.query(query)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
type candidate struct {
|
|
rec models.MemoryRecord
|
|
score float64
|
|
}
|
|
var candidates []candidate
|
|
for _, row := range rows {
|
|
vecBlob, _ := row["vector"].([]byte)
|
|
candVec := blobToVector(vecBlob)
|
|
sim := cosineSim(vector, candVec)
|
|
importance, _ := row["importance"].(float64)
|
|
if importance <= 0 { importance = 1.0 }
|
|
|
|
createdAt, _ := time.Parse(time.RFC3339, strVal(row, "created_at"))
|
|
candidates = append(candidates, candidate{
|
|
rec: models.MemoryRecord{
|
|
ID: strVal(row, "id"),
|
|
Content: strVal(row, "content"),
|
|
Category: strVal(row, "category"),
|
|
Namespace: strVal(row, "namespace"),
|
|
CreatedAt: createdAt,
|
|
},
|
|
score: sim * importance, // importance 加权
|
|
})
|
|
}
|
|
|
|
sort.Slice(candidates, func(i, j int) bool {
|
|
return candidates[i].score > candidates[j].score
|
|
})
|
|
if topK > len(candidates) {
|
|
topK = len(candidates)
|
|
}
|
|
results := make([]models.MemoryRecord, topK)
|
|
for i := 0; i < topK; i++ {
|
|
results[i] = candidates[i].rec
|
|
}
|
|
return results, nil
|
|
}
|
|
|
|
func (sc *SQLiteClient) GetTopByQuality(agentID string, limit int) ([]models.MemoryRecord, error) {
|
|
sc.mu.RLock()
|
|
defer sc.mu.RUnlock()
|
|
|
|
rows, err := sc.query(
|
|
"SELECT id,content,category,namespace,created_at FROM memories WHERE is_deleted=0 ORDER BY quality_score DESC LIMIT " + itoa(limit),
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return sc.rowsToMemories(rows), nil
|
|
}
|
|
|
|
func (sc *SQLiteClient) Stats() (map[string]interface{}, error) {
|
|
sc.mu.RLock()
|
|
defer sc.mu.RUnlock()
|
|
|
|
var memCount, epCount, tombCount int64
|
|
rows, _ := sc.query("SELECT COUNT(*) as cnt FROM memories WHERE is_deleted=0")
|
|
if len(rows) > 0 {
|
|
memCount, _ = rows[0]["cnt"].(int64)
|
|
}
|
|
rows, _ = sc.query("SELECT COUNT(*) as cnt FROM episodes")
|
|
if len(rows) > 0 {
|
|
epCount, _ = rows[0]["cnt"].(int64)
|
|
}
|
|
rows, _ = sc.query("SELECT COUNT(*) as cnt FROM tombstones")
|
|
if len(rows) > 0 {
|
|
tombCount, _ = rows[0]["cnt"].(int64)
|
|
}
|
|
|
|
return map[string]interface{}{
|
|
"memory_count": memCount,
|
|
"episode_count": epCount,
|
|
"tombstone_count": tombCount,
|
|
"backend": "sqlite3 (CGO)",
|
|
"db_path": sc.path,
|
|
}, nil
|
|
}
|
|
|
|
func (sc *SQLiteClient) SoftDelete(id, reason string) error {
|
|
sc.mu.Lock()
|
|
defer sc.mu.Unlock()
|
|
|
|
now := time.Now().Format(time.RFC3339)
|
|
if err := sc.execWithArgs(
|
|
"UPDATE memories SET is_deleted=1, updated_at=? WHERE id=?",
|
|
now, id,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
|
|
tombID := fmt.Sprintf("tomb_%d", time.Now().UnixNano())
|
|
return sc.execWithArgs(
|
|
"INSERT INTO tombstones(id,original_id,reason,deleted_at) VALUES(?,?,?,?)",
|
|
tombID, id, reason, now,
|
|
)
|
|
}
|
|
|
|
func (sc *SQLiteClient) GetVersionHistory(id string) ([]map[string]interface{}, error) {
|
|
sc.mu.RLock()
|
|
defer sc.mu.RUnlock()
|
|
|
|
rows, err := sc.query(
|
|
"SELECT version,content,source,reason,timestamp FROM version_history WHERE memory_id=? ORDER BY version DESC",
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// 用笨办法实现参数化查询避免重写 query 函数
|
|
if len(rows) == 0 {
|
|
return nil, nil
|
|
}
|
|
|
|
// 直接重新查询带参数
|
|
cSQL := C.CString("SELECT version,content,source,reason,timestamp FROM version_history WHERE memory_id=? ORDER BY version DESC")
|
|
defer C.free(unsafe.Pointer(cSQL))
|
|
var stmt *C.sqlite3_stmt
|
|
C.sqlite3_prepare_v2(sc.db, cSQL, -1, &stmt, nil)
|
|
defer C.sqlite3_finalize(stmt)
|
|
cID := C.CString(id)
|
|
defer C.free(unsafe.Pointer(cID))
|
|
C.sqlite3_bind_text(stmt, 1, cID, C.int(len(id)), (*[0]byte)(C.free))
|
|
|
|
var result []map[string]interface{}
|
|
for C.sqlite3_step(stmt) == C.SQLITE_ROW {
|
|
result = append(result, map[string]interface{}{
|
|
"version": int64(C.sqlite3_column_int64(stmt, 0)),
|
|
"content": C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 1)))),
|
|
"source": C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 2)))),
|
|
"reason": C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 3)))),
|
|
"timestamp": C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 4)))),
|
|
})
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (sc *SQLiteClient) GetCandidatesForForgetting() ([]map[string]interface{}, error) {
|
|
sc.mu.RLock()
|
|
defer sc.mu.RUnlock()
|
|
|
|
rows, err := sc.query(
|
|
"SELECT id FROM memories WHERE is_deleted=0 AND tier!='core' ORDER BY last_recalled_at ASC LIMIT 100",
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var results []map[string]interface{}
|
|
for _, r := range rows {
|
|
results = append(results, map[string]interface{}{"id": r["id"]})
|
|
}
|
|
return results, nil
|
|
}
|
|
|
|
func (sc *SQLiteClient) Backup(path string) error {
|
|
sc.mu.RLock()
|
|
defer sc.mu.RUnlock()
|
|
|
|
// SQLite 在线备份 API
|
|
var pBackup *C.sqlite3_backup
|
|
cDestPath := C.CString(path)
|
|
defer C.free(unsafe.Pointer(cDestPath))
|
|
|
|
var destDB *C.sqlite3
|
|
rc := C.sqlite3_open(cDestPath, &destDB)
|
|
if rc != C.SQLITE_OK {
|
|
return fmt.Errorf("backup open dest: %s", C.GoString(C.sqlite3_errmsg(destDB)))
|
|
}
|
|
defer C.sqlite3_close(destDB)
|
|
|
|
pBackup = C.sqlite3_backup_init(destDB, C.CString("main"), sc.db, C.CString("main"))
|
|
if pBackup == nil {
|
|
return fmt.Errorf("backup init: %s", C.GoString(C.sqlite3_errmsg(destDB)))
|
|
}
|
|
C.sqlite3_backup_step(pBackup, -1)
|
|
C.sqlite3_backup_finish(pBackup)
|
|
return nil
|
|
}
|
|
|
|
func (sc *SQLiteClient) GetAuditLog(limit int) ([]map[string]interface{}, error) {
|
|
sc.mu.RLock()
|
|
defer sc.mu.RUnlock()
|
|
|
|
rows, err := sc.query(
|
|
"SELECT id,original_id,reason,deleted_at FROM tombstones ORDER BY deleted_at DESC LIMIT " + itoa(limit),
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var results []map[string]interface{}
|
|
for _, r := range rows {
|
|
results = append(results, map[string]interface{}{
|
|
"id": r["id"],
|
|
"original_id": r["original_id"],
|
|
"reason": r["reason"],
|
|
"deleted_at": r["deleted_at"],
|
|
})
|
|
}
|
|
return results, nil
|
|
}
|
|
|
|
func (sc *SQLiteClient) IncrementUseful(id string) {
|
|
sc.mu.Lock()
|
|
defer sc.mu.Unlock()
|
|
sc.execWithArgs(
|
|
"UPDATE memories SET useful_count=useful_count+1, recall_count=recall_count+1, updated_at=? WHERE id=?",
|
|
time.Now().Format(time.RFC3339), id,
|
|
)
|
|
}
|
|
|
|
func (sc *SQLiteClient) IncrementNotUseful(id string) {
|
|
sc.mu.Lock()
|
|
defer sc.mu.Unlock()
|
|
sc.execWithArgs(
|
|
"UPDATE memories SET not_useful_count=not_useful_count+1, updated_at=? WHERE id=?",
|
|
time.Now().Format(time.RFC3339), id,
|
|
)
|
|
}
|
|
|
|
func (sc *SQLiteClient) UpdateMemoryContent(id, newContent, source string) error {
|
|
sc.mu.Lock()
|
|
defer sc.mu.Unlock()
|
|
|
|
now := time.Now().Format(time.RFC3339)
|
|
|
|
// 记录版本历史
|
|
rows, _ := sc.query("SELECT version FROM memories WHERE id='" + sanitizeIdent(id) + "'")
|
|
version := int64(1)
|
|
if len(rows) > 0 {
|
|
if v, ok := rows[0]["version"].(int64); ok {
|
|
version = v + 1
|
|
}
|
|
}
|
|
|
|
sc.execWithArgs(
|
|
"INSERT INTO version_history(memory_id,version,content,source,reason,timestamp) VALUES(?,?,?,?,?,?)",
|
|
id, version, newContent, source, "corrected", now,
|
|
)
|
|
|
|
return sc.execWithArgs(
|
|
"UPDATE memories SET content=?, source=?, version=?, updated_at=? WHERE id=?",
|
|
newContent, source, version, now, id,
|
|
)
|
|
}
|
|
|
|
func (sc *SQLiteClient) Update(table, id string, fields map[string]any) error {
|
|
sc.mu.Lock()
|
|
defer sc.mu.Unlock()
|
|
|
|
if table != "memories" {
|
|
return nil
|
|
}
|
|
|
|
now := time.Now().Format(time.RFC3339)
|
|
if _, ok := fields["recall_count"]; ok {
|
|
return sc.execWithArgs(
|
|
"UPDATE memories SET recall_count=recall_count+1, updated_at=? WHERE id=?",
|
|
now, id,
|
|
)
|
|
}
|
|
if _, ok := fields["useful_count"]; ok {
|
|
return sc.execWithArgs(
|
|
"UPDATE memories SET useful_count=useful_count+1, updated_at=? WHERE id=?",
|
|
now, id,
|
|
)
|
|
}
|
|
// generic update
|
|
for k, v := range fields {
|
|
if err := sc.execWithArgs(
|
|
"UPDATE memories SET "+sanitizeIdent(k)+"=?, updated_at=? WHERE id=?",
|
|
v, now, id,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ─── helpers ──────────────────────────────────────────
|
|
|
|
func strVal(row sqliteRow, key string) string {
|
|
if v, ok := row[key]; ok {
|
|
if s, ok := v.(string); ok {
|
|
return s
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (sc *SQLiteClient) rowsToMemories(rows []sqliteRow) []models.MemoryRecord {
|
|
results := make([]models.MemoryRecord, 0, len(rows))
|
|
for _, row := range rows {
|
|
createdAt, _ := time.Parse(time.RFC3339, strVal(row, "created_at"))
|
|
results = append(results, models.MemoryRecord{
|
|
ID: strVal(row, "id"),
|
|
Content: strVal(row, "content"),
|
|
Category: strVal(row, "category"),
|
|
Namespace: strVal(row, "namespace"),
|
|
CreatedAt: createdAt,
|
|
})
|
|
}
|
|
return results
|
|
}
|
|
|
|
func itoa(n int) string {
|
|
if n <= 0 {
|
|
return "10"
|
|
}
|
|
return fmt.Sprintf("%d", n)
|
|
}
|
|
|
|
func sanitizeIdent(s string) string {
|
|
// 简单防注入:仅允许字母、数字、下划线
|
|
for _, c := range s {
|
|
if !((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || c == '-') {
|
|
return "'invalid'"
|
|
}
|
|
}
|
|
return s
|
|
}
|