Changeset 0.17.1 (#76)
This commit is contained in:
328
server/store/sqlite/helpers.go
Normal file
328
server/store/sqlite/helpers.go
Normal file
@@ -0,0 +1,328 @@
|
||||
package sqlite
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.gobha.me/xcaliber/chat-switchboard/store"
|
||||
)
|
||||
|
||||
// DB is the shared database connection pool.
|
||||
var DB *sql.DB
|
||||
|
||||
// timeFmt is the SQLite-compatible time format for explicit timestamps.
|
||||
// Must match datetime('now') output used in schema DEFAULT expressions.
|
||||
const timeFmt = "2006-01-02 15:04:05"
|
||||
|
||||
// ── Time Scanner ────────────────────────────
|
||||
// modernc/sqlite returns TEXT columns as raw strings, not time.Time.
|
||||
// st() wraps a *time.Time destination so Scan auto-parses the string.
|
||||
|
||||
type sqliteTime struct{ t *time.Time }
|
||||
|
||||
func st(t *time.Time) *sqliteTime { return &sqliteTime{t: t} }
|
||||
|
||||
func (s *sqliteTime) Scan(src interface{}) error {
|
||||
if src == nil {
|
||||
return nil
|
||||
}
|
||||
switch v := src.(type) {
|
||||
case time.Time:
|
||||
*s.t = v
|
||||
return nil
|
||||
case string:
|
||||
for _, f := range timeFormats {
|
||||
if p, err := time.Parse(f, v); err == nil {
|
||||
*s.t = p
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return fmt.Errorf("sqliteTime: cannot parse %q", v)
|
||||
default:
|
||||
return fmt.Errorf("sqliteTime: unsupported type %T", src)
|
||||
}
|
||||
}
|
||||
|
||||
var timeFormats = []string{
|
||||
"2006-01-02 15:04:05",
|
||||
"2006-01-02T15:04:05Z",
|
||||
time.RFC3339,
|
||||
"2006-01-02 15:04:05.000000000+00:00",
|
||||
}
|
||||
|
||||
// stN wraps a *time.Time pointer for nullable columns.
|
||||
type sqliteTimeNullable struct{ t **time.Time }
|
||||
|
||||
func stN(t **time.Time) *sqliteTimeNullable { return &sqliteTimeNullable{t: t} }
|
||||
|
||||
func (s *sqliteTimeNullable) Scan(src interface{}) error {
|
||||
if src == nil {
|
||||
*s.t = nil
|
||||
return nil
|
||||
}
|
||||
var parsed time.Time
|
||||
scanner := st(&parsed)
|
||||
if err := scanner.Scan(src); err != nil {
|
||||
return err
|
||||
}
|
||||
*s.t = &parsed
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetDB configures the shared database connection for all stores.
|
||||
func SetDB(db *sql.DB) {
|
||||
DB = db
|
||||
}
|
||||
|
||||
// ── Dynamic SQL Builder (? placeholders) ────
|
||||
|
||||
// UpdateBuilder constructs a dynamic UPDATE with ? placeholders.
|
||||
type UpdateBuilder struct {
|
||||
table string
|
||||
sets []string
|
||||
args []interface{}
|
||||
where []string
|
||||
}
|
||||
|
||||
func NewUpdate(table string) *UpdateBuilder {
|
||||
return &UpdateBuilder{table: table}
|
||||
}
|
||||
|
||||
func (b *UpdateBuilder) Set(col string, val interface{}) *UpdateBuilder {
|
||||
b.sets = append(b.sets, col+" = ?")
|
||||
b.args = append(b.args, val)
|
||||
return b
|
||||
}
|
||||
|
||||
func (b *UpdateBuilder) SetJSON(col string, val interface{}) *UpdateBuilder {
|
||||
data, err := json.Marshal(val)
|
||||
if err != nil {
|
||||
data = []byte("{}")
|
||||
}
|
||||
return b.Set(col, string(data))
|
||||
}
|
||||
|
||||
func (b *UpdateBuilder) SetIf(col string, val interface{}, set bool) *UpdateBuilder {
|
||||
if set {
|
||||
return b.Set(col, val)
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
// SetExpr sets a column to a raw SQL expression (not parameterized).
|
||||
func (b *UpdateBuilder) SetExpr(col, expr string) *UpdateBuilder {
|
||||
b.sets = append(b.sets, col+" = "+expr)
|
||||
return b
|
||||
}
|
||||
|
||||
// nowExpr returns the SQL expression for "current timestamp" in ISO 8601 format.
|
||||
const nowExpr = "datetime('now')"
|
||||
|
||||
func (b *UpdateBuilder) Where(col string, val interface{}) *UpdateBuilder {
|
||||
b.where = append(b.where, col+" = ?")
|
||||
b.args = append(b.args, val)
|
||||
return b
|
||||
}
|
||||
|
||||
func (b *UpdateBuilder) HasSets() bool {
|
||||
return len(b.sets) > 0
|
||||
}
|
||||
|
||||
func (b *UpdateBuilder) Build() (string, []interface{}) {
|
||||
q := fmt.Sprintf("UPDATE %s SET %s", b.table, strings.Join(b.sets, ", "))
|
||||
if len(b.where) > 0 {
|
||||
q += " WHERE " + strings.Join(b.where, " AND ")
|
||||
}
|
||||
return q, b.args
|
||||
}
|
||||
|
||||
func (b *UpdateBuilder) Exec(db *sql.DB) (sql.Result, error) {
|
||||
q, args := b.Build()
|
||||
return db.Exec(q, args...)
|
||||
}
|
||||
|
||||
// ── Select Builder ──────────────────────────
|
||||
|
||||
type SelectBuilder struct {
|
||||
cols string
|
||||
table string
|
||||
joins []string
|
||||
where []string
|
||||
args []interface{}
|
||||
orderBy string
|
||||
limit int
|
||||
offset int
|
||||
}
|
||||
|
||||
func NewSelect(cols, table string) *SelectBuilder {
|
||||
return &SelectBuilder{cols: cols, table: table}
|
||||
}
|
||||
|
||||
func (b *SelectBuilder) Join(join string) *SelectBuilder {
|
||||
b.joins = append(b.joins, join)
|
||||
return b
|
||||
}
|
||||
|
||||
func (b *SelectBuilder) Where(clause string, args ...interface{}) *SelectBuilder {
|
||||
b.where = append(b.where, clause)
|
||||
b.args = append(b.args, args...)
|
||||
return b
|
||||
}
|
||||
|
||||
func (b *SelectBuilder) WhereRaw(clause string) *SelectBuilder {
|
||||
b.where = append(b.where, clause)
|
||||
return b
|
||||
}
|
||||
|
||||
func (b *SelectBuilder) OrderBy(col, order string) *SelectBuilder {
|
||||
if order == "" {
|
||||
order = "DESC"
|
||||
}
|
||||
b.orderBy = fmt.Sprintf("%s %s", col, strings.ToUpper(order))
|
||||
return b
|
||||
}
|
||||
|
||||
func (b *SelectBuilder) Paginate(opts store.ListOptions) *SelectBuilder {
|
||||
if opts.Limit > 0 {
|
||||
b.limit = opts.Limit
|
||||
}
|
||||
if opts.Offset > 0 {
|
||||
b.offset = opts.Offset
|
||||
}
|
||||
if opts.Sort != "" {
|
||||
b.OrderBy(opts.Sort, opts.Order)
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
func (b *SelectBuilder) Build() (string, []interface{}) {
|
||||
q := fmt.Sprintf("SELECT %s FROM %s", b.cols, b.table)
|
||||
for _, j := range b.joins {
|
||||
q += " " + j
|
||||
}
|
||||
if len(b.where) > 0 {
|
||||
q += " WHERE " + strings.Join(b.where, " AND ")
|
||||
}
|
||||
if b.orderBy != "" {
|
||||
q += " ORDER BY " + b.orderBy
|
||||
}
|
||||
if b.limit > 0 {
|
||||
q += fmt.Sprintf(" LIMIT %d", b.limit)
|
||||
}
|
||||
if b.offset > 0 {
|
||||
q += fmt.Sprintf(" OFFSET %d", b.offset)
|
||||
}
|
||||
return q, b.args
|
||||
}
|
||||
|
||||
func (b *SelectBuilder) CountBuild() (string, []interface{}) {
|
||||
q := fmt.Sprintf("SELECT COUNT(*) FROM %s", b.table)
|
||||
for _, j := range b.joins {
|
||||
q += " " + j
|
||||
}
|
||||
if len(b.where) > 0 {
|
||||
q += " WHERE " + strings.Join(b.where, " AND ")
|
||||
}
|
||||
return q, b.args
|
||||
}
|
||||
|
||||
// ── JSON Helpers ────────────────────────────
|
||||
|
||||
// ToJSON marshals a value to JSON string for TEXT columns.
|
||||
func ToJSON(v interface{}) string {
|
||||
if v == nil {
|
||||
return "{}"
|
||||
}
|
||||
b, err := json.Marshal(v)
|
||||
if err != nil {
|
||||
return "{}"
|
||||
}
|
||||
return string(b)
|
||||
}
|
||||
|
||||
// ScanJSON scans a TEXT column (JSON) into a target.
|
||||
func ScanJSON(src interface{}, dst interface{}) error {
|
||||
if src == nil {
|
||||
return nil
|
||||
}
|
||||
var data []byte
|
||||
switch v := src.(type) {
|
||||
case []byte:
|
||||
data = v
|
||||
case string:
|
||||
data = []byte(v)
|
||||
default:
|
||||
return fmt.Errorf("unsupported JSON type: %T", src)
|
||||
}
|
||||
return json.Unmarshal(data, dst)
|
||||
}
|
||||
|
||||
// ArrayToJSON converts a []string to JSON text for storage.
|
||||
func ArrayToJSON(arr []string) string {
|
||||
if arr == nil {
|
||||
return "[]"
|
||||
}
|
||||
b, _ := json.Marshal(arr)
|
||||
return string(b)
|
||||
}
|
||||
|
||||
// ScanArray scans a JSON text array column into []string.
|
||||
func ScanArray(src interface{}) []string {
|
||||
if src == nil {
|
||||
return nil
|
||||
}
|
||||
var data string
|
||||
switch v := src.(type) {
|
||||
case string:
|
||||
data = v
|
||||
case []byte:
|
||||
data = string(v)
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
var arr []string
|
||||
if err := json.Unmarshal([]byte(data), &arr); err != nil {
|
||||
return nil
|
||||
}
|
||||
return arr
|
||||
}
|
||||
|
||||
// ── Nullable Helpers ────────────────────────
|
||||
|
||||
func NullableString(ns sql.NullString) string {
|
||||
if ns.Valid {
|
||||
return ns.String
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func NullableStringPtr(ns sql.NullString) *string {
|
||||
if ns.Valid {
|
||||
return &ns.String
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func NullableFloat64Ptr(nf sql.NullFloat64) *float64 {
|
||||
if nf.Valid {
|
||||
return &nf.Float64
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func NullableIntPtr(ni sql.NullInt64) *int {
|
||||
if ni.Valid {
|
||||
v := int(ni.Int64)
|
||||
return &v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ── UUID Generation ─────────────────────────
|
||||
|
||||
// NewID generates a new UUID string. Imported from the uuid package
|
||||
// at the store level to keep the helper package dependency-light.
|
||||
// Callers should use store.NewID() instead.
|
||||
Reference in New Issue
Block a user