Online backup.

README.md

@@ -55,7 +55,7 @@ As a work around for other Unixes, you can use [`nolock=1`](https://www.sqlite.o
 - [ ] advanced SQLite features
   - [x] nested transactions
   - [x] incremental BLOB I/O
-  - [ ] online backup
+  - [x] online backup
   - [ ] snapshots
   - [ ] session extension
   - [ ] resumable bulk update

backup.go

@@ -6,20 +6,84 @@ package sqlite3
 type Backup struct {
 	c      *Conn
 	handle uint32
+	otherc uint32
+}
+
+// Backup backs up srcDB on the src connection to the "main" database in dstURI.
+//
+// Backup calls [Conn.Open] to open the SQLite database file dstURI,
+// and blocks until the entire backup is complete.
+// Use [Conn.BackupInit] for incremental backup.
+//
+// https://www.sqlite.org/backup.html
+func (src *Conn) Backup(srcDB, dstURI string) error {
+	b, err := src.BackupInit(srcDB, dstURI)
+	if err != nil {
+		return err
+	}
+	defer b.Close()
+	_, err = b.Step(-1)
+	return err
+}
+
+// Restore restores dstDB on the dst connection from the "main" database in srcURI.
+//
+// Restore calls [Conn.Open] to open the SQLite database file srcURI,
+// and blocks until the entire restore is complete.
+//
+// https://www.sqlite.org/backup.html
+func (dst *Conn) Restore(dstDB, srcURI string) error {
+	src, err := dst.openDB(srcURI, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
+	if err != nil {
+		return err
+	}
+	b, err := dst.backupInit(dst.handle, dstDB, src, "main")
+	if err != nil {
+		return err
+	}
+	defer b.Close()
+	_, err = b.Step(-1)
+	return err
 }
 
 // BackupInit initializes a backup operation to copy the content of one database into another.
 //
 // BackupInit calls [Conn.Open] to open the SQLite database file dstURI,
-// then initializes a backup that copies the content of srcDB to the "main" database in dstURI.
+// then initializes a backup that copies the contents of srcDB on the src connection
+// to the "main" database in dstURI.
 //
 // https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupinit
-func (c *Conn) BackupInit(srcDB, dstURI string) (*Backup, error) {
-	return c.backupInit(srcDB, "main", 0)
+func (src *Conn) BackupInit(srcDB, dstURI string) (*Backup, error) {
+	dst, err := src.openDB(dstURI, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
+	if err != nil {
+		return nil, err
+	}
+	return src.backupInit(dst, "main", src.handle, srcDB)
 }
 
-func (c *Conn) backupInit(srcDB, dstDB string, handle uint32) (*Backup, error) {
-	return nil, notImplErr
+func (c *Conn) backupInit(dst uint32, dstName string, src uint32, srcName string) (*Backup, error) {
+	defer c.arena.reset()
+	dstPtr := c.arena.string(dstName)
+	srcPtr := c.arena.string(srcName)
+
+	r := c.call(c.api.backupInit,
+		uint64(dst), uint64(dstPtr),
+		uint64(src), uint64(srcPtr))
+	if r[0] == 0 {
+		r = c.call(c.api.errcode, uint64(dst))
+		return nil, c.module.error(r[0], dst)
+	}
+
+	other := dst
+	if c.handle == dst {
+		other = src
+	}
+
+	return &Backup{
+		c:      c,
+		otherc: other,
+		handle: uint32(r[0]),
+	}, nil
 }
 
 // Close finishes a backup operation.
@@ -33,7 +97,7 @@ func (b *Backup) Close() error {
 	}
 
 	r := b.c.call(b.c.api.backupFinish, uint64(b.handle))
-
+	b.c.closeDB(b.otherc)
 	b.handle = 0
 	return b.c.error(r[0])
 }

conn.go

@@ -98,7 +98,7 @@ func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
 }
 
 func (c *Conn) closeDB(handle uint32) {
-	r := c.call(c.api.closeZombie, uint64(c.handle))
+	r := c.call(c.api.closeZombie, uint64(handle))
 	if err := c.module.error(r[0], handle); err != nil {
 		panic(err)
 	}

stmt.go

@@ -339,7 +339,7 @@ func (s *Stmt) ColumnText(col int) string {
 
 	ptr := uint32(r[0])
 	if ptr == 0 {
-		r = s.c.call(s.c.api.errcode, uint64(s.handle))
+		r = s.c.call(s.c.api.errcode, uint64(s.c.handle))
 		s.err = s.c.error(r[0])
 		return ""
 	}
@@ -362,7 +362,7 @@ func (s *Stmt) ColumnBlob(col int, buf []byte) []byte {
 
 	ptr := uint32(r[0])
 	if ptr == 0 {
-		r = s.c.call(s.c.api.errcode, uint64(s.handle))
+		r = s.c.call(s.c.api.errcode, uint64(s.c.handle))
 		s.err = s.c.error(r[0])
 		return buf[0:0]
 	}

tests/backup_test.go

@@ -0,0 +1,94 @@
+package tests
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+)
+
+func TestBackup(t *testing.T) {
+	t.Parallel()
+
+	backupName := filepath.Join(t.TempDir(), "backup.db")
+
+	func() { // Create backup.
+		db, err := sqlite3.Open(":memory:")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer db.Close()
+
+		err = db.Exec(`CREATE TABLE IF NOT EXISTS users (id INT, name VARCHAR(10))`)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = db.Exec(`INSERT INTO users (id, name) VALUES (0, 'go'), (1, 'zig'), (2, 'whatever')`)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = db.Backup("main", backupName)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = db.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	func() { // Restore backup.
+		db, err := sqlite3.Open(":memory:")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer db.Close()
+
+		err = db.Restore("main", backupName)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		stmt, _, err := db.Prepare(`SELECT id, name FROM users`)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer stmt.Close()
+
+		row := 0
+		ids := []int{0, 1, 2}
+		names := []string{"go", "zig", "whatever"}
+		for ; stmt.Step(); row++ {
+			id := stmt.ColumnInt(0)
+			name := stmt.ColumnText(1)
+
+			if id != ids[row] {
+				t.Errorf("got %d, want %d", id, ids[row])
+			}
+			if name != names[row] {
+				t.Errorf("got %q, want %q", name, names[row])
+			}
+		}
+		if row != 3 {
+			t.Errorf("got %d, want %d", row, len(ids))
+		}
+
+		if err := stmt.Err(); err != nil {
+			t.Fatal(err)
+		}
+
+		err = stmt.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = db.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+}