implement prepared stmt recovery mechanism

Author: Vincent Landgraf

sqlite3.go

@@ -111,6 +111,7 @@ type SQLiteStmt struct {
 	t      string
 	closed bool
 	cls    bool
+	query  string
 }
 
 // Result struct.
@@ -328,7 +329,7 @@ func (c *SQLiteConn) Prepare(query string) (driver.Stmt, error) {
 	if tail != nil && C.strlen(tail) > 0 {
 		t = strings.TrimSpace(C.GoString(tail))
 	}
-	return &SQLiteStmt{c: c, s: s, t: t}, nil
+	return &SQLiteStmt{c: c, s: s, t: t, query: query}, nil
 }
 
 // Close the statement.
@@ -401,6 +402,7 @@ func (s *SQLiteStmt) bind(args []driver.Value) error {
 // Query the statement with arguments. Return records.
 func (s *SQLiteStmt) Query(args []driver.Value) (driver.Rows, error) {
 	if err := s.bind(args); err != nil {
+		defer s.reprepare()
 		return nil, err
 	}
 	return &SQLiteRows{s, int(C.sqlite3_column_count(s.s)), nil, nil, s.cls}, nil
@@ -416,13 +418,21 @@ func (r *SQLiteResult) RowsAffected() (int64, error) {
 	return r.changes, nil
 }
 
+// Reprepares the statement in case of errors
+func (s *SQLiteStmt) reprepare() {
+	stmt, _ := s.c.Prepare(s.query)
+	s.s = stmt.(*SQLiteStmt).s
+}
+
 // Execute the statement with arguments. Return result object.
 func (s *SQLiteStmt) Exec(args []driver.Value) (driver.Result, error) {
 	if err := s.bind(args); err != nil {
+		defer s.reprepare()
 		return nil, err
 	}
 	rv := C.sqlite3_step(s.s)
 	if rv != C.SQLITE_ROW && rv != C.SQLITE_OK && rv != C.SQLITE_DONE {
+		defer s.reprepare()
 		return nil, s.c.lastError()
 	}
 

sqlite3_test/sqltest.go

@@ -29,13 +29,14 @@ type DB struct {
 var db *DB
 
 // the following tables will be created and dropped during the test
-var testTables = []string{"foo", "bar", "t", "bench"}
+var testTables = []string{"foo", "bar", "t", "bench", "users"}
 
 var tests = []testing.InternalTest{
 	{"TestBlobs", TestBlobs},
 	{"TestManyQueryRow", TestManyQueryRow},
 	{"TestTxQuery", TestTxQuery},
 	{"TestPreparedStmt", TestPreparedStmt},
+	{"TestPreparedStmtRecovery", TestPreparedStmtRecovery},
 }
 
 var benchmarks = []testing.InternalBenchmark{
@@ -299,6 +300,35 @@ func TestPreparedStmt(t *testing.T) {
 	}
 }
 
+func TestPreparedStmtRecovery(t *testing.T) {
+	db.tearDown()
+    db.Exec(`create table if not exists users (
+        uid integer primary key autoincrement,
+        name text not null,
+        constraint uniqname unique (name) on conflict rollback
+    );`)
+
+    stmt, err := db.Prepare(`insert into users (name) values (?);`)
+	if err != nil {
+		t.Fatalf("recovery 1: %v", err)
+	}
+
+    _, e1 := stmt.Exec("test")
+	if e1 != nil {
+		t.Fatalf("recovery 2: %v", e1)
+	}
+
+    _, e2 := stmt.Exec("test")
+	if e2 == nil {
+		t.Fatalf("recovery 3: %v", e2)
+	}
+
+    _, e3 := stmt.Exec("test1")
+	if e3 != nil {
+		t.Fatalf("recovery 4: %v", e3)
+	}
+}
+
 // Benchmarks need to use panic() since b.Error errors are lost when
 // running via testing.Benchmark() I would like to run these via go
 // test -bench but calling Benchmark() from a benchmark test