0
0
package storemaint
import (
"context"
"database/sql"
"fmt"
"net/url"
"os"
_ "modernc.org/sqlite"
)
const (
AutoVacuumNone = "none"
AutoVacuumFull = "full"
AutoVacuumIncremental = "incremental"
VacuumChunkPages = 2000
BusyTimeoutMs = 30000
)
type SqliteReading struct {
AutoVacuum string
PageSize int64
PageCount int64
FreePages int64
Rows int64
FileBytes int64
WalBytes int64
}
func (r SqliteReading) FreeBytes() int64 { return r.FreePages * r.PageSize }
type SqliteResult struct {
Before, After SqliteReading
PagesFreed int64
Checkpointed bool
Converted bool
}
func autoVacuumName(mode int64) string {
switch mode {
case 1:
return AutoVacuumFull
case 2:
return AutoVacuumIncremental
}
return AutoVacuumNone
}
func openSqlite(path string) (*sql.DB, error) {
if _, err := os.Stat(path); err != nil {
return nil, err
}
q := url.Values{}
q.Set("mode", "rw")
q.Add("_pragma", fmt.Sprintf("busy_timeout(%d)", BusyTimeoutMs))
db, err := sql.Open("sqlite", "file:"+path+"?"+q.Encode())
if err != nil {
return nil, err
}
db.SetMaxOpenConns(1)
return db, nil
}
func pragmaInt(ctx context.Context, db *sql.DB, name string) (int64, error) {
var v int64
if err := db.QueryRowContext(ctx, "PRAGMA "+name).Scan(&v); err != nil {
return 0, fmt.Errorf("storemaint: PRAGMA %s: %w", name, err)
}
return v, nil
}
func readSqlite(ctx context.Context, db *sql.DB, path, table string) (SqliteReading, error) {
var r SqliteReading
mode, err := pragmaInt(ctx, db, "auto_vacuum")
if err != nil {
return r, err
}
r.AutoVacuum = autoVacuumName(mode)
if r.PageSize, err = pragmaInt(ctx, db, "page_size"); err != nil {
return r, err
}
if r.PageCount, err = pragmaInt(ctx, db, "page_count"); err != nil {
return r, err
}
if r.FreePages, err = pragmaInt(ctx, db, "freelist_count"); err != nil {
return r, err
}
if err := db.QueryRowContext(ctx, "SELECT count(*) FROM "+table).Scan(&r.Rows); err != nil {
return r, fmt.Errorf("storemaint: counting the %s rows of %s: %w", table, path, err)
}
if fi, err := os.Stat(path); err == nil {
r.FileBytes = fi.Size()
}
if fi, err := os.Stat(path + "-wal"); err == nil {
r.WalBytes = fi.Size()
}
return r, nil
}
func ReadSqlite(ctx context.Context, path string) (SqliteReading, error) {
db, err := openSqlite(path)
if err != nil {
return SqliteReading{}, err
}
defer db.Close()
return readSqlite(ctx, db, path, "kine")
}
func MaintainSqlite(ctx context.Context, path string) (SqliteResult, error) {
db, err := openSqlite(path)
if err != nil {
return SqliteResult{}, err
}
defer db.Close()
return maintain(ctx, db, path, "kine", false)
}
func maintain(ctx context.Context, db *sql.DB, path, table string, convert bool) (SqliteResult, error) {
var res SqliteResult
var err error
if res.Before, err = readSqlite(ctx, db, path, table); err != nil {
return res, err
}
res.After = res.Before
if res.Before.AutoVacuum != AutoVacuumIncremental {
if !convert {
return res, nil
}
if _, err := db.ExecContext(ctx, "PRAGMA auto_vacuum=INCREMENTAL"); err != nil {
return res, fmt.Errorf("storemaint: setting auto_vacuum on %s: %w", path, err)
}
if _, err := db.ExecContext(ctx, "VACUUM"); err != nil {
return res, fmt.Errorf("storemaint: converting %s to incremental auto_vacuum: %w", path, err)
}
res.Converted = true
}
for left := res.Before.FreePages; left > 0; {
if _, err := db.ExecContext(ctx, fmt.Sprintf("PRAGMA incremental_vacuum(%d)", VacuumChunkPages)); err != nil {
return res, fmt.Errorf("storemaint: incremental_vacuum on %s: %w", path, err)
}
now, err := pragmaInt(ctx, db, "freelist_count")
if err != nil {
return res, err
}
if now >= left {
break
}
left = now
}
var busy, logFrames, checkpointed int64
if err := db.QueryRowContext(ctx, "PRAGMA wal_checkpoint(TRUNCATE)").Scan(&busy, &logFrames, &checkpointed); err == nil {
res.Checkpointed = busy == 0
}
if res.After, err = readSqlite(ctx, db, path, table); err != nil {
return res, err
}
if res.Converted {
res.PagesFreed = res.Before.PageCount - res.After.PageCount
return res, nil
}
res.PagesFreed = res.Before.FreePages - res.After.FreePages
return res, nil
}