all: export Checkpoint and BusyTimeout

Signed-off-by: David Crawshaw <crawshaw@tailscale.com>

Author: crawshaw

cgosqlite/cgosqlite.go

@@ -118,6 +118,19 @@ func (db *DB) BusyTimeout(d time.Duration) {
 	C.sqlite3_busy_timeout(db.db, C.int(d/1e6))
 }
 
+func (db *DB) Checkpoint(dbName string, mode sqliteh.Checkpoint) (int, int, error) {
+	var cDB *C.char
+	if dbName != "" {
+		// Docs say: "If parameter zDb is NULL or points to a zero length string",
+		// so they are equivalent here.
+		cDB = C.CString(dbName)
+		defer C.free(unsafe.Pointer(cDB))
+	}
+	var nLog, nCkpt C.int
+	res := C.sqlite3_wal_checkpoint_v2(db.db, cDB, C.int(mode), &nLog, &nCkpt)
+	return int(nLog), int(nCkpt), errCode(res)
+}
+
 func (db *DB) Prepare(query string, prepFlags sqliteh.PrepareFlags) (stmt sqliteh.Stmt, remainingQuery string, err error) {
 	csql := C.CString(query)
 	defer C.free(unsafe.Pointer(csql))

sqlite.go

@@ -695,12 +695,41 @@ func ExecScript(sqlconn SQLConn, queries string) error {
 			_, err = cstmt.Step()
 			cstmt.Finalize()
 			if err != nil {
+				// TODO(crawshaw): consider checking sqlite3_txn_state
+				// here and issuing a rollback, incase this script was:
+				//	BEGIN; BAD-SQL; COMMIT;
+				// So we don't leave the connection open.
 				return reserr(c.db, "ExecScript", queries, err)
 			}
 		}
 	})
 }
 
+// BusyTimeout calls sqlite3_busy_timeout on the underlying connection.
+func BusyTimeout(sqlconn SQLConn, d time.Duration) error {
+	return sqlconn.Raw(func(driverConn interface{}) error {
+		c, ok := driverConn.(*conn)
+		if !ok {
+			return fmt.Errorf("sqlite.BusyTimeout: sql.Conn is not the sqlite driver: %T", driverConn)
+		}
+		c.db.BusyTimeout(d)
+		return nil
+	})
+}
+
+// Checkpoint calls sqlite3_wal_checkpoint_v2 on the underlying connection.
+func Checkpoint(sqlconn SQLConn, dbName string, mode sqliteh.Checkpoint) (numFrames, numFramesCheckpointed int, err error) {
+	err = sqlconn.Raw(func(driverConn interface{}) error {
+		c, ok := driverConn.(*conn)
+		if !ok {
+			return fmt.Errorf("sqlite.BusyTimeout: sql.Conn is not the sqlite driver: %T", driverConn)
+		}
+		numFrames, numFramesCheckpointed, err = c.db.Checkpoint(dbName, mode)
+		return reserr(c.db, "Checkpoint", dbName, err)
+	})
+	return numFrames, numFramesCheckpointed, err
+}
+
 // WithPersist makes a ctx instruct the sqlite driver to persist a prepared query.
 //
 // This should be used with recurring queries to avoid constant parsing and

sqlite_test.go

@@ -8,10 +8,13 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
+	"os"
 	"runtime"
 	"strings"
 	"testing"
 	"time"
+
+	"github.com/tailscale/sqlite/sqliteh"
 )
 
 func TestOpenDB(t *testing.T) {
@@ -407,6 +410,9 @@ func TestErrors(t *testing.T) {
 	if want := `near "NOT": syntax error`; !strings.Contains(err.Error(), want) {
 		t.Errorf("err=%v, want %q", err, want)
 	}
+	if err := ExecScript(conn, "ROLLBACK;"); err != nil { // TODO: make unnecessary?
+		t.Fatal(err)
+	}
 
 	err = ExecScript(conn, `CREATE TABLE t (c INTEGER PRIMARY KEY);
 		INSERT INTO t (c) VALUES (1);
@@ -427,6 +433,47 @@ func TestErrors(t *testing.T) {
 	}
 }
 
+func TestCheckpoint(t *testing.T) {
+	dbFile := t.TempDir() + "/test.db"
+	db, err := sql.Open("sqlite3", "file:"+dbFile)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := db.Exec("PRAGMA journal_mode=WAL"); err != nil {
+		t.Fatal(err)
+	}
+
+	ctx := context.Background()
+	conn, err := db.Conn(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = ExecScript(conn, `CREATE TABLE t (c);
+		INSERT INTO t (c) VALUES (1);
+		INSERT INTO t (c) VALUES (1);`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if fi, err := os.Stat(dbFile + "-wal"); err != nil {
+		t.Fatal(err)
+	} else if fi.Size() == 0 {
+		t.Fatal("WAL is empty")
+	} else {
+		t.Logf("WAL is %d bytes", fi.Size())
+	}
+
+	if _, _, err := Checkpoint(conn, "", sqliteh.SQLITE_CHECKPOINT_TRUNCATE); err != nil {
+		t.Fatal(err)
+	}
+
+	if fi, err := os.Stat(dbFile + "-wal"); err != nil {
+		t.Fatal(err)
+	} else if fi.Size() != 0 {
+		t.Fatal("WAL is not empty")
+	}
+}
+
 func TestTrace(t *testing.T) {
 	type traceEvent struct {
 		prepCtx  context.Context

sqliteh/sqliteh.go

@@ -45,6 +45,8 @@ type DB interface {
 	// BusyTimeout is sqlite3_busy_timeout.
 	// https://www.sqlite.org/c3ref/busy_timeout.html
 	BusyTimeout(time.Duration)
+	// Checkpoint is sqlite3_wal_checkpoint_v2.
+	Checkpoint(db string, mode Checkpoint) (numFrames, numFramesCheckpointed int, err error)
 }
 
 // Stmt is an sqlite3_stmt* database connection object.
@@ -323,6 +325,35 @@ func (o OpenFlags) String() string {
 	return string(flags)
 }
 
+// Checkpoint is a WAL checkpoint mode.
+// It is used by sqlite3_wal_checkpoint_v2.
+//
+// https://sqlite.org/c3ref/wal_checkpoint_v2.html
+type Checkpoint int
+
+const (
+	SQLITE_CHECKPOINT_PASSIVE  Checkpoint = 0
+	SQLITE_CHECKPOINT_FULL     Checkpoint = 1
+	SQLITE_CHECKPOINT_RESTART  Checkpoint = 2
+	SQLITE_CHECKPOINT_TRUNCATE Checkpoint = 3
+)
+
+func (mode Checkpoint) String() string {
+	switch mode {
+	default:
+		var buf [20]byte
+		return "SQLITE_CHECKPOINT_UNKNOWN(" + string(itoa(buf[:], int64(mode))) + ")"
+	case SQLITE_CHECKPOINT_PASSIVE:
+		return "SQLITE_CHECKPOINT_PASSIVE"
+	case SQLITE_CHECKPOINT_FULL:
+		return "SQLITE_CHECKPOINT_FULL"
+	case SQLITE_CHECKPOINT_RESTART:
+		return "SQLITE_CHECKPOINT_RESTART"
+	case SQLITE_CHECKPOINT_TRUNCATE:
+		return "SQLITE_CHECKPOINT_TRUNCATE"
+	}
+}
+
 // ErrCode is an SQLite error code as a Go error.
 // It must not be one of the status codes SQLITE_OK, SQLITE_ROW, or SQLITE_DONE.
 type ErrCode Code