// Package db ports minimal SQLite CRUD from the Rust web plugin (sqlite: URLs). package db import ( "database/sql" "fmt" "os" "path/filepath" "strconv" "strings" "sync" "time" "github.com/marqdo/marqdo/plugins/web/internal/table" _ "github.com/jackc/pgx/v5/stdlib" _ "modernc.org/sqlite" ) var ( poolMu sync.Mutex pool = map[string]*sql.DB{} ) // ResolveURL normalizes sqlite: paths. Absolute paths stay; relative stay as given // (caller / host resolve cwd). Always returns a sqlite:… URL when prefixed. func ResolveURL(url string) string { lower := strings.ToLower(url) if strings.HasPrefix(lower, "postgres://") || strings.HasPrefix(lower, "postgresql://") { return url } stripped := url prefix := "" if strings.HasPrefix(url, "sqlite:") { stripped = strings.TrimPrefix(url, "sqlite:") prefix = "sqlite:" } else if strings.HasPrefix(url, "SQLITE:") { stripped = strings.TrimPrefix(url, "SQLITE:") prefix = "SQLITE:" } if prefix == "" { return stripped } return prefix + stripped } func pathOf(url string) string { u := ResolveURL(url) if strings.HasPrefix(u, "sqlite:") { return strings.TrimPrefix(u, "sqlite:") } if strings.HasPrefix(u, "SQLITE:") { return strings.TrimPrefix(u, "SQLITE:") } return u } func open(url string) (*sql.DB, error) { poolMu.Lock() defer poolMu.Unlock() key := ResolveURL(url) if db, ok := pool[key]; ok { return db, nil } if IsPostgres(url) { db, err := sql.Open("pgx", key) if err != nil { return nil, err } db.SetMaxOpenConns(16) db.SetMaxIdleConns(4) if err := db.Ping(); err != nil { _ = db.Close() return nil, fmt.Errorf("postgres ping: %w", err) } pool[key] = db return db, nil } path := pathOf(url) if parent := filepath.Dir(path); parent != "" && parent != "." { if err := os.MkdirAll(parent, 0o755); err != nil { return nil, err } } db, err := sql.Open("sqlite", path) if err != nil { return nil, err } if _, err := db.Exec(`PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 5000;`); err != nil { _ = db.Close() return nil, err } pool[key] = db return db, nil } // OpenSQL returns a pooled *sql.DB (sqlite or postgres). Prefer OpenSQLDB when // issuing `?` placeholders against Postgres (RBAC). func OpenSQL(url string) (*sql.DB, error) { return open(url) } // ResetPool closes pooled connections and open transactions (tests). func ResetPool() { resetTxns() poolMu.Lock() defer poolMu.Unlock() for k, db := range pool { _ = db.Close() delete(pool, k) } } func ident(s string) (string, error) { s = strings.TrimSpace(s) if s == "" { return "", fmt.Errorf("bad identifier `%s`", s) } for _, c := range s { if !(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || c == '_') { return "", fmt.Errorf("bad identifier `%s`", s) } } return s, nil } func sqlType(t string) string { switch strings.ToLower(strings.TrimSpace(t)) { case "int", "integer": return "INTEGER" case "real", "float", "double": return "REAL" case "blob": return "BLOB" case "timestamp", "datetime", "timestamptz", "审计": return "TEXT" default: return "TEXT" } } func sqlTypeFor(url, t string) string { ty := sqlType(t) if IsPostgres(url) && ty == "REAL" { return "DOUBLE PRECISION" } if IsPostgres(url) && ty == "BLOB" { return "BYTEA" } return ty } func cellStr(v any) string { switch t := v.(type) { case nil: return "" case string: return t case bool: return strconv.FormatBool(t) case float64: if t == float64(int64(t)) { return strconv.FormatInt(int64(t), 10) } return strconv.FormatFloat(t, 'f', -1, 64) case int: return strconv.Itoa(t) case int64: return strconv.FormatInt(t, 10) default: return fmt.Sprint(t) } } func boolField(m map[string]any, keys []string, def bool) bool { for _, k := range keys { v, ok := m[k] if !ok { continue } switch t := v.(type) { case bool: return t case string: switch t { case "true", "True", "1", "yes", "是", "可", "唯一", "索引": return true case "false", "False", "0", "no", "否": return false } case float64: return int64(t) != 0 } } return def } func parseFK(raw string) (string, string, error) { s := strings.TrimSpace(raw) if s == "" { return "", "", fmt.Errorf("empty foreign key") } if i := strings.IndexByte(s, '('); i >= 0 { t, err := ident(s[:i]) if err != nil { return "", "", err } col := strings.TrimSpace(strings.TrimSuffix(s[i+1:], ")")) if col == "" { return t, "id", nil } c, err := ident(col) return t, c, err } if i := strings.IndexByte(s, '.'); i >= 0 { t, err := ident(s[:i]) if err != nil { return "", "", err } c, err := ident(s[i+1:]) return t, c, err } t, err := ident(s) return t, "id", err } func utcNowISO() string { return time.Now().UTC().Format("2006-01-02T15:04:05Z") } // Init creates a table from AsFields-shaped schema. // Returns {"_type":"db_table","name":table,"url":url}. func Init(url, name string, fields any) (map[string]any, error) { tableName, err := ident(name) if err != nil { return nil, err } colsAny := table.AsFields(fields) arr, ok := colsAny.([]any) if !ok { return nil, fmt.Errorf("fields must be a list") } if len(arr) == 0 { return nil, fmt.Errorf("empty fields") } var parts []string var indexSQL []string hasPK := false for _, c := range arr { m, ok := c.(map[string]any) if !ok { continue } nm := cellStr(m["name"]) if nm == "" { nm = cellStr(m["字段"]) } colName, err := ident(nm) if err != nil { return nil, err } ty := cellStr(m["type"]) if ty == "" { ty = cellStr(m["类型"]) } if ty == "" { ty = "text" } nullable := boolField(m, []string{"nullable", "可空"}, true) unique := boolField(m, []string{"unique", "唯一"}, false) index := boolField(m, []string{"index", "索引"}, false) col := fmt.Sprintf(`"%s" %s`, colName, sqlTypeFor(url, ty)) if colName == "id" && !hasPK { if IsPostgres(url) && sqlType(ty) == "INTEGER" { col = fmt.Sprintf(`"%s" INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY`, colName) } else { col += " PRIMARY KEY" if sqlType(ty) == "INTEGER" { col += " AUTOINCREMENT" } } hasPK = true } else if !nullable { col += " NOT NULL" } if unique && colName != "id" { col += " UNIQUE" } fkRaw := cellStr(m["fk"]) if fkRaw == "" { fkRaw = cellStr(m["外键"]) } if fkRaw != "" { rt, rc, err := parseFK(fkRaw) if err != nil { return nil, err } col += fmt.Sprintf(` REFERENCES "%s"("%s")`, rt, rc) } parts = append(parts, col) if (index || unique) && colName != "id" { kind := "" if unique { kind = "UNIQUE " } indexSQL = append(indexSQL, fmt.Sprintf( `CREATE %sINDEX IF NOT EXISTS "idx_%s_%s" ON "%s" ("%s")`, kind, tableName, colName, tableName, colName, )) } } sqlStmt := fmt.Sprintf(`CREATE TABLE IF NOT EXISTS "%s" (%s)`, tableName, strings.Join(parts, ", ")) db, err := open(url) if err != nil { return nil, err } if _, err := db.Exec(sqlStmt); err != nil { return nil, err } for _, stmt := range indexSQL { if _, err := db.Exec(stmt); err != nil { return nil, err } } return map[string]any{ "_type": "db_table", "name": tableName, "url": ResolveURL(url), }, nil } func columnNames(c dbConn, tableName string, dbURL string) ([]string, error) { if IsPostgres(dbURL) { rows, err := c.Query(` SELECT column_name FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = ? ORDER BY ordinal_position`, tableName) if err != nil { return nil, err } defer rows.Close() var out []string for rows.Next() { var name string if err := rows.Scan(&name); err != nil { return nil, err } out = append(out, name) } return out, rows.Err() } rows, err := c.Query(fmt.Sprintf(`PRAGMA table_info("%s")`, tableName)) if err != nil { return nil, err } defer rows.Close() var out []string for rows.Next() { var cid int var name, ctype string var notnull, pk int var dflt any if err := rows.Scan(&cid, &name, &ctype, ¬null, &dflt, &pk); err != nil { return nil, err } out = append(out, name) } return out, rows.Err() } func toSQLArg(v any) any { switch t := v.(type) { case nil: return nil case bool: if t { return int64(1) } return int64(0) case float64: if t == float64(int64(t)) { return int64(t) } return t case string: s := strings.TrimSpace(t) if i, err := strconv.ParseInt(s, 10, 64); err == nil { return i } if f, err := strconv.ParseFloat(s, 64); err == nil && strings.Contains(s, ".") && !strings.ContainsAny(s, "eE") { return f } return t case int: return int64(t) case int64: return t default: return fmt.Sprint(t) } } func fromSQL(v any) any { switch t := v.(type) { case nil: return nil case int64: return float64(t) // JSON numbers are float64 case float64: return t case bool: return t case []byte: return string(t) case string: return t default: return fmt.Sprint(t) } } // Insert inserts row maps. Returns {"ok":true,"inserted":n}. // Optional txnID routes through an open Begin transaction. func Insert(url, tableName string, rows any, txnID ...string) (map[string]any, error) { tn, err := ident(tableName) if err != nil { return nil, err } c, err := connFor(url, optTxn(txnID)) if err != nil { return nil, err } colsPresent, err := columnNames(c, tn, url) if err != nil { return nil, err } hasCreated, hasUpdated := false, false for _, col := range colsPresent { if col == "created_at" { hasCreated = true } if col == "updated_at" { hasUpdated = true } } normalized := table.AsRows(rows) arr, ok := normalized.([]any) if !ok { return nil, fmt.Errorf("rows must be a list") } now := utcNowISO() var n int64 for _, row := range arr { obj, ok := row.(map[string]any) if !ok { return nil, fmt.Errorf("row must be a map") } var cols, placeholders []string var vals []any seenCreated, seenUpdated := false, false for k, v := range obj { if k == "@" || k == "行" || k == "row" { continue } if _, err := ident(k); err != nil { return nil, err } if k == "created_at" { seenCreated = true } if k == "updated_at" { seenUpdated = true } cols = append(cols, `"`+k+`"`) placeholders = append(placeholders, "?") vals = append(vals, toSQLArg(v)) } if hasCreated && !seenCreated { cols = append(cols, `"created_at"`) placeholders = append(placeholders, "?") vals = append(vals, now) } if hasUpdated && !seenUpdated { cols = append(cols, `"updated_at"`) placeholders = append(placeholders, "?") vals = append(vals, now) } if len(cols) == 0 { continue } sqlStmt := fmt.Sprintf( `INSERT INTO "%s" (%s) VALUES (%s)`, tn, strings.Join(cols, ", "), strings.Join(placeholders, ", "), ) if _, err := c.Exec(sqlStmt, vals...); err != nil { return nil, err } n++ } return map[string]any{"ok": true, "inserted": float64(n)}, nil } func skipWhereKey(k string) bool { return k == "@" || k == "行" || k == "row" || strings.HasPrefix(k, "_") } func whereOp(raw string) (string, error) { switch strings.ToLower(strings.TrimSpace(raw)) { case "", "=", "eq", "==", "等于": return "=", nil case "!=", "<>", "ne", "不等于": return "!=", nil case ">", "gt", "大于": return ">", nil case ">=", "gte", "大于等于": return ">=", nil case "<", "lt", "小于": return "<", nil case "<=", "lte", "小于等于": return "<=", nil case "like", "contains", "包含", "匹配": return "LIKE", nil case "in", "在": return "IN", nil case "between", "介于", "在之间": return "BETWEEN", nil case "is null", "isnull", "为空", "空": return "IS NULL", nil default: return "", fmt.Errorf("unsupported where op `%s`", raw) } } type whereClause struct { expr string vals []any or bool } func inValues(v any) []any { switch t := v.(type) { case []any: out := make([]any, len(t)) for i, x := range t { out[i] = toSQLArg(x) } return out case string: parts := strings.Split(t, ",") out := make([]any, 0, len(parts)) for _, p := range parts { out = append(out, toSQLArg(strings.TrimSpace(p))) } return out default: return []any{toSQLArg(v)} } } func betweenValues(v any) ([]any, error) { switch t := v.(type) { case []any: if len(t) != 2 { return nil, fmt.Errorf(`between expects two bounds ("lo,hi" or [lo,hi])`) } return []any{toSQLArg(t[0]), toSQLArg(t[1])}, nil case string: parts := strings.SplitN(t, ",", 2) lo, hi := "", "" if len(parts) > 0 { lo = strings.TrimSpace(parts[0]) } if len(parts) > 1 { hi = strings.TrimSpace(parts[1]) } return []any{toSQLArg(lo), toSQLArg(hi)}, nil default: return nil, fmt.Errorf(`between expects two bounds ("lo,hi" or [lo,hi])`) } } func boolOrFlag(v any) bool { switch t := v.(type) { case bool: return t case string: switch strings.ToLower(strings.TrimSpace(t)) { case "1", "true", "是", "or", "或者": return true } case float64: return int64(t) != 0 } return false } func clauseFromRow(m map[string]any) (*whereClause, error) { field := "" for _, k := range []string{"field", "字段", "列"} { if v, ok := m[k]; ok { field = cellStr(v) break } } if field == "" { return nil, nil } col, err := ident(field) if err != nil { return nil, err } opRaw := "" if v, ok := m["op"]; ok { opRaw = cellStr(v) } else if v, ok := m["操作"]; ok { opRaw = cellStr(v) } op, err := whereOp(opRaw) if err != nil { return nil, err } var val any if v, ok := m["value"]; ok { val = v } else if v, ok := m["值"]; ok { val = v } or := false if v, ok := m["or"]; ok { or = boolOrFlag(v) } else if v, ok := m["或"]; ok { or = boolOrFlag(v) } var expr string var vals []any switch op { case "IS NULL": expr = fmt.Sprintf(`"%s" IS NULL`, col) case "IN": vs := inValues(val) ph := make([]string, len(vs)) for i := range vs { ph[i] = "?" } expr = fmt.Sprintf(`"%s" IN (%s)`, col, strings.Join(ph, ", ")) vals = vs case "BETWEEN": vs, err := betweenValues(val) if err != nil { return nil, err } expr = fmt.Sprintf(`"%s" BETWEEN ? AND ?`, col) vals = vs default: expr = fmt.Sprintf(`"%s" %s ?`, col, op) vals = []any{toSQLArg(val)} } return &whereClause{expr: expr, vals: vals, or: or}, nil } // parseWhere builds AND/OR filter clauses. // Supports: // - equality map `{title:"Alpha", body:"first"}` → col = ? // - filter rows `{field|字段|列, op|操作, value|值, or|或?}` // - ops: = != > >= < <= LIKE IN BETWEEN IS NULL (+ Chinese aliases) // - GFM columnar tables via table.AsRows func parseWhere(where any) (exprs []string, vals []any, err error) { if where == nil { return nil, nil, nil } if s, ok := where.(string); ok { if s == "" || strings.EqualFold(s, "none") || strings.EqualFold(s, "null") { return nil, nil, nil } // Non-empty bare strings: AsRows yields []; treat as no filter (Rust parity). } w := table.AsRows(where) arr, ok := w.([]any) if !ok { return nil, nil, fmt.Errorf("where must be a map or filter table") } var clauses []whereClause for _, item := range arr { m, ok := item.(map[string]any) if !ok { return nil, nil, fmt.Errorf("where must be a map or filter table") } field := "" for _, k := range []string{"field", "字段", "列"} { if v, ok := m[k]; ok { field = cellStr(v) break } } _, hasVal := m["value"] if !hasVal { _, hasVal = m["值"] } _, hasOp := m["op"] if !hasOp { _, hasOp = m["操作"] } if field != "" && (hasVal || hasOp) { cl, err := clauseFromRow(m) if err != nil { return nil, nil, err } if cl != nil { clauses = append(clauses, *cl) } continue } for k, v := range m { if skipWhereKey(k) { continue } col, err := ident(k) if err != nil { return nil, nil, err } clauses = append(clauses, whereClause{ expr: fmt.Sprintf(`"%s" = ?`, col), vals: []any{toSQLArg(v)}, }) } } // Assemble: AND by default; OR-marked clauses join the current group. var group []string for _, cl := range clauses { if cl.or { group = append(group, cl.expr) } else { if len(group) > 0 { exprs = append(exprs, "("+strings.Join(group, " OR ")+")") group = group[:0] } group = append(group, cl.expr) } vals = append(vals, cl.vals...) } if len(group) > 0 { exprs = append(exprs, "("+strings.Join(group, " OR ")+")") } return exprs, vals, nil } func scanRows(rows *sql.Rows) ([]any, error) { cols, err := rows.Columns() if err != nil { return nil, err } var out []any for rows.Next() { raw := make([]any, len(cols)) ptrs := make([]any, len(cols)) for i := range raw { ptrs[i] = &raw[i] } if err := rows.Scan(ptrs...); err != nil { return nil, err } m := map[string]any{} for i, name := range cols { m[name] = fromSQL(raw[i]) } out = append(out, m) } return out, rows.Err() } // SelectOpts controls select_order behavior. type SelectOpts struct { Where any Order string Offset *int64 } // Select runs SELECT * FROM table with optional where/order/offset. // Without offset: {"rows":[…]}; with offset: {"rows":[…],"total":N}. // Optional txnID routes through an open Begin transaction. func Select(url, tableName string, limit int64, opts SelectOpts, txnID ...string) (map[string]any, error) { tn, err := ident(tableName) if err != nil { return nil, err } exprs, vals, err := parseWhere(opts.Where) if err != nil { return nil, err } c, err := connFor(url, optTxn(txnID)) if err != nil { return nil, err } sqlStmt := fmt.Sprintf(`SELECT * FROM "%s"`, tn) whereSQL := "" if len(exprs) > 0 { whereSQL = " WHERE " + strings.Join(exprs, " AND ") sqlStmt += whereSQL } if order := strings.TrimSpace(opts.Order); order != "" { parts := strings.Split(order, ",") var orderExprs []string for _, part := range parts { part = strings.TrimSpace(part) if part == "" { continue } dir := "" col := part if strings.HasPrefix(part, "-") { col = part[1:] dir = " DESC" } cname, err := ident(col) if err != nil { return nil, err } orderExprs = append(orderExprs, fmt.Sprintf(`"%s"%s`, cname, dir)) } if len(orderExprs) > 0 { sqlStmt += " ORDER BY " + strings.Join(orderExprs, ", ") } } sqlStmt += " LIMIT ?" vals = append(vals, limit) if opts.Offset != nil && *opts.Offset > 0 { sqlStmt += " OFFSET ?" vals = append(vals, *opts.Offset) } rows, err := c.Query(sqlStmt, vals...) if err != nil { return nil, err } defer rows.Close() list, err := scanRows(rows) if err != nil { return nil, err } if list == nil { list = []any{} } if opts.Offset != nil { countSQL := fmt.Sprintf(`SELECT COUNT(*) FROM "%s"%s`, tn, whereSQL) _, whereOnly, _ := parseWhere(opts.Where) var total int64 if err := c.QueryRow(countSQL, whereOnly...).Scan(&total); err != nil { total = int64(len(list)) } return map[string]any{"rows": list, "total": float64(total)}, nil } return map[string]any{"rows": list}, nil } // Get returns one row by id, or nil (JSON null). // Optional txnID routes through an open Begin transaction. func Get(url, tableName, id string, txnID ...string) (any, error) { tn, err := ident(tableName) if err != nil { return nil, err } c, err := connFor(url, optTxn(txnID)) if err != nil { return nil, err } sqlStmt := fmt.Sprintf(`SELECT * FROM "%s" WHERE "id" = ? LIMIT 1`, tn) rows, err := c.Query(sqlStmt, toSQLArg(id)) if err != nil { return nil, err } defer rows.Close() list, err := scanRows(rows) if err != nil { return nil, err } if len(list) == 0 { return nil, nil } return list[0], nil } func sqlArgs(args any) []any { switch t := args.(type) { case []any: out := make([]any, len(t)) for i, v := range t { out[i] = toSQLArg(v) } return out case nil: return nil default: return []any{toSQLArg(t)} } } // Exec runs a non-SELECT statement. Returns {"ok":true,"changes":N}. // Optional txnID routes through an open Begin transaction. func Exec(url, sqlStmt string, args any, txnID ...string) (map[string]any, error) { c, err := connFor(url, optTxn(txnID)) if err != nil { return nil, err } vals := sqlArgs(args) res, err := c.Exec(sqlStmt, vals...) if err != nil { return nil, err } n, _ := res.RowsAffected() return map[string]any{"ok": true, "changes": float64(n)}, nil } // Update sets columns from row (skips id). Auto-sets updated_at when present. // Returns {"ok":true,"updated":N}. // Optional txnID routes through an open Begin transaction. func Update(url, tableName, id string, row any, txnID ...string) (map[string]any, error) { tn, err := ident(tableName) if err != nil { return nil, err } obj, ok := row.(map[string]any) if !ok { return nil, fmt.Errorf("row must be a map") } c, err := connFor(url, optTxn(txnID)) if err != nil { return nil, err } colsPresent, err := columnNames(c, tn, url) if err != nil { return nil, err } hasUpdated := false for _, col := range colsPresent { if col == "updated_at" { hasUpdated = true break } } var sets []string var vals []any seenUpdated := false for k, v := range obj { if k == "id" { continue } if _, err := ident(k); err != nil { return nil, err } if k == "updated_at" { seenUpdated = true } sets = append(sets, fmt.Sprintf(`"%s" = ?`, k)) vals = append(vals, toSQLArg(v)) } if hasUpdated && !seenUpdated { sets = append(sets, `"updated_at" = ?`) vals = append(vals, utcNowISO()) } if len(sets) == 0 { return nil, fmt.Errorf("nothing to update") } vals = append(vals, id) // Rust binds id as text; SQLite coerces sqlStmt := fmt.Sprintf(`UPDATE "%s" SET %s WHERE "id" = ?`, tn, strings.Join(sets, ", ")) res, err := c.Exec(sqlStmt, vals...) if err != nil { return nil, err } n, _ := res.RowsAffected() return map[string]any{"ok": true, "updated": float64(n)}, nil } // UpdateIf is a conditional update (CAS): SET row WHERE id=? AND expect_col=expect_val. // Returns {"ok":true,"updated":N,"matched":N}. Callers treat updated==0 as conflict. // Optional txnID routes through an open Begin transaction. func UpdateIf(url, tableName, id string, row any, expectCol string, expectVal any, txnID ...string) (map[string]any, error) { tn, err := ident(tableName) if err != nil { return nil, err } ecol, err := ident(expectCol) if err != nil { return nil, err } obj, ok := row.(map[string]any) if !ok { return nil, fmt.Errorf("row must be a map") } c, err := connFor(url, optTxn(txnID)) if err != nil { return nil, err } var sets []string var vals []any for k, v := range obj { if k == "id" { continue } if _, err := ident(k); err != nil { return nil, err } sets = append(sets, fmt.Sprintf(`"%s" = ?`, k)) vals = append(vals, toSQLArg(v)) } if len(sets) == 0 { return nil, fmt.Errorf("nothing to update") } vals = append(vals, id, toSQLArg(expectVal)) sqlStmt := fmt.Sprintf( `UPDATE "%s" SET %s WHERE "id" = ? AND "%s" = ?`, tn, strings.Join(sets, ", "), ecol, ) res, err := c.Exec(sqlStmt, vals...) if err != nil { return nil, err } n, _ := res.RowsAffected() return map[string]any{"ok": true, "updated": float64(n), "matched": float64(n)}, nil } // Delete removes a row by id. Returns {"ok":true,"deleted":N}. // Optional txnID routes through an open Begin transaction. func Delete(url, tableName, id string, txnID ...string) (map[string]any, error) { tn, err := ident(tableName) if err != nil { return nil, err } c, err := connFor(url, optTxn(txnID)) if err != nil { return nil, err } sqlStmt := fmt.Sprintf(`DELETE FROM "%s" WHERE "id" = ?`, tn) res, err := c.Exec(sqlStmt, id) if err != nil { return nil, err } n, _ := res.RowsAffected() return map[string]any{"ok": true, "deleted": float64(n)}, nil } // Query runs a SELECT (or any result-set SQL). Returns {"rows":[…],"count":N}. // Optional txnID routes through an open Begin transaction. func Query(url, sqlStmt string, args any, txnID ...string) (map[string]any, error) { c, err := connFor(url, optTxn(txnID)) if err != nil { return nil, err } vals := sqlArgs(args) rows, err := c.Query(sqlStmt, vals...) if err != nil { return nil, err } defer rows.Close() list, err := scanRows(rows) if err != nil { return nil, err } if list == nil { list = []any{} } return map[string]any{"rows": list, "count": float64(len(list))}, nil } // Count returns {"count":N} for rows matching where (nil where → all). // Optional txnID routes through an open Begin transaction. func Count(url, tableName string, where any, txnID ...string) (map[string]any, error) { tn, err := ident(tableName) if err != nil { return nil, err } exprs, vals, err := parseWhere(where) if err != nil { return nil, err } c, err := connFor(url, optTxn(txnID)) if err != nil { return nil, err } sqlStmt := fmt.Sprintf(`SELECT COUNT(*) FROM "%s"`, tn) if len(exprs) > 0 { sqlStmt += " WHERE " + strings.Join(exprs, " AND ") } var n int64 if err := c.QueryRow(sqlStmt, vals...).Scan(&n); err != nil { return nil, err } return map[string]any{"count": float64(n)}, nil } // ColumnInfo is one PRAGMA table_info row (admin forms / schema introspection). type ColumnInfo struct { Name string SQLType string NotNull bool PK bool } // TableInfo returns column metadata for a table (SQLite or Postgres). func TableInfo(url, tableName string) ([]ColumnInfo, error) { tn, err := ident(tableName) if err != nil { return nil, err } c, err := connFor(url, "") if err != nil { return nil, err } if IsPostgres(url) { rows, err := c.Query(` SELECT c.column_name, c.data_type, c.is_nullable, CASE WHEN tc.constraint_type = 'PRIMARY KEY' THEN 1 ELSE 0 END AS is_pk FROM information_schema.columns c LEFT JOIN information_schema.key_column_usage kcu ON c.table_schema = kcu.table_schema AND c.table_name = kcu.table_name AND c.column_name = kcu.column_name LEFT JOIN information_schema.table_constraints tc ON kcu.constraint_name = tc.constraint_name AND kcu.table_schema = tc.table_schema AND tc.constraint_type = 'PRIMARY KEY' WHERE c.table_schema = current_schema() AND c.table_name = ? ORDER BY c.ordinal_position`, tn) if err != nil { return nil, err } defer rows.Close() var out []ColumnInfo for rows.Next() { var name, dtype, nullable string var pk int if err := rows.Scan(&name, &dtype, &nullable, &pk); err != nil { return nil, err } if dtype == "" { dtype = "TEXT" } out = append(out, ColumnInfo{ Name: name, SQLType: dtype, NotNull: strings.EqualFold(nullable, "NO"), PK: pk != 0, }) } return out, rows.Err() } rows, err := c.Query(fmt.Sprintf(`PRAGMA table_info("%s")`, tn)) if err != nil { return nil, err } defer rows.Close() var out []ColumnInfo for rows.Next() { var cid int var name, ctype string var notnull, pk int var dflt any if err := rows.Scan(&cid, &name, &ctype, ¬null, &dflt, &pk); err != nil { return nil, err } if ctype == "" { ctype = "TEXT" } out = append(out, ColumnInfo{ Name: name, SQLType: ctype, NotNull: notnull != 0, PK: pk != 0, }) } return out, rows.Err() }