Merge pull request #643 from letsencrypt/cert-checker

Certificate checker

Godeps/Godeps.json

@@ -1,6 +1,6 @@
 {
 	"ImportPath": "github.com/letsencrypt/boulder",
-	"GoVersion": "go1.4.2",
+	"GoVersion": "go1.5",
 	"Packages": [
 		"./..."
 	],
@@ -73,12 +73,12 @@
 			"Rev": "a197e5d40516f2e9f74dcee085a5f2d4604e94df"
 		},
 		{
-			"ImportPath": "github.com/letsencrypt/go-jose",
-			"Rev": "e7bd87a386998d423741e8e370af1a22638767e0"
+			"ImportPath": "github.com/jmhodges/clock",
+			"Rev": "c560df7e034994569e9742f6e7716c173f6286eb"
 		},
 		{
-			"ImportPath": "github.com/mattn/go-sqlite3",
-			"Rev": "308067797b0fcce4ca06362580dc6db77c1bfeda"
+			"ImportPath": "github.com/letsencrypt/go-jose",
+			"Rev": "e7bd87a386998d423741e8e370af1a22638767e0"
 		},
 		{
 			"ImportPath": "github.com/miekg/dns",

Godeps/_workspace/src/github.com/jmhodges/clock/.travis.yml

@@ -0,0 +1,5 @@
+language: go
+
+go:
+  - 1.3
+  - tip

Godeps/_workspace/src/github.com/jmhodges/clock/LICENSE

@@ -1,21 +1,20 @@
 The MIT License (MIT)
-
-Copyright (c) 2014 Yasuhiro Matsumoto
+Copyright © 2014 Jeff Hodges <jeff@somethingsimilar.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
+of this software and associated documentation files (the “Software”), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

Godeps/_workspace/src/github.com/jmhodges/clock/README.md

@@ -0,0 +1,10 @@
+clock
+====
+
+[![Build Status](https://travis-ci.org/jmhodges/clock.png?branch=master)](https://travis-ci.org/jmhodges/clock)
+
+A Go package that provides an abstraction for system time that enables
+testing of time-sensitive code.
+
+For documentation, see the
+[godoc](http://godoc.org/github.com/jmhodges/clock).

Godeps/_workspace/src/github.com/jmhodges/clock/clock.go

@@ -0,0 +1,78 @@
+// Package clock provides an abstraction for system time that enables
+// testing of time-sensitive code.
+//
+// By passing in Default to production code, you can then use NewFake
+// in tests to create Clocks that control what time the production
+// code sees.
+//
+// Be sure to test Time equality with time.Time#Equal, not ==.
+package clock
+
+import (
+	"sync"
+	"time"
+)
+
+var systemClock Clock = sysClock{}
+
+// Default returns a Clock that matches the actual system time.
+func Default() Clock {
+	// This is a method instead of a public var to prevent folks from
+	// "making things work" by writing to the var instead of passing
+	// in a Clock.
+	return systemClock
+}
+
+// Clock is an abstraction over system time. New instances of it can
+// be made with Default and NewFake.
+type Clock interface {
+	// Now returns the Clock's current view of the time. Mutating the
+	// returned Time will not mutate the clock's time.
+	Now() time.Time
+}
+
+type sysClock struct{}
+
+func (s sysClock) Now() time.Time {
+	return time.Now()
+}
+
+// NewFake returns a FakeClock to be used in tests that need to
+// manipulate time. Its initial value is always the unix epoch in the
+// UTC timezone. The FakeClock returned is thread-safe.
+func NewFake() FakeClock {
+	// We're explicit about this time construction to avoid early user
+	// questions about why the time object doesn't have a Location by
+	// default.
+	return &fake{t: time.Unix(0, 0).UTC()}
+}
+
+// FakeClock is a Clock with additional controls. The return value of
+// Now return can be modified with Add. Use NewFake to get a
+// thread-safe FakeClock implementation.
+type FakeClock interface {
+	Clock
+	// Adjust the time that will be returned by Now.
+	Add(d time.Duration)
+}
+
+// To prevent mistakes with the API, we hide this behind NewFake. It's
+// easy forget to create a pointer to a fake since time.Time (and
+// sync.Mutex) are also simple values. The code will appear to work
+// but the clock's time will never be adjusted.
+type fake struct {
+	sync.RWMutex
+	t time.Time
+}
+
+func (f *fake) Now() time.Time {
+	f.RLock()
+	defer f.RUnlock()
+	return f.t
+}
+
+func (f *fake) Add(d time.Duration) {
+	f.Lock()
+	defer f.Unlock()
+	f.t = f.t.Add(d)
+}

Godeps/_workspace/src/github.com/jmhodges/clock/clock_test.go

@@ -0,0 +1,48 @@
+package clock
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+func TestFakeClockGoldenPath(t *testing.T) {
+	clk := NewFake()
+	second := NewFake()
+	if !clk.Now().Equal(second.Now()) {
+		t.Errorf("clocks must start out at the same time but didn't: %#v vs %#v", clk.Now(), second.Now())
+	}
+	clk.Add(3 * time.Second)
+	if clk.Now().Equal(second.Now()) {
+		t.Errorf("clocks different must differ: %#v vs %#v", clk.Now(), second.Now())
+	}
+}
+
+func ExampleClock() {
+	c := Default()
+	now := c.Now()
+	fmt.Println(now.UTC().Zone())
+	// Output:
+	// UTC 0
+}
+
+func ExampleFakeClock() {
+	c := Default()
+	fc := NewFake()
+	fc.Add(20 * time.Hour)
+	fc.Add(-5 * time.Minute) // negatives work, as well
+
+	if fc.Now().Equal(fc.Now()) {
+		fmt.Println("FakeClocks' Times always equal themselves.")
+	}
+	if !c.Now().Equal(fc.Now()) {
+		fmt.Println("Clock and FakeClock can be set to different times.")
+	}
+	if !fc.Now().Equal(NewFake().Now()) {
+		fmt.Println("FakeClocks work independently, too.")
+	}
+	// Output:
+	// FakeClocks' Times always equal themselves.
+	// Clock and FakeClock can be set to different times.
+	// FakeClocks work independently, too.
+}

Godeps/_workspace/src/github.com/mattn/go-sqlite3/.gitignore

@@ -1,3 +0,0 @@
-*.db
-*.exe
-*.dll

Godeps/_workspace/src/github.com/mattn/go-sqlite3/.travis.yml

@@ -1,9 +0,0 @@
-language: go
-go:
-  - tip
-before_install:
-  - go get github.com/axw/gocov/gocov
-  - go get github.com/mattn/goveralls
-  - go get golang.org/x/tools/cmd/cover
-script:
-    - $HOME/gopath/bin/goveralls -repotoken 3qJVUE0iQwqnCbmNcDsjYu1nh4J4KIFXx

Godeps/_workspace/src/github.com/mattn/go-sqlite3/README.md

@@ -1,62 +0,0 @@
-go-sqlite3
-==========
-
-[![Build Status](https://travis-ci.org/mattn/go-sqlite3.png?branch=master)](https://travis-ci.org/mattn/go-sqlite3)
-[![Coverage Status](https://coveralls.io/repos/mattn/go-sqlite3/badge.png?branch=master)](https://coveralls.io/r/mattn/go-sqlite3?branch=master)
-
-Description
------------
-
-sqlite3 driver conforming to the built-in database/sql interface
-
-Installation
-------------
-
-This package can be installed with the go get command:
-
-    go get github.com/mattn/go-sqlite3
-    
-Documentation
--------------
-
-API documentation can be found here: http://godoc.org/github.com/mattn/go-sqlite3
-
-Examples can be found under the `./_example` directory
-
-FAQ
----
-
-* Can't build go-sqlite3 on windows 64bit.
-
-    > Probably, you are using go 1.0, go1.0 has a problem when it comes to compiling/linking on windows 64bit. 
-    > See: https://github.com/mattn/go-sqlite3/issues/27
-
-* Getting insert error while query is opened.
-
-    > You can pass some arguments into the connection string, for example, a URI.
-    > See: https://github.com/mattn/go-sqlite3/issues/39
-
-* Do you want cross compiling? mingw on Linux or Mac?
-
-    > See: https://github.com/mattn/go-sqlite3/issues/106
-    > See also: http://www.limitlessfx.com/cross-compile-golang-app-for-windows-from-linux.html
-
-* Want to get time.Time with current locale
-
-    Use `loc=auto` in SQLite3 filename schema like `file:foo.db?loc=auto`.
-
-License
--------
-
-MIT: http://mattn.mit-license.org/2012
-
-sqlite3-binding.c, sqlite3-binding.h, sqlite3ext.h
-
-The -binding suffix was added to avoid build failures under gccgo.
-
-In this repository, those files are amalgamation code that copied from SQLite3. The license of those codes are depend on the license of SQLite3.
-
-Author
-------
-
-Yasuhiro Matsumoto (a.k.a mattn)

Godeps/_workspace/src/github.com/mattn/go-sqlite3/backup.go

@@ -1,70 +0,0 @@
-// Copyright (C) 2014 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-package sqlite3
-
-/*
-#include <sqlite3-binding.h>
-#include <stdlib.h>
-*/
-import "C"
-import (
-	"runtime"
-	"unsafe"
-)
-
-type SQLiteBackup struct {
-	b *C.sqlite3_backup
-}
-
-func (c *SQLiteConn) Backup(dest string, conn *SQLiteConn, src string) (*SQLiteBackup, error) {
-	destptr := C.CString(dest)
-	defer C.free(unsafe.Pointer(destptr))
-	srcptr := C.CString(src)
-	defer C.free(unsafe.Pointer(srcptr))
-
-	if b := C.sqlite3_backup_init(c.db, destptr, conn.db, srcptr); b != nil {
-		bb := &SQLiteBackup{b: b}
-		runtime.SetFinalizer(bb, (*SQLiteBackup).Finish)
-		return bb, nil
-	}
-	return nil, c.lastError()
-}
-
-// Backs up for one step. Calls the underlying `sqlite3_backup_step` function.
-// This function returns a boolean indicating if the backup is done and
-// an error signalling any other error. Done is returned if the underlying C
-// function returns SQLITE_DONE (Code 101)
-func (b *SQLiteBackup) Step(p int) (bool, error) {
-	ret := C.sqlite3_backup_step(b.b, C.int(p))
-	if ret == C.SQLITE_DONE {
-		return true, nil
-	} else if ret != 0 && ret != C.SQLITE_LOCKED && ret != C.SQLITE_BUSY {
-		return false, Error{Code: ErrNo(ret)}
-	}
-	return false, nil
-}
-
-func (b *SQLiteBackup) Remaining() int {
-	return int(C.sqlite3_backup_remaining(b.b))
-}
-
-func (b *SQLiteBackup) PageCount() int {
-	return int(C.sqlite3_backup_pagecount(b.b))
-}
-
-func (b *SQLiteBackup) Finish() error {
-	return b.Close()
-}
-
-func (b *SQLiteBackup) Close() error {
-	ret := C.sqlite3_backup_finish(b.b)
-	if ret != 0 {
-		return Error{Code: ErrNo(ret)}
-	}
-	b.b = nil
-	runtime.SetFinalizer(b, nil)
-	return nil
-}

Godeps/_workspace/src/github.com/mattn/go-sqlite3/doc.go

@@ -1,95 +0,0 @@
-/*
-Package sqlite3 provides interface to SQLite3 databases.
-
-This works as driver for database/sql.
-
-Installation
-
-    go get github.com/mattn/go-sqlite3
-
-Supported Types
-
-Currently, go-sqlite3 support following data types.
-
-    +------------------------------+
-    |go        | sqlite3           |
-    |----------|-------------------|
-    |nil       | null              |
-    |int       | integer           |
-    |int64     | integer           |
-    |float64   | float             |
-    |bool      | integer           |
-    |[]byte    | blob              |
-    |string    | text              |
-    |time.Time | timestamp/datetime|
-    +------------------------------+
-
-SQLite3 Extension
-
-You can write your own extension module for sqlite3. For example, below is a
-extension for Regexp matcher operation.
-
-    #include <pcre.h>
-    #include <string.h>
-    #include <stdio.h>
-    #include <sqlite3ext.h>
-    
-    SQLITE_EXTENSION_INIT1
-    static void regexp_func(sqlite3_context *context, int argc, sqlite3_value **argv) {
-      if (argc >= 2) {
-        const char *target  = (const char *)sqlite3_value_text(argv[1]);
-        const char *pattern = (const char *)sqlite3_value_text(argv[0]);
-        const char* errstr = NULL;
-        int erroff = 0;
-        int vec[500];
-        int n, rc;
-        pcre* re = pcre_compile(pattern, 0, &errstr, &erroff, NULL);
-        rc = pcre_exec(re, NULL, target, strlen(target), 0, 0, vec, 500); 
-        if (rc <= 0) {
-          sqlite3_result_error(context, errstr, 0);
-          return;
-        }
-        sqlite3_result_int(context, 1);
-      }
-    }
-    
-    #ifdef _WIN32
-    __declspec(dllexport)
-    #endif
-    int sqlite3_extension_init(sqlite3 *db, char **errmsg,
-          const sqlite3_api_routines *api) {
-      SQLITE_EXTENSION_INIT2(api);
-      return sqlite3_create_function(db, "regexp", 2, SQLITE_UTF8,
-          (void*)db, regexp_func, NULL, NULL);
-    }
-
-It need to build as so/dll shared library. And you need to register
-extension module like below.
-
-	sql.Register("sqlite3_with_extensions",
-		&sqlite3.SQLiteDriver{
-			Extensions: []string{
-				"sqlite3_mod_regexp",
-			},
-		})
-
-Then, you can use this extension.
-
-	rows, err := db.Query("select text from mytable where name regexp '^golang'")
-
-Connection Hook
-
-You can hook and inject your codes when connection established. database/sql
-doesn't provide the way to get native go-sqlite3 interfaces. So if you want,
-you need to hook ConnectHook and get the SQLiteConn.
-
-	sql.Register("sqlite3_with_hook_example",
-			&sqlite3.SQLiteDriver{
-					ConnectHook: func(conn *sqlite3.SQLiteConn) error {
-						sqlite3conn = append(sqlite3conn, conn)
-						return nil
-					},
-			})
-
-*/
-package sqlite3

Godeps/_workspace/src/github.com/mattn/go-sqlite3/error.go

@@ -1,128 +0,0 @@
-// Copyright (C) 2014 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-package sqlite3
-
-import "C"
-
-type ErrNo int
-
-const ErrNoMask C.int = 0xff
-
-type ErrNoExtended int
-
-type Error struct {
-	Code         ErrNo         /* The error code returned by SQLite */
-	ExtendedCode ErrNoExtended /* The extended error code returned by SQLite */
-	err          string        /* The error string returned by sqlite3_errmsg(),
-	this usually contains more specific details. */
-}
-
-// result codes from http://www.sqlite.org/c3ref/c_abort.html
-var (
-	ErrError      = ErrNo(1)  /* SQL error or missing database */
-	ErrInternal   = ErrNo(2)  /* Internal logic error in SQLite */
-	ErrPerm       = ErrNo(3)  /* Access permission denied */
-	ErrAbort      = ErrNo(4)  /* Callback routine requested an abort */
-	ErrBusy       = ErrNo(5)  /* The database file is locked */
-	ErrLocked     = ErrNo(6)  /* A table in the database is locked */
-	ErrNomem      = ErrNo(7)  /* A malloc() failed */
-	ErrReadonly   = ErrNo(8)  /* Attempt to write a readonly database */
-	ErrInterrupt  = ErrNo(9)  /* Operation terminated by sqlite3_interrupt() */
-	ErrIoErr      = ErrNo(10) /* Some kind of disk I/O error occurred */
-	ErrCorrupt    = ErrNo(11) /* The database disk image is malformed */
-	ErrNotFound   = ErrNo(12) /* Unknown opcode in sqlite3_file_control() */
-	ErrFull       = ErrNo(13) /* Insertion failed because database is full */
-	ErrCantOpen   = ErrNo(14) /* Unable to open the database file */
-	ErrProtocol   = ErrNo(15) /* Database lock protocol error */
-	ErrEmpty      = ErrNo(16) /* Database is empty */
-	ErrSchema     = ErrNo(17) /* The database schema changed */
-	ErrTooBig     = ErrNo(18) /* String or BLOB exceeds size limit */
-	ErrConstraint = ErrNo(19) /* Abort due to constraint violation */
-	ErrMismatch   = ErrNo(20) /* Data type mismatch */
-	ErrMisuse     = ErrNo(21) /* Library used incorrectly */
-	ErrNoLFS      = ErrNo(22) /* Uses OS features not supported on host */
-	ErrAuth       = ErrNo(23) /* Authorization denied */
-	ErrFormat     = ErrNo(24) /* Auxiliary database format error */
-	ErrRange      = ErrNo(25) /* 2nd parameter to sqlite3_bind out of range */
-	ErrNotADB     = ErrNo(26) /* File opened that is not a database file */
-	ErrNotice     = ErrNo(27) /* Notifications from sqlite3_log() */
-	ErrWarning    = ErrNo(28) /* Warnings from sqlite3_log() */
-)
-
-func (err ErrNo) Error() string {
-	return Error{Code: err}.Error()
-}
-
-func (err ErrNo) Extend(by int) ErrNoExtended {
-	return ErrNoExtended(int(err) | (by << 8))
-}
-
-func (err ErrNoExtended) Error() string {
-	return Error{Code: ErrNo(C.int(err) & ErrNoMask), ExtendedCode: err}.Error()
-}
-
-func (err Error) Error() string {
-	if err.err != "" {
-		return err.err
-	}
-	return errorString(err)
-}
-
-// result codes from http://www.sqlite.org/c3ref/c_abort_rollback.html
-var (
-	ErrIoErrRead              = ErrIoErr.Extend(1)
-	ErrIoErrShortRead         = ErrIoErr.Extend(2)
-	ErrIoErrWrite             = ErrIoErr.Extend(3)
-	ErrIoErrFsync             = ErrIoErr.Extend(4)
-	ErrIoErrDirFsync          = ErrIoErr.Extend(5)
-	ErrIoErrTruncate          = ErrIoErr.Extend(6)
-	ErrIoErrFstat             = ErrIoErr.Extend(7)
-	ErrIoErrUnlock            = ErrIoErr.Extend(8)
-	ErrIoErrRDlock            = ErrIoErr.Extend(9)
-	ErrIoErrDelete            = ErrIoErr.Extend(10)
-	ErrIoErrBlocked           = ErrIoErr.Extend(11)
-	ErrIoErrNoMem             = ErrIoErr.Extend(12)
-	ErrIoErrAccess            = ErrIoErr.Extend(13)
-	ErrIoErrCheckReservedLock = ErrIoErr.Extend(14)
-	ErrIoErrLock              = ErrIoErr.Extend(15)
-	ErrIoErrClose             = ErrIoErr.Extend(16)
-	ErrIoErrDirClose          = ErrIoErr.Extend(17)
-	ErrIoErrSHMOpen           = ErrIoErr.Extend(18)
-	ErrIoErrSHMSize           = ErrIoErr.Extend(19)
-	ErrIoErrSHMLock           = ErrIoErr.Extend(20)
-	ErrIoErrSHMMap            = ErrIoErr.Extend(21)
-	ErrIoErrSeek              = ErrIoErr.Extend(22)
-	ErrIoErrDeleteNoent       = ErrIoErr.Extend(23)
-	ErrIoErrMMap              = ErrIoErr.Extend(24)
-	ErrIoErrGetTempPath       = ErrIoErr.Extend(25)
-	ErrIoErrConvPath          = ErrIoErr.Extend(26)
-	ErrLockedSharedCache      = ErrLocked.Extend(1)
-	ErrBusyRecovery           = ErrBusy.Extend(1)
-	ErrBusySnapshot           = ErrBusy.Extend(2)
-	ErrCantOpenNoTempDir      = ErrCantOpen.Extend(1)
-	ErrCantOpenIsDir          = ErrCantOpen.Extend(2)
-	ErrCantOpenFullPath       = ErrCantOpen.Extend(3)
-	ErrCantOpenConvPath       = ErrCantOpen.Extend(4)
-	ErrCorruptVTab            = ErrCorrupt.Extend(1)
-	ErrReadonlyRecovery       = ErrReadonly.Extend(1)
-	ErrReadonlyCantLock       = ErrReadonly.Extend(2)
-	ErrReadonlyRollback       = ErrReadonly.Extend(3)
-	ErrReadonlyDbMoved        = ErrReadonly.Extend(4)
-	ErrAbortRollback          = ErrAbort.Extend(2)
-	ErrConstraintCheck        = ErrConstraint.Extend(1)
-	ErrConstraintCommitHook   = ErrConstraint.Extend(2)
-	ErrConstraintForeignKey   = ErrConstraint.Extend(3)
-	ErrConstraintFunction     = ErrConstraint.Extend(4)
-	ErrConstraintNotNull      = ErrConstraint.Extend(5)
-	ErrConstraintPrimaryKey   = ErrConstraint.Extend(6)
-	ErrConstraintTrigger      = ErrConstraint.Extend(7)
-	ErrConstraintUnique       = ErrConstraint.Extend(8)
-	ErrConstraintVTab         = ErrConstraint.Extend(9)
-	ErrConstraintRowId        = ErrConstraint.Extend(10)
-	ErrNoticeRecoverWAL       = ErrNotice.Extend(1)
-	ErrNoticeRecoverRollback  = ErrNotice.Extend(2)
-	ErrWarningAutoIndex       = ErrWarning.Extend(1)
-)

Godeps/_workspace/src/github.com/mattn/go-sqlite3/error_test.go

@@ -1,242 +0,0 @@
-// Copyright (C) 2014 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-package sqlite3
-
-import (
-	"database/sql"
-	"io/ioutil"
-	"os"
-	"path"
-	"testing"
-)
-
-func TestSimpleError(t *testing.T) {
-	e := ErrError.Error()
-	if e != "SQL logic error or missing database" {
-		t.Error("wrong error code:" + e)
-	}
-}
-
-func TestCorruptDbErrors(t *testing.T) {
-	dirName, err := ioutil.TempDir("", "sqlite3")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dirName)
-
-	dbFileName := path.Join(dirName, "test.db")
-	f, err := os.Create(dbFileName)
-	if err != nil {
-		t.Error(err)
-	}
-	f.Write([]byte{1, 2, 3, 4, 5})
-	f.Close()
-
-	db, err := sql.Open("sqlite3", dbFileName)
-	if err == nil {
-		_, err = db.Exec("drop table foo")
-	}
-
-	sqliteErr := err.(Error)
-	if sqliteErr.Code != ErrNotADB {
-		t.Error("wrong error code for corrupted DB")
-	}
-	if err.Error() == "" {
-		t.Error("wrong error string for corrupted DB")
-	}
-	db.Close()
-}
-
-func TestSqlLogicErrors(t *testing.T) {
-	dirName, err := ioutil.TempDir("", "sqlite3")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dirName)
-
-	dbFileName := path.Join(dirName, "test.db")
-	db, err := sql.Open("sqlite3", dbFileName)
-	if err != nil {
-		t.Error(err)
-	}
-	defer db.Close()
-
-	_, err = db.Exec("CREATE TABLE Foo (id INTEGER PRIMARY KEY)")
-	if err != nil {
-		t.Error(err)
-	}
-
-	const expectedErr = "table Foo already exists"
-	_, err = db.Exec("CREATE TABLE Foo (id INTEGER PRIMARY KEY)")
-	if err.Error() != expectedErr {
-		t.Errorf("Unexpected error: %s, expected %s", err.Error(), expectedErr)
-	}
-
-}
-
-func TestExtendedErrorCodes_ForeignKey(t *testing.T) {
-	dirName, err := ioutil.TempDir("", "sqlite3-err")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dirName)
-
-	dbFileName := path.Join(dirName, "test.db")
-	db, err := sql.Open("sqlite3", dbFileName)
-	if err != nil {
-		t.Error(err)
-	}
-	defer db.Close()
-
-	_, err = db.Exec("PRAGMA foreign_keys=ON;")
-	if err != nil {
-		t.Errorf("PRAGMA foreign_keys=ON: %v", err)
-	}
-
-	_, err = db.Exec(`CREATE TABLE Foo (
-		id INTEGER PRIMARY KEY AUTOINCREMENT,
-		value INTEGER NOT NULL,
-		ref INTEGER NULL REFERENCES Foo (id),
-		UNIQUE(value)
-	);`)
-	if err != nil {
-		t.Error(err)
-	}
-
-	_, err = db.Exec("INSERT INTO Foo (ref, value) VALUES (100, 100);")
-	if err == nil {
-		t.Error("No error!")
-	} else {
-		sqliteErr := err.(Error)
-		if sqliteErr.Code != ErrConstraint {
-			t.Errorf("Wrong basic error code: %d != %d",
-				sqliteErr.Code, ErrConstraint)
-		}
-		if sqliteErr.ExtendedCode != ErrConstraintForeignKey {
-			t.Errorf("Wrong extended error code: %d != %d",
-				sqliteErr.ExtendedCode, ErrConstraintForeignKey)
-		}
-	}
-
-}
-
-func TestExtendedErrorCodes_NotNull(t *testing.T) {
-	dirName, err := ioutil.TempDir("", "sqlite3-err")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dirName)
-
-	dbFileName := path.Join(dirName, "test.db")
-	db, err := sql.Open("sqlite3", dbFileName)
-	if err != nil {
-		t.Error(err)
-	}
-	defer db.Close()
-
-	_, err = db.Exec("PRAGMA foreign_keys=ON;")
-	if err != nil {
-		t.Errorf("PRAGMA foreign_keys=ON: %v", err)
-	}
-
-	_, err = db.Exec(`CREATE TABLE Foo (
-		id INTEGER PRIMARY KEY AUTOINCREMENT,
-		value INTEGER NOT NULL,
-		ref INTEGER NULL REFERENCES Foo (id),
-		UNIQUE(value)
-	);`)
-	if err != nil {
-		t.Error(err)
-	}
-
-	res, err := db.Exec("INSERT INTO Foo (value) VALUES (100);")
-	if err != nil {
-		t.Fatalf("Creating first row: %v", err)
-	}
-
-	id, err := res.LastInsertId()
-	if err != nil {
-		t.Fatalf("Retrieving last insert id: %v", err)
-	}
-
-	_, err = db.Exec("INSERT INTO Foo (ref) VALUES (?);", id)
-	if err == nil {
-		t.Error("No error!")
-	} else {
-		sqliteErr := err.(Error)
-		if sqliteErr.Code != ErrConstraint {
-			t.Errorf("Wrong basic error code: %d != %d",
-				sqliteErr.Code, ErrConstraint)
-		}
-		if sqliteErr.ExtendedCode != ErrConstraintNotNull {
-			t.Errorf("Wrong extended error code: %d != %d",
-				sqliteErr.ExtendedCode, ErrConstraintNotNull)
-		}
-	}
-
-}
-
-func TestExtendedErrorCodes_Unique(t *testing.T) {
-	dirName, err := ioutil.TempDir("", "sqlite3-err")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dirName)
-
-	dbFileName := path.Join(dirName, "test.db")
-	db, err := sql.Open("sqlite3", dbFileName)
-	if err != nil {
-		t.Error(err)
-	}
-	defer db.Close()
-
-	_, err = db.Exec("PRAGMA foreign_keys=ON;")
-	if err != nil {
-		t.Errorf("PRAGMA foreign_keys=ON: %v", err)
-	}
-
-	_, err = db.Exec(`CREATE TABLE Foo (
-		id INTEGER PRIMARY KEY AUTOINCREMENT,
-		value INTEGER NOT NULL,
-		ref INTEGER NULL REFERENCES Foo (id),
-		UNIQUE(value)
-	);`)
-	if err != nil {
-		t.Error(err)
-	}
-
-	res, err := db.Exec("INSERT INTO Foo (value) VALUES (100);")
-	if err != nil {
-		t.Fatalf("Creating first row: %v", err)
-	}
-
-	id, err := res.LastInsertId()
-	if err != nil {
-		t.Fatalf("Retrieving last insert id: %v", err)
-	}
-
-	_, err = db.Exec("INSERT INTO Foo (ref, value) VALUES (?, 100);", id)
-	if err == nil {
-		t.Error("No error!")
-	} else {
-		sqliteErr := err.(Error)
-		if sqliteErr.Code != ErrConstraint {
-			t.Errorf("Wrong basic error code: %d != %d",
-				sqliteErr.Code, ErrConstraint)
-		}
-		if sqliteErr.ExtendedCode != ErrConstraintUnique {
-			t.Errorf("Wrong extended error code: %d != %d",
-				sqliteErr.ExtendedCode, ErrConstraintUnique)
-		}
-		extended := sqliteErr.Code.Extend(3).Error()
-		expected := "constraint failed"
-		if extended != expected {
-			t.Errorf("Wrong basic error code: %q != %q",
-				extended, expected)
-		}
-	}
-
-}

Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3.go

@@ -1,604 +0,0 @@
-// Copyright (C) 2014 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-package sqlite3
-
-/*
-#cgo CFLAGS: -std=gnu99
-#cgo CFLAGS: -DSQLITE_ENABLE_RTREE -DSQLITE_THREADSAFE
-#cgo CFLAGS: -DSQLITE_ENABLE_FTS3 -DSQLITE_ENABLE_FTS3_PARENTHESIS
-#include <sqlite3-binding.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef __CYGWIN__
-# include <errno.h>
-#endif
-
-#ifndef SQLITE_OPEN_READWRITE
-# define SQLITE_OPEN_READWRITE 0
-#endif
-
-#ifndef SQLITE_OPEN_FULLMUTEX
-# define SQLITE_OPEN_FULLMUTEX 0
-#endif
-
-static int
-_sqlite3_open_v2(const char *filename, sqlite3 **ppDb, int flags, const char *zVfs) {
-#ifdef SQLITE_OPEN_URI
-  return sqlite3_open_v2(filename, ppDb, flags | SQLITE_OPEN_URI, zVfs);
-#else
-  return sqlite3_open_v2(filename, ppDb, flags, zVfs);
-#endif
-}
-
-static int
-_sqlite3_bind_text(sqlite3_stmt *stmt, int n, char *p, int np) {
-  return sqlite3_bind_text(stmt, n, p, np, SQLITE_TRANSIENT);
-}
-
-static int
-_sqlite3_bind_blob(sqlite3_stmt *stmt, int n, void *p, int np) {
-  return sqlite3_bind_blob(stmt, n, p, np, SQLITE_TRANSIENT);
-}
-
-#include <stdio.h>
-#include <stdint.h>
-
-static long
-_sqlite3_last_insert_rowid(sqlite3* db) {
-  return (long) sqlite3_last_insert_rowid(db);
-}
-
-static long
-_sqlite3_changes(sqlite3* db) {
-  return (long) sqlite3_changes(db);
-}
-
-*/
-import "C"
-import (
-	"database/sql"
-	"database/sql/driver"
-	"errors"
-	"fmt"
-	"io"
-	"net/url"
-	"runtime"
-	"strconv"
-	"strings"
-	"time"
-	"unsafe"
-)
-
-// Timestamp formats understood by both this module and SQLite.
-// The first format in the slice will be used when saving time values
-// into the database. When parsing a string from a timestamp or
-// datetime column, the formats are tried in order.
-var SQLiteTimestampFormats = []string{
-	"2006-01-02 15:04:05.999999999",
-	"2006-01-02T15:04:05.999999999",
-	"2006-01-02 15:04:05",
-	"2006-01-02T15:04:05",
-	"2006-01-02 15:04",
-	"2006-01-02T15:04",
-	"2006-01-02",
-	"2006-01-02 15:04:05-07:00",
-}
-
-func init() {
-	sql.Register("sqlite3", &SQLiteDriver{})
-}
-
-// Return SQLite library Version information.
-func Version() (libVersion string, libVersionNumber int, sourceId string) {
-	libVersion = C.GoString(C.sqlite3_libversion())
-	libVersionNumber = int(C.sqlite3_libversion_number())
-	sourceId = C.GoString(C.sqlite3_sourceid())
-	return libVersion, libVersionNumber, sourceId
-}
-
-// Driver struct.
-type SQLiteDriver struct {
-	Extensions  []string
-	ConnectHook func(*SQLiteConn) error
-}
-
-// Conn struct.
-type SQLiteConn struct {
-	db  *C.sqlite3
-	loc *time.Location
-}
-
-// Tx struct.
-type SQLiteTx struct {
-	c *SQLiteConn
-}
-
-// Stmt struct.
-type SQLiteStmt struct {
-	c      *SQLiteConn
-	s      *C.sqlite3_stmt
-	t      string
-	closed bool
-	cls    bool
-}
-
-// Result struct.
-type SQLiteResult struct {
-	id      int64
-	changes int64
-}
-
-// Rows struct.
-type SQLiteRows struct {
-	s        *SQLiteStmt
-	nc       int
-	cols     []string
-	decltype []string
-	cls      bool
-}
-
-// Commit transaction.
-func (tx *SQLiteTx) Commit() error {
-	_, err := tx.c.exec("COMMIT")
-	return err
-}
-
-// Rollback transaction.
-func (tx *SQLiteTx) Rollback() error {
-	_, err := tx.c.exec("ROLLBACK")
-	return err
-}
-
-// AutoCommit return which currently auto commit or not.
-func (c *SQLiteConn) AutoCommit() bool {
-	return int(C.sqlite3_get_autocommit(c.db)) != 0
-}
-
-func (c *SQLiteConn) lastError() Error {
-	return Error{
-		Code:         ErrNo(C.sqlite3_errcode(c.db)),
-		ExtendedCode: ErrNoExtended(C.sqlite3_extended_errcode(c.db)),
-		err:          C.GoString(C.sqlite3_errmsg(c.db)),
-	}
-}
-
-// Implements Execer
-func (c *SQLiteConn) Exec(query string, args []driver.Value) (driver.Result, error) {
-	if len(args) == 0 {
-		return c.exec(query)
-	}
-
-	for {
-		s, err := c.Prepare(query)
-		if err != nil {
-			return nil, err
-		}
-		var res driver.Result
-		if s.(*SQLiteStmt).s != nil {
-			na := s.NumInput()
-			if len(args) < na {
-				return nil, fmt.Errorf("Not enough args to execute query. Expected %d, got %d.", na, len(args))
-			}
-			res, err = s.Exec(args[:na])
-			if err != nil && err != driver.ErrSkip {
-				s.Close()
-				return nil, err
-			}
-			args = args[na:]
-		}
-		tail := s.(*SQLiteStmt).t
-		s.Close()
-		if tail == "" {
-			return res, nil
-		}
-		query = tail
-	}
-}
-
-// Implements Queryer
-func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, error) {
-	for {
-		s, err := c.Prepare(query)
-		if err != nil {
-			return nil, err
-		}
-		s.(*SQLiteStmt).cls = true
-		na := s.NumInput()
-		if len(args) < na {
-			return nil, fmt.Errorf("Not enough args to execute query. Expected %d, got %d.", na, len(args))
-		}
-		rows, err := s.Query(args[:na])
-		if err != nil && err != driver.ErrSkip {
-			s.Close()
-			return nil, err
-		}
-		args = args[na:]
-		tail := s.(*SQLiteStmt).t
-		if tail == "" {
-			return rows, nil
-		}
-		rows.Close()
-		s.Close()
-		query = tail
-	}
-}
-
-func (c *SQLiteConn) exec(cmd string) (driver.Result, error) {
-	pcmd := C.CString(cmd)
-	defer C.free(unsafe.Pointer(pcmd))
-	rv := C.sqlite3_exec(c.db, pcmd, nil, nil, nil)
-	if rv != C.SQLITE_OK {
-		return nil, c.lastError()
-	}
-	return &SQLiteResult{
-		int64(C._sqlite3_last_insert_rowid(c.db)),
-		int64(C._sqlite3_changes(c.db)),
-	}, nil
-}
-
-// Begin transaction.
-func (c *SQLiteConn) Begin() (driver.Tx, error) {
-	if _, err := c.exec("BEGIN"); err != nil {
-		return nil, err
-	}
-	return &SQLiteTx{c}, nil
-}
-
-func errorString(err Error) string {
-	return C.GoString(C.sqlite3_errstr(C.int(err.Code)))
-}
-
-// Open database and return a new connection.
-// You can specify DSN string with URI filename.
-//   test.db
-//   file:test.db?cache=shared&mode=memory
-//   :memory:
-//   file::memory:
-// go-sqlite handle especially query parameters.
-//   loc=XXX
-//     Specify location of time format. It's possible to specify "auto".
-func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) {
-	if C.sqlite3_threadsafe() == 0 {
-		return nil, errors.New("sqlite library was not compiled for thread-safe operation")
-	}
-
-	var loc *time.Location
-	pos := strings.IndexRune(dsn, '?')
-	if pos >= 1 {
-		params, err := url.ParseQuery(dsn[pos+1:])
-		if err != nil {
-			return nil, err
-		}
-
-		// loc
-		if val := params.Get("loc"); val != "" {
-			if val == "auto" {
-				loc = time.Local
-			} else {
-				loc, err = time.LoadLocation(val)
-				if err != nil {
-					return nil, fmt.Errorf("Invalid loc: %v: %v", val, err)
-				}
-			}
-		}
-
-		if !strings.HasPrefix(dsn, "file:") {
-			dsn = dsn[:pos]
-		}
-	}
-
-	var db *C.sqlite3
-	name := C.CString(dsn)
-	defer C.free(unsafe.Pointer(name))
-	rv := C._sqlite3_open_v2(name, &db,
-		C.SQLITE_OPEN_FULLMUTEX|
-			C.SQLITE_OPEN_READWRITE|
-			C.SQLITE_OPEN_CREATE,
-		nil)
-	if rv != 0 {
-		return nil, Error{Code: ErrNo(rv)}
-	}
-	if db == nil {
-		return nil, errors.New("sqlite succeeded without returning a database")
-	}
-
-	rv = C.sqlite3_busy_timeout(db, 5000)
-	if rv != C.SQLITE_OK {
-		return nil, Error{Code: ErrNo(rv)}
-	}
-
-	conn := &SQLiteConn{db: db, loc: loc}
-
-	if len(d.Extensions) > 0 {
-		rv = C.sqlite3_enable_load_extension(db, 1)
-		if rv != C.SQLITE_OK {
-			return nil, errors.New(C.GoString(C.sqlite3_errmsg(db)))
-		}
-
-		for _, extension := range d.Extensions {
-			cext := C.CString(extension)
-			defer C.free(unsafe.Pointer(cext))
-			rv = C.sqlite3_load_extension(db, cext, nil, nil)
-			if rv != C.SQLITE_OK {
-				return nil, errors.New(C.GoString(C.sqlite3_errmsg(db)))
-			}
-		}
-
-		rv = C.sqlite3_enable_load_extension(db, 0)
-		if rv != C.SQLITE_OK {
-			return nil, errors.New(C.GoString(C.sqlite3_errmsg(db)))
-		}
-	}
-
-	if d.ConnectHook != nil {
-		if err := d.ConnectHook(conn); err != nil {
-			return nil, err
-		}
-	}
-	runtime.SetFinalizer(conn, (*SQLiteConn).Close)
-	return conn, nil
-}
-
-// Close the connection.
-func (c *SQLiteConn) Close() error {
-	rv := C.sqlite3_close_v2(c.db)
-	if rv != C.SQLITE_OK {
-		return c.lastError()
-	}
-	c.db = nil
-	runtime.SetFinalizer(c, nil)
-	return nil
-}
-
-// Prepare query string. Return a new statement.
-func (c *SQLiteConn) Prepare(query string) (driver.Stmt, error) {
-	pquery := C.CString(query)
-	defer C.free(unsafe.Pointer(pquery))
-	var s *C.sqlite3_stmt
-	var tail *C.char
-	rv := C.sqlite3_prepare_v2(c.db, pquery, -1, &s, &tail)
-	if rv != C.SQLITE_OK {
-		return nil, c.lastError()
-	}
-	var t string
-	if tail != nil && C.strlen(tail) > 0 {
-		t = strings.TrimSpace(C.GoString(tail))
-	}
-	ss := &SQLiteStmt{c: c, s: s, t: t}
-	runtime.SetFinalizer(ss, (*SQLiteStmt).Close)
-	return ss, nil
-}
-
-// Close the statement.
-func (s *SQLiteStmt) Close() error {
-	if s.closed {
-		return nil
-	}
-	s.closed = true
-	if s.c == nil || s.c.db == nil {
-		return errors.New("sqlite statement with already closed database connection")
-	}
-	rv := C.sqlite3_finalize(s.s)
-	if rv != C.SQLITE_OK {
-		return s.c.lastError()
-	}
-	runtime.SetFinalizer(s, nil)
-	return nil
-}
-
-// Return a number of parameters.
-func (s *SQLiteStmt) NumInput() int {
-	return int(C.sqlite3_bind_parameter_count(s.s))
-}
-
-func (s *SQLiteStmt) bind(args []driver.Value) error {
-	rv := C.sqlite3_reset(s.s)
-	if rv != C.SQLITE_ROW && rv != C.SQLITE_OK && rv != C.SQLITE_DONE {
-		return s.c.lastError()
-	}
-
-	for i, v := range args {
-		n := C.int(i + 1)
-		switch v := v.(type) {
-		case nil:
-			rv = C.sqlite3_bind_null(s.s, n)
-		case string:
-			if len(v) == 0 {
-				b := []byte{0}
-				rv = C._sqlite3_bind_text(s.s, n, (*C.char)(unsafe.Pointer(&b[0])), C.int(0))
-			} else {
-				b := []byte(v)
-				rv = C._sqlite3_bind_text(s.s, n, (*C.char)(unsafe.Pointer(&b[0])), C.int(len(b)))
-			}
-		case int64:
-			rv = C.sqlite3_bind_int64(s.s, n, C.sqlite3_int64(v))
-		case bool:
-			if bool(v) {
-				rv = C.sqlite3_bind_int(s.s, n, 1)
-			} else {
-				rv = C.sqlite3_bind_int(s.s, n, 0)
-			}
-		case float64:
-			rv = C.sqlite3_bind_double(s.s, n, C.double(v))
-		case []byte:
-			var p *byte
-			if len(v) > 0 {
-				p = &v[0]
-			}
-			rv = C._sqlite3_bind_blob(s.s, n, unsafe.Pointer(p), C.int(len(v)))
-		case time.Time:
-			b := []byte(v.UTC().Format(SQLiteTimestampFormats[0]))
-			rv = C._sqlite3_bind_text(s.s, n, (*C.char)(unsafe.Pointer(&b[0])), C.int(len(b)))
-		}
-		if rv != C.SQLITE_OK {
-			return s.c.lastError()
-		}
-	}
-	return nil
-}
-
-// Query the statement with arguments. Return records.
-func (s *SQLiteStmt) Query(args []driver.Value) (driver.Rows, error) {
-	if err := s.bind(args); err != nil {
-		return nil, err
-	}
-	return &SQLiteRows{s, int(C.sqlite3_column_count(s.s)), nil, nil, s.cls}, nil
-}
-
-// Return last inserted ID.
-func (r *SQLiteResult) LastInsertId() (int64, error) {
-	return r.id, nil
-}
-
-// Return how many rows affected.
-func (r *SQLiteResult) RowsAffected() (int64, error) {
-	return r.changes, nil
-}
-
-// 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 {
-		C.sqlite3_reset(s.s)
-		return nil, err
-	}
-	rv := C.sqlite3_step(s.s)
-	if rv != C.SQLITE_ROW && rv != C.SQLITE_OK && rv != C.SQLITE_DONE {
-		err := s.c.lastError()
-		C.sqlite3_reset(s.s)
-		return nil, err
-	}
-
-	res := &SQLiteResult{
-		int64(C._sqlite3_last_insert_rowid(s.c.db)),
-		int64(C._sqlite3_changes(s.c.db)),
-	}
-	return res, nil
-}
-
-// Close the rows.
-func (rc *SQLiteRows) Close() error {
-	if rc.s.closed {
-		return nil
-	}
-	if rc.cls {
-		return rc.s.Close()
-	}
-	rv := C.sqlite3_reset(rc.s.s)
-	if rv != C.SQLITE_OK {
-		return rc.s.c.lastError()
-	}
-	return nil
-}
-
-// Return column names.
-func (rc *SQLiteRows) Columns() []string {
-	if rc.nc != len(rc.cols) {
-		rc.cols = make([]string, rc.nc)
-		for i := 0; i < rc.nc; i++ {
-			rc.cols[i] = C.GoString(C.sqlite3_column_name(rc.s.s, C.int(i)))
-		}
-	}
-	return rc.cols
-}
-
-// Move cursor to next.
-func (rc *SQLiteRows) Next(dest []driver.Value) error {
-	rv := C.sqlite3_step(rc.s.s)
-	if rv == C.SQLITE_DONE {
-		return io.EOF
-	}
-	if rv != C.SQLITE_ROW {
-		rv = C.sqlite3_reset(rc.s.s)
-		if rv != C.SQLITE_OK {
-			return rc.s.c.lastError()
-		}
-		return nil
-	}
-
-	if rc.decltype == nil {
-		rc.decltype = make([]string, rc.nc)
-		for i := 0; i < rc.nc; i++ {
-			rc.decltype[i] = strings.ToLower(C.GoString(C.sqlite3_column_decltype(rc.s.s, C.int(i))))
-		}
-	}
-
-	for i := range dest {
-		switch C.sqlite3_column_type(rc.s.s, C.int(i)) {
-		case C.SQLITE_INTEGER:
-			val := int64(C.sqlite3_column_int64(rc.s.s, C.int(i)))
-			switch rc.decltype[i] {
-			case "timestamp", "datetime", "date":
-				unixTimestamp := strconv.FormatInt(val, 10)
-				var t time.Time
-				if len(unixTimestamp) == 13 {
-					duration, err := time.ParseDuration(unixTimestamp + "ms")
-					if err != nil {
-						return fmt.Errorf("error parsing %s value %d, %s", rc.decltype[i], val, err)
-					}
-					epoch := time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC)
-					t = epoch.Add(duration)
-				} else {
-					t = time.Unix(val, 0)
-				}
-				if rc.s.c.loc != nil {
-					t = t.In(rc.s.c.loc)
-				}
-				dest[i] = t
-			case "boolean":
-				dest[i] = val > 0
-			default:
-				dest[i] = val
-			}
-		case C.SQLITE_FLOAT:
-			dest[i] = float64(C.sqlite3_column_double(rc.s.s, C.int(i)))
-		case C.SQLITE_BLOB:
-			p := C.sqlite3_column_blob(rc.s.s, C.int(i))
-			if p == nil {
-				dest[i] = nil
-				continue
-			}
-			n := int(C.sqlite3_column_bytes(rc.s.s, C.int(i)))
-			switch dest[i].(type) {
-			case sql.RawBytes:
-				dest[i] = (*[1 << 30]byte)(unsafe.Pointer(p))[0:n]
-			default:
-				slice := make([]byte, n)
-				copy(slice[:], (*[1 << 30]byte)(unsafe.Pointer(p))[0:n])
-				dest[i] = slice
-			}
-		case C.SQLITE_NULL:
-			dest[i] = nil
-		case C.SQLITE_TEXT:
-			var err error
-			var timeVal time.Time
-			s := C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(rc.s.s, C.int(i)))))
-
-			switch rc.decltype[i] {
-			case "timestamp", "datetime", "date":
-				var t time.Time
-				for _, format := range SQLiteTimestampFormats {
-					if timeVal, err = time.ParseInLocation(format, s, time.UTC); err == nil {
-						t = timeVal
-						break
-					}
-				}
-				if err != nil {
-					// The column is a time value, so return the zero time on parse failure.
-					t = time.Time{}
-				}
-				if rc.s.c.loc != nil {
-					t = t.In(rc.s.c.loc)
-				}
-				dest[i] = t
-			default:
-				dest[i] = []byte(s)
-			}
-
-		}
-	}
-	return nil
-}

Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_fts3_test.go

@@ -1,83 +0,0 @@
-// Copyright (C) 2015 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-package sqlite3
-
-import (
-	"database/sql"
-	"os"
-	"testing"
-)
-
-func TestFTS3(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	defer os.Remove(tempFilename)
-	defer db.Close()
-
-	_, err = db.Exec("DROP TABLE foo")
-	_, err = db.Exec("CREATE VIRTUAL TABLE foo USING fts3(id INTEGER PRIMARY KEY, value TEXT)")
-	if err != nil {
-		t.Fatal("Failed to create table:", err)
-	}
-
-	_, err = db.Exec("INSERT INTO foo(id, value) VALUES(?, ?)", 1, `今日の 晩御飯は 天麩羅よ`)
-	if err != nil {
-		t.Fatal("Failed to insert value:", err)
-	}
-
-	_, err = db.Exec("INSERT INTO foo(id, value) VALUES(?, ?)", 2, `今日は いい 天気だ`)
-	if err != nil {
-		t.Fatal("Failed to insert value:", err)
-	}
-
-	rows, err := db.Query("SELECT id, value FROM foo WHERE value MATCH '今日* 天*'")
-	if err != nil {
-		t.Fatal("Unable to query foo table:", err)
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var id int
-		var value string
-
-		if err := rows.Scan(&id, &value); err != nil {
-			t.Error("Unable to scan results:", err)
-			continue
-		}
-
-		if id == 1 && value != `今日の 晩御飯は 天麩羅よ` {
-			t.Error("Value for id 1 should be `今日の 晩御飯は 天麩羅よ`, but:", value)
-		} else if id == 2 && value != `今日は いい 天気だ` {
-			t.Error("Value for id 2 should be `今日は いい 天気だ`, but:", value)
-		}
-	}
-
-	rows, err = db.Query("SELECT value FROM foo WHERE value MATCH '今日* 天麩羅*'")
-	if err != nil {
-		t.Fatal("Unable to query foo table:", err)
-	}
-	defer rows.Close()
-
-	var value string
-	if !rows.Next() {
-		t.Fatal("Result should be only one")
-	}
-
-	if err := rows.Scan(&value); err != nil {
-		t.Fatal("Unable to scan results:", err)
-	}
-
-	if value != `今日の 晩御飯は 天麩羅よ` {
-		t.Fatal("Value should be `今日の 晩御飯は 天麩羅よ`, but:", value)
-	}
-
-	if rows.Next() {
-		t.Fatal("Result should be only one")
-	}
-}

Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_other.go

@@ -1,14 +0,0 @@
-// Copyright (C) 2014 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-// +build !windows
-
-package sqlite3
-
-/*
-#cgo CFLAGS: -I.
-#cgo linux LDFLAGS: -ldl
-#cgo LDFLAGS: -lpthread
-*/
-import "C"

Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test.go

@@ -1,911 +0,0 @@
-// Copyright (C) 2014 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-package sqlite3
-
-import (
-	"crypto/rand"
-	"database/sql"
-	"encoding/hex"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/letsencrypt/boulder/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test"
-)
-
-func TempFilename() string {
-	randBytes := make([]byte, 16)
-	rand.Read(randBytes)
-	return filepath.Join(os.TempDir(), "foo"+hex.EncodeToString(randBytes)+".db")
-}
-
-func TestOpen(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	defer os.Remove(tempFilename)
-	defer db.Close()
-
-	_, err = db.Exec("drop table foo")
-	_, err = db.Exec("create table foo (id integer)")
-	if err != nil {
-		t.Fatal("Failed to create table:", err)
-	}
-
-	if stat, err := os.Stat(tempFilename); err != nil || stat.IsDir() {
-		t.Error("Failed to create ./foo.db")
-	}
-}
-
-func TestClose(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	defer os.Remove(tempFilename)
-
-	_, err = db.Exec("drop table foo")
-	_, err = db.Exec("create table foo (id integer)")
-	if err != nil {
-		t.Fatal("Failed to create table:", err)
-	}
-
-	stmt, err := db.Prepare("select id from foo where id = ?")
-	if err != nil {
-		t.Fatal("Failed to select records:", err)
-	}
-
-	db.Close()
-	_, err = stmt.Exec(1)
-	if err == nil {
-		t.Fatal("Failed to operate closed statement")
-	}
-}
-
-func TestInsert(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	defer os.Remove(tempFilename)
-	defer db.Close()
-
-	_, err = db.Exec("drop table foo")
-	_, err = db.Exec("create table foo (id integer)")
-	if err != nil {
-		t.Fatal("Failed to create table:", err)
-	}
-
-	res, err := db.Exec("insert into foo(id) values(123)")
-	if err != nil {
-		t.Fatal("Failed to insert record:", err)
-	}
-	affected, _ := res.RowsAffected()
-	if affected != 1 {
-		t.Fatalf("Expected %d for affected rows, but %d:", 1, affected)
-	}
-
-	rows, err := db.Query("select id from foo")
-	if err != nil {
-		t.Fatal("Failed to select records:", err)
-	}
-	defer rows.Close()
-
-	rows.Next()
-
-	var result int
-	rows.Scan(&result)
-	if result != 123 {
-		t.Errorf("Fetched %q; expected %q", 123, result)
-	}
-}
-
-func TestUpdate(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	defer os.Remove(tempFilename)
-	defer db.Close()
-
-	_, err = db.Exec("drop table foo")
-	_, err = db.Exec("create table foo (id integer)")
-	if err != nil {
-		t.Fatal("Failed to create table:", err)
-	}
-
-	res, err := db.Exec("insert into foo(id) values(123)")
-	if err != nil {
-		t.Fatal("Failed to insert record:", err)
-	}
-	expected, err := res.LastInsertId()
-	if err != nil {
-		t.Fatal("Failed to get LastInsertId:", err)
-	}
-	affected, _ := res.RowsAffected()
-	if err != nil {
-		t.Fatal("Failed to get RowsAffected:", err)
-	}
-	if affected != 1 {
-		t.Fatalf("Expected %d for affected rows, but %d:", 1, affected)
-	}
-
-	res, err = db.Exec("update foo set id = 234")
-	if err != nil {
-		t.Fatal("Failed to update record:", err)
-	}
-	lastId, err := res.LastInsertId()
-	if err != nil {
-		t.Fatal("Failed to get LastInsertId:", err)
-	}
-	if expected != lastId {
-		t.Errorf("Expected %q for last Id, but %q:", expected, lastId)
-	}
-	affected, _ = res.RowsAffected()
-	if err != nil {
-		t.Fatal("Failed to get RowsAffected:", err)
-	}
-	if affected != 1 {
-		t.Fatalf("Expected %d for affected rows, but %d:", 1, affected)
-	}
-
-	rows, err := db.Query("select id from foo")
-	if err != nil {
-		t.Fatal("Failed to select records:", err)
-	}
-	defer rows.Close()
-
-	rows.Next()
-
-	var result int
-	rows.Scan(&result)
-	if result != 234 {
-		t.Errorf("Fetched %q; expected %q", 234, result)
-	}
-}
-
-func TestDelete(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	defer os.Remove(tempFilename)
-	defer db.Close()
-
-	_, err = db.Exec("drop table foo")
-	_, err = db.Exec("create table foo (id integer)")
-	if err != nil {
-		t.Fatal("Failed to create table:", err)
-	}
-
-	res, err := db.Exec("insert into foo(id) values(123)")
-	if err != nil {
-		t.Fatal("Failed to insert record:", err)
-	}
-	expected, err := res.LastInsertId()
-	if err != nil {
-		t.Fatal("Failed to get LastInsertId:", err)
-	}
-	affected, err := res.RowsAffected()
-	if err != nil {
-		t.Fatal("Failed to get RowsAffected:", err)
-	}
-	if affected != 1 {
-		t.Errorf("Expected %d for cout of affected rows, but %q:", 1, affected)
-	}
-
-	res, err = db.Exec("delete from foo where id = 123")
-	if err != nil {
-		t.Fatal("Failed to delete record:", err)
-	}
-	lastId, err := res.LastInsertId()
-	if err != nil {
-		t.Fatal("Failed to get LastInsertId:", err)
-	}
-	if expected != lastId {
-		t.Errorf("Expected %q for last Id, but %q:", expected, lastId)
-	}
-	affected, err = res.RowsAffected()
-	if err != nil {
-		t.Fatal("Failed to get RowsAffected:", err)
-	}
-	if affected != 1 {
-		t.Errorf("Expected %d for cout of affected rows, but %q:", 1, affected)
-	}
-
-	rows, err := db.Query("select id from foo")
-	if err != nil {
-		t.Fatal("Failed to select records:", err)
-	}
-	defer rows.Close()
-
-	if rows.Next() {
-		t.Error("Fetched row but expected not rows")
-	}
-}
-
-func TestBooleanRoundtrip(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	defer os.Remove(tempFilename)
-	defer db.Close()
-
-	_, err = db.Exec("DROP TABLE foo")
-	_, err = db.Exec("CREATE TABLE foo(id INTEGER, value BOOL)")
-	if err != nil {
-		t.Fatal("Failed to create table:", err)
-	}
-
-	_, err = db.Exec("INSERT INTO foo(id, value) VALUES(1, ?)", true)
-	if err != nil {
-		t.Fatal("Failed to insert true value:", err)
-	}
-
-	_, err = db.Exec("INSERT INTO foo(id, value) VALUES(2, ?)", false)
-	if err != nil {
-		t.Fatal("Failed to insert false value:", err)
-	}
-
-	rows, err := db.Query("SELECT id, value FROM foo")
-	if err != nil {
-		t.Fatal("Unable to query foo table:", err)
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var id int
-		var value bool
-
-		if err := rows.Scan(&id, &value); err != nil {
-			t.Error("Unable to scan results:", err)
-			continue
-		}
-
-		if id == 1 && !value {
-			t.Error("Value for id 1 should be true, not false")
-
-		} else if id == 2 && value {
-			t.Error("Value for id 2 should be false, not true")
-		}
-	}
-}
-
-func TestTimestamp(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	defer os.Remove(tempFilename)
-	defer db.Close()
-
-	_, err = db.Exec("DROP TABLE foo")
-	_, err = db.Exec("CREATE TABLE foo(id INTEGER, ts timeSTAMP, dt DATETIME)")
-	if err != nil {
-		t.Fatal("Failed to create table:", err)
-	}
-
-	timestamp1 := time.Date(2012, time.April, 6, 22, 50, 0, 0, time.UTC)
-	timestamp2 := time.Date(2006, time.January, 2, 15, 4, 5, 123456789, time.UTC)
-	timestamp3 := time.Date(2012, time.November, 4, 0, 0, 0, 0, time.UTC)
-	tests := []struct {
-		value    interface{}
-		expected time.Time
-	}{
-		{"nonsense", time.Time{}},
-		{"0000-00-00 00:00:00", time.Time{}},
-		{timestamp1, timestamp1},
-		{timestamp1.Unix(), timestamp1},
-		{timestamp1.UnixNano() / int64(time.Millisecond), timestamp1},
-		{timestamp1.In(time.FixedZone("TEST", -7*3600)), timestamp1},
-		{timestamp1.Format("2006-01-02 15:04:05.000"), timestamp1},
-		{timestamp1.Format("2006-01-02T15:04:05.000"), timestamp1},
-		{timestamp1.Format("2006-01-02 15:04:05"), timestamp1},
-		{timestamp1.Format("2006-01-02T15:04:05"), timestamp1},
-		{timestamp2, timestamp2},
-		{"2006-01-02 15:04:05.123456789", timestamp2},
-		{"2006-01-02T15:04:05.123456789", timestamp2},
-		{"2012-11-04", timestamp3},
-		{"2012-11-04 00:00", timestamp3},
-		{"2012-11-04 00:00:00", timestamp3},
-		{"2012-11-04 00:00:00.000", timestamp3},
-		{"2012-11-04T00:00", timestamp3},
-		{"2012-11-04T00:00:00", timestamp3},
-		{"2012-11-04T00:00:00.000", timestamp3},
-	}
-	for i := range tests {
-		_, err = db.Exec("INSERT INTO foo(id, ts, dt) VALUES(?, ?, ?)", i, tests[i].value, tests[i].value)
-		if err != nil {
-			t.Fatal("Failed to insert timestamp:", err)
-		}
-	}
-
-	rows, err := db.Query("SELECT id, ts, dt FROM foo ORDER BY id ASC")
-	if err != nil {
-		t.Fatal("Unable to query foo table:", err)
-	}
-	defer rows.Close()
-
-	seen := 0
-	for rows.Next() {
-		var id int
-		var ts, dt time.Time
-
-		if err := rows.Scan(&id, &ts, &dt); err != nil {
-			t.Error("Unable to scan results:", err)
-			continue
-		}
-		if id < 0 || id >= len(tests) {
-			t.Error("Bad row id: ", id)
-			continue
-		}
-		seen++
-		if !tests[id].expected.Equal(ts) {
-			t.Errorf("Timestamp value for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected, dt)
-		}
-		if !tests[id].expected.Equal(dt) {
-			t.Errorf("Datetime value for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected, dt)
-		}
-	}
-
-	if seen != len(tests) {
-		t.Errorf("Expected to see %d rows", len(tests))
-	}
-}
-
-func TestBoolean(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-
-	defer os.Remove(tempFilename)
-	defer db.Close()
-
-	_, err = db.Exec("CREATE TABLE foo(id INTEGER, fbool BOOLEAN)")
-	if err != nil {
-		t.Fatal("Failed to create table:", err)
-	}
-
-	bool1 := true
-	_, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(1, ?)", bool1)
-	if err != nil {
-		t.Fatal("Failed to insert boolean:", err)
-	}
-
-	bool2 := false
-	_, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(2, ?)", bool2)
-	if err != nil {
-		t.Fatal("Failed to insert boolean:", err)
-	}
-
-	bool3 := "nonsense"
-	_, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(3, ?)", bool3)
-	if err != nil {
-		t.Fatal("Failed to insert nonsense:", err)
-	}
-
-	rows, err := db.Query("SELECT id, fbool FROM foo where fbool = ?", bool1)
-	if err != nil {
-		t.Fatal("Unable to query foo table:", err)
-	}
-	counter := 0
-
-	var id int
-	var fbool bool
-
-	for rows.Next() {
-		if err := rows.Scan(&id, &fbool); err != nil {
-			t.Fatal("Unable to scan results:", err)
-		}
-		counter++
-	}
-
-	if counter != 1 {
-		t.Fatalf("Expected 1 row but %v", counter)
-	}
-
-	if id != 1 && fbool != true {
-		t.Fatalf("Value for id 1 should be %v, not %v", bool1, fbool)
-	}
-
-	rows, err = db.Query("SELECT id, fbool FROM foo where fbool = ?", bool2)
-	if err != nil {
-		t.Fatal("Unable to query foo table:", err)
-	}
-
-	counter = 0
-
-	for rows.Next() {
-		if err := rows.Scan(&id, &fbool); err != nil {
-			t.Fatal("Unable to scan results:", err)
-		}
-		counter++
-	}
-
-	if counter != 1 {
-		t.Fatalf("Expected 1 row but %v", counter)
-	}
-
-	if id != 2 && fbool != false {
-		t.Fatalf("Value for id 2 should be %v, not %v", bool2, fbool)
-	}
-
-	// make sure "nonsense" triggered an error
-	rows, err = db.Query("SELECT id, fbool FROM foo where id=?;", 3)
-	if err != nil {
-		t.Fatal("Unable to query foo table:", err)
-	}
-
-	rows.Next()
-	err = rows.Scan(&id, &fbool)
-	if err == nil {
-		t.Error("Expected error from \"nonsense\" bool")
-	}
-}
-
-func TestFloat32(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-
-	defer os.Remove(tempFilename)
-	defer db.Close()
-
-	_, err = db.Exec("CREATE TABLE foo(id INTEGER)")
-	if err != nil {
-		t.Fatal("Failed to create table:", err)
-	}
-
-	_, err = db.Exec("INSERT INTO foo(id) VALUES(null)")
-	if err != nil {
-		t.Fatal("Failed to insert null:", err)
-	}
-
-	rows, err := db.Query("SELECT id FROM foo")
-	if err != nil {
-		t.Fatal("Unable to query foo table:", err)
-	}
-
-	if !rows.Next() {
-		t.Fatal("Unable to query results:", err)
-	}
-
-	var id interface{}
-	if err := rows.Scan(&id); err != nil {
-		t.Fatal("Unable to scan results:", err)
-	}
-	if id != nil {
-		t.Error("Expected nil but not")
-	}
-}
-
-func TestNull(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-
-	defer os.Remove(tempFilename)
-	defer db.Close()
-
-	rows, err := db.Query("SELECT 3.141592")
-	if err != nil {
-		t.Fatal("Unable to query foo table:", err)
-	}
-
-	if !rows.Next() {
-		t.Fatal("Unable to query results:", err)
-	}
-
-	var v interface{}
-	if err := rows.Scan(&v); err != nil {
-		t.Fatal("Unable to scan results:", err)
-	}
-	f, ok := v.(float64)
-	if !ok {
-		t.Error("Expected float but not")
-	}
-	if f != 3.141592 {
-		t.Error("Expected 3.141592 but not")
-	}
-}
-
-func TestTransaction(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-
-	defer os.Remove(tempFilename)
-	defer db.Close()
-
-	_, err = db.Exec("CREATE TABLE foo(id INTEGER)")
-	if err != nil {
-		t.Fatal("Failed to create table:", err)
-	}
-
-	tx, err := db.Begin()
-	if err != nil {
-		t.Fatal("Failed to begin transaction:", err)
-	}
-
-	_, err = tx.Exec("INSERT INTO foo(id) VALUES(1)")
-	if err != nil {
-		t.Fatal("Failed to insert null:", err)
-	}
-
-	rows, err := tx.Query("SELECT id from foo")
-	if err != nil {
-		t.Fatal("Unable to query foo table:", err)
-	}
-
-	err = tx.Rollback()
-	if err != nil {
-		t.Fatal("Failed to rollback transaction:", err)
-	}
-
-	if rows.Next() {
-		t.Fatal("Unable to query results:", err)
-	}
-
-	tx, err = db.Begin()
-	if err != nil {
-		t.Fatal("Failed to begin transaction:", err)
-	}
-
-	_, err = tx.Exec("INSERT INTO foo(id) VALUES(1)")
-	if err != nil {
-		t.Fatal("Failed to insert null:", err)
-	}
-
-	err = tx.Commit()
-	if err != nil {
-		t.Fatal("Failed to commit transaction:", err)
-	}
-
-	rows, err = tx.Query("SELECT id from foo")
-	if err == nil {
-		t.Fatal("Expected failure to query")
-	}
-}
-
-func TestWAL(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-
-	defer os.Remove(tempFilename)
-	defer db.Close()
-	if _, err = db.Exec("PRAGMA journal_mode=WAL;"); err != nil {
-		t.Fatal("Failed to Exec PRAGMA journal_mode:", err)
-	}
-	if _, err = db.Exec("PRAGMA locking_mode=EXCLUSIVE;"); err != nil {
-		t.Fatal("Failed to Exec PRAGMA locking_mode:", err)
-	}
-	if _, err = db.Exec("CREATE TABLE test (id SERIAL, user TEXT NOT NULL, name TEXT NOT NULL);"); err != nil {
-		t.Fatal("Failed to Exec CREATE TABLE:", err)
-	}
-	if _, err = db.Exec("INSERT INTO test (user, name) VALUES ('user','name');"); err != nil {
-		t.Fatal("Failed to Exec INSERT:", err)
-	}
-
-	trans, err := db.Begin()
-	if err != nil {
-		t.Fatal("Failed to Begin:", err)
-	}
-	s, err := trans.Prepare("INSERT INTO test (user, name) VALUES (?, ?);")
-	if err != nil {
-		t.Fatal("Failed to Prepare:", err)
-	}
-
-	var count int
-	if err = trans.QueryRow("SELECT count(user) FROM test;").Scan(&count); err != nil {
-		t.Fatal("Failed to QueryRow:", err)
-	}
-	if _, err = s.Exec("bbbb", "aaaa"); err != nil {
-		t.Fatal("Failed to Exec prepared statement:", err)
-	}
-	if err = s.Close(); err != nil {
-		t.Fatal("Failed to Close prepared statement:", err)
-	}
-	if err = trans.Commit(); err != nil {
-		t.Fatal("Failed to Commit:", err)
-	}
-}
-
-func TestTimezoneConversion(t *testing.T) {
-	zones := []string{"UTC", "US/Central", "US/Pacific", "Local"}
-	for _, tz := range zones {
-		tempFilename := TempFilename()
-		db, err := sql.Open("sqlite3", tempFilename+"?loc="+url.QueryEscape(tz))
-		if err != nil {
-			t.Fatal("Failed to open database:", err)
-		}
-		defer os.Remove(tempFilename)
-		defer db.Close()
-
-		_, err = db.Exec("DROP TABLE foo")
-		_, err = db.Exec("CREATE TABLE foo(id INTEGER, ts TIMESTAMP, dt DATETIME)")
-		if err != nil {
-			t.Fatal("Failed to create table:", err)
-		}
-
-		loc, err := time.LoadLocation(tz)
-		if err != nil {
-			t.Fatal("Failed to load location:", err)
-		}
-
-		timestamp1 := time.Date(2012, time.April, 6, 22, 50, 0, 0, time.UTC)
-		timestamp2 := time.Date(2006, time.January, 2, 15, 4, 5, 123456789, time.UTC)
-		timestamp3 := time.Date(2012, time.November, 4, 0, 0, 0, 0, time.UTC)
-		tests := []struct {
-			value    interface{}
-			expected time.Time
-		}{
-			{"nonsense", time.Time{}.In(loc)},
-			{"0000-00-00 00:00:00", time.Time{}.In(loc)},
-			{timestamp1, timestamp1.In(loc)},
-			{timestamp1.Unix(), timestamp1.In(loc)},
-			{timestamp1.In(time.FixedZone("TEST", -7*3600)), timestamp1.In(loc)},
-			{timestamp1.Format("2006-01-02 15:04:05.000"), timestamp1.In(loc)},
-			{timestamp1.Format("2006-01-02T15:04:05.000"), timestamp1.In(loc)},
-			{timestamp1.Format("2006-01-02 15:04:05"), timestamp1.In(loc)},
-			{timestamp1.Format("2006-01-02T15:04:05"), timestamp1.In(loc)},
-			{timestamp2, timestamp2.In(loc)},
-			{"2006-01-02 15:04:05.123456789", timestamp2.In(loc)},
-			{"2006-01-02T15:04:05.123456789", timestamp2.In(loc)},
-			{"2012-11-04", timestamp3.In(loc)},
-			{"2012-11-04 00:00", timestamp3.In(loc)},
-			{"2012-11-04 00:00:00", timestamp3.In(loc)},
-			{"2012-11-04 00:00:00.000", timestamp3.In(loc)},
-			{"2012-11-04T00:00", timestamp3.In(loc)},
-			{"2012-11-04T00:00:00", timestamp3.In(loc)},
-			{"2012-11-04T00:00:00.000", timestamp3.In(loc)},
-		}
-		for i := range tests {
-			_, err = db.Exec("INSERT INTO foo(id, ts, dt) VALUES(?, ?, ?)", i, tests[i].value, tests[i].value)
-			if err != nil {
-				t.Fatal("Failed to insert timestamp:", err)
-			}
-		}
-
-		rows, err := db.Query("SELECT id, ts, dt FROM foo ORDER BY id ASC")
-		if err != nil {
-			t.Fatal("Unable to query foo table:", err)
-		}
-		defer rows.Close()
-
-		seen := 0
-		for rows.Next() {
-			var id int
-			var ts, dt time.Time
-
-			if err := rows.Scan(&id, &ts, &dt); err != nil {
-				t.Error("Unable to scan results:", err)
-				continue
-			}
-			if id < 0 || id >= len(tests) {
-				t.Error("Bad row id: ", id)
-				continue
-			}
-			seen++
-			if !tests[id].expected.Equal(ts) {
-				t.Errorf("Timestamp value for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected, ts)
-			}
-			if !tests[id].expected.Equal(dt) {
-				t.Errorf("Datetime value for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected, dt)
-			}
-			if tests[id].expected.Location().String() != ts.Location().String() {
-				t.Errorf("Location for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected.Location().String(), ts.Location().String())
-			}
-			if tests[id].expected.Location().String() != dt.Location().String() {
-				t.Errorf("Location for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected.Location().String(), dt.Location().String())
-			}
-		}
-
-		if seen != len(tests) {
-			t.Errorf("Expected to see %d rows", len(tests))
-		}
-	}
-}
-
-func TestSuite(t *testing.T) {
-	db, err := sql.Open("sqlite3", ":memory:")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	sqlite3_test.RunTests(t, db, sqlite3_test.SQLITE)
-}
-
-// TODO: Execer & Queryer currently disabled
-// https://github.com/mattn/go-sqlite3/issues/82
-func TestExecer(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	defer os.Remove(tempFilename)
-	defer db.Close()
-
-	_, err = db.Exec(`
-       create table foo (id integer); -- one comment
-       insert into foo(id) values(?);
-       insert into foo(id) values(?);
-       insert into foo(id) values(?); -- another comment
-       `, 1, 2, 3)
-	if err != nil {
-		t.Error("Failed to call db.Exec:", err)
-	}
-}
-
-func TestQueryer(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	defer os.Remove(tempFilename)
-	defer db.Close()
-
-	_, err = db.Exec(`
-	create table foo (id integer);
-	`)
-	if err != nil {
-		t.Error("Failed to call db.Query:", err)
-	}
-
-	rows, err := db.Query(`
-	insert into foo(id) values(?);
-	insert into foo(id) values(?);
-	insert into foo(id) values(?);
-	select id from foo order by id;
-	`, 3, 2, 1)
-	if err != nil {
-		t.Error("Failed to call db.Query:", err)
-	}
-	defer rows.Close()
-	n := 1
-	if rows != nil {
-		for rows.Next() {
-			var id int
-			err = rows.Scan(&id)
-			if err != nil {
-				t.Error("Failed to db.Query:", err)
-			}
-			if id != n {
-				t.Error("Failed to db.Query: not matched results")
-			}
-		}
-	}
-}
-
-func TestStress(t *testing.T) {
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	db.Exec("CREATE TABLE foo (id int);")
-	db.Exec("INSERT INTO foo VALUES(1);")
-	db.Exec("INSERT INTO foo VALUES(2);")
-	db.Close()
-
-	for i := 0; i < 10000; i++ {
-		db, err := sql.Open("sqlite3", tempFilename)
-		if err != nil {
-			t.Fatal("Failed to open database:", err)
-		}
-
-		for j := 0; j < 3; j++ {
-			rows, err := db.Query("select * from foo where id=1;")
-			if err != nil {
-				t.Error("Failed to call db.Query:", err)
-			}
-			for rows.Next() {
-				var i int
-				if err := rows.Scan(&i); err != nil {
-					t.Errorf("Scan failed: %v\n", err)
-				}
-			}
-			if err := rows.Err(); err != nil {
-				t.Errorf("Post-scan failed: %v\n", err)
-			}
-			rows.Close()
-		}
-		db.Close()
-	}
-}
-
-func TestDateTimeLocal(t *testing.T) {
-	zone := "Asia/Tokyo"
-	tempFilename := TempFilename()
-	db, err := sql.Open("sqlite3", tempFilename+"?loc="+zone)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	db.Exec("CREATE TABLE foo (dt datetime);")
-	db.Exec("INSERT INTO foo VALUES('2015-03-05 15:16:17');")
-
-	row := db.QueryRow("select * from foo")
-	var d time.Time
-	err = row.Scan(&d)
-	if err != nil {
-		t.Fatal("Failed to scan datetime:", err)
-	}
-	if d.Hour() == 15 || !strings.Contains(d.String(), "JST") {
-		t.Fatal("Result should have timezone", d)
-	}
-	db.Close()
-
-	db, err = sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-
-	row = db.QueryRow("select * from foo")
-	err = row.Scan(&d)
-	if err != nil {
-		t.Fatal("Failed to scan datetime:", err)
-	}
-	if d.UTC().Hour() != 15 || !strings.Contains(d.String(), "UTC") {
-		t.Fatalf("Result should not have timezone %v %v", zone, d.String())
-	}
-
-	_, err = db.Exec("DELETE FROM foo")
-	if err != nil {
-		t.Fatal("Failed to delete table:", err)
-	}
-	dt, err := time.Parse("2006/1/2 15/4/5 -0700 MST", "2015/3/5 15/16/17 +0900 JST")
-	if err != nil {
-		t.Fatal("Failed to parse datetime:", err)
-	}
-	db.Exec("INSERT INTO foo VALUES(?);", dt)
-
-	db.Close()
-	db, err = sql.Open("sqlite3", tempFilename+"?loc="+zone)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-
-	row = db.QueryRow("select * from foo")
-	err = row.Scan(&d)
-	if err != nil {
-		t.Fatal("Failed to scan datetime:", err)
-	}
-	if d.Hour() != 15 || !strings.Contains(d.String(), "JST") {
-		t.Fatalf("Result should have timezone %v %v", zone, d.String())
-	}
-}
-
-func TestVersion(t *testing.T) {
-	s, n, id := Version()
-	if s == "" || n == 0 || id == "" {
-		t.Errorf("Version failed %q, %d, %q\n", s, n, id)
-	}
-}

Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test/sqltest.go

@@ -1,412 +0,0 @@
-package sqlite3_test
-
-import (
-	"database/sql"
-	"fmt"
-	"math/rand"
-	"regexp"
-	"strconv"
-	"sync"
-	"testing"
-	"time"
-)
-
-type Dialect int
-
-const (
-	SQLITE Dialect = iota
-	POSTGRESQL
-	MYSQL
-)
-
-type DB struct {
-	*testing.T
-	*sql.DB
-	dialect Dialect
-	once    sync.Once
-}
-
-var db *DB
-
-// the following tables will be created and dropped during the test
-var testTables = []string{"foo", "bar", "t", "bench"}
-
-var tests = []testing.InternalTest{
-	{"TestBlobs", TestBlobs},
-	{"TestManyQueryRow", TestManyQueryRow},
-	{"TestTxQuery", TestTxQuery},
-	{"TestPreparedStmt", TestPreparedStmt},
-}
-
-var benchmarks = []testing.InternalBenchmark{
-	{"BenchmarkExec", BenchmarkExec},
-	{"BenchmarkQuery", BenchmarkQuery},
-	{"BenchmarkParams", BenchmarkParams},
-	{"BenchmarkStmt", BenchmarkStmt},
-	{"BenchmarkRows", BenchmarkRows},
-	{"BenchmarkStmtRows", BenchmarkStmtRows},
-}
-
-// RunTests runs the SQL test suite
-func RunTests(t *testing.T, d *sql.DB, dialect Dialect) {
-	db = &DB{t, d, dialect, sync.Once{}}
-	testing.RunTests(func(string, string) (bool, error) { return true, nil }, tests)
-
-	if !testing.Short() {
-		for _, b := range benchmarks {
-			fmt.Printf("%-20s", b.Name)
-			r := testing.Benchmark(b.F)
-			fmt.Printf("%10d %10.0f req/s\n", r.N, float64(r.N)/r.T.Seconds())
-		}
-	}
-	db.tearDown()
-}
-
-func (db *DB) mustExec(sql string, args ...interface{}) sql.Result {
-	res, err := db.Exec(sql, args...)
-	if err != nil {
-		db.Fatalf("Error running %q: %v", sql, err)
-	}
-	return res
-}
-
-func (db *DB) tearDown() {
-	for _, tbl := range testTables {
-		switch db.dialect {
-		case SQLITE:
-			db.mustExec("drop table if exists " + tbl)
-		case MYSQL, POSTGRESQL:
-			db.mustExec("drop table if exists " + tbl)
-		default:
-			db.Fatal("unkown dialect")
-		}
-	}
-}
-
-// q replaces ? parameters if needed
-func (db *DB) q(sql string) string {
-	switch db.dialect {
-	case POSTGRESQL: // repace with $1, $2, ..
-		qrx := regexp.MustCompile(`\?`)
-		n := 0
-		return qrx.ReplaceAllStringFunc(sql, func(string) string {
-			n++
-			return "$" + strconv.Itoa(n)
-		})
-	}
-	return sql
-}
-
-func (db *DB) blobType(size int) string {
-	switch db.dialect {
-	case SQLITE:
-		return fmt.Sprintf("blob[%d]", size)
-	case POSTGRESQL:
-		return "bytea"
-	case MYSQL:
-		return fmt.Sprintf("VARBINARY(%d)", size)
-	}
-	panic("unkown dialect")
-}
-
-func (db *DB) serialPK() string {
-	switch db.dialect {
-	case SQLITE:
-		return "integer primary key autoincrement"
-	case POSTGRESQL:
-		return "serial primary key"
-	case MYSQL:
-		return "integer primary key auto_increment"
-	}
-	panic("unkown dialect")
-}
-
-func (db *DB) now() string {
-	switch db.dialect {
-	case SQLITE:
-		return "datetime('now')"
-	case POSTGRESQL:
-		return "now()"
-	case MYSQL:
-		return "now()"
-	}
-	panic("unkown dialect")
-}
-
-func makeBench() {
-	if _, err := db.Exec("create table bench (n varchar(32), i integer, d double, s varchar(32), t datetime)"); err != nil {
-		panic(err)
-	}
-	st, err := db.Prepare("insert into bench values (?, ?, ?, ?, ?)")
-	if err != nil {
-		panic(err)
-	}
-	defer st.Close()
-	for i := 0; i < 100; i++ {
-		if _, err = st.Exec(nil, i, float64(i), fmt.Sprintf("%d", i), time.Now()); err != nil {
-			panic(err)
-		}
-	}
-}
-
-func TestResult(t *testing.T) {
-	db.tearDown()
-	db.mustExec("create temporary table test (id " + db.serialPK() + ", name varchar(10))")
-
-	for i := 1; i < 3; i++ {
-		r := db.mustExec(db.q("insert into test (name) values (?)"), fmt.Sprintf("row %d", i))
-		n, err := r.RowsAffected()
-		if err != nil {
-			t.Fatal(err)
-		}
-		if n != 1 {
-			t.Errorf("got %v, want %v", n, 1)
-		}
-		n, err = r.LastInsertId()
-		if err != nil {
-			t.Fatal(err)
-		}
-		if n != int64(i) {
-			t.Errorf("got %v, want %v", n, i)
-		}
-	}
-	if _, err := db.Exec("error!"); err == nil {
-		t.Fatalf("expected error")
-	}
-}
-
-func TestBlobs(t *testing.T) {
-	db.tearDown()
-	var blob = []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
-	db.mustExec("create table foo (id integer primary key, bar " + db.blobType(16) + ")")
-	db.mustExec(db.q("insert into foo (id, bar) values(?,?)"), 0, blob)
-
-	want := fmt.Sprintf("%x", blob)
-
-	b := make([]byte, 16)
-	err := db.QueryRow(db.q("select bar from foo where id = ?"), 0).Scan(&b)
-	got := fmt.Sprintf("%x", b)
-	if err != nil {
-		t.Errorf("[]byte scan: %v", err)
-	} else if got != want {
-		t.Errorf("for []byte, got %q; want %q", got, want)
-	}
-
-	err = db.QueryRow(db.q("select bar from foo where id = ?"), 0).Scan(&got)
-	want = string(blob)
-	if err != nil {
-		t.Errorf("string scan: %v", err)
-	} else if got != want {
-		t.Errorf("for string, got %q; want %q", got, want)
-	}
-}
-
-func TestManyQueryRow(t *testing.T) {
-	if testing.Short() {
-		t.Log("skipping in short mode")
-		return
-	}
-	db.tearDown()
-	db.mustExec("create table foo (id integer primary key, name varchar(50))")
-	db.mustExec(db.q("insert into foo (id, name) values(?,?)"), 1, "bob")
-	var name string
-	for i := 0; i < 10000; i++ {
-		err := db.QueryRow(db.q("select name from foo where id = ?"), 1).Scan(&name)
-		if err != nil || name != "bob" {
-			t.Fatalf("on query %d: err=%v, name=%q", i, err, name)
-		}
-	}
-}
-
-func TestTxQuery(t *testing.T) {
-	db.tearDown()
-	tx, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer tx.Rollback()
-
-	_, err = tx.Exec("create table foo (id integer primary key, name varchar(50))")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = tx.Exec(db.q("insert into foo (id, name) values(?,?)"), 1, "bob")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	r, err := tx.Query(db.q("select name from foo where id = ?"), 1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer r.Close()
-
-	if !r.Next() {
-		if r.Err() != nil {
-			t.Fatal(err)
-		}
-		t.Fatal("expected one rows")
-	}
-
-	var name string
-	err = r.Scan(&name)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestPreparedStmt(t *testing.T) {
-	db.tearDown()
-	db.mustExec("CREATE TABLE t (count INT)")
-	sel, err := db.Prepare("SELECT count FROM t ORDER BY count DESC")
-	if err != nil {
-		t.Fatalf("prepare 1: %v", err)
-	}
-	ins, err := db.Prepare(db.q("INSERT INTO t (count) VALUES (?)"))
-	if err != nil {
-		t.Fatalf("prepare 2: %v", err)
-	}
-
-	for n := 1; n <= 3; n++ {
-		if _, err := ins.Exec(n); err != nil {
-			t.Fatalf("insert(%d) = %v", n, err)
-		}
-	}
-
-	const nRuns = 10
-	ch := make(chan bool)
-	for i := 0; i < nRuns; i++ {
-		go func() {
-			defer func() {
-				ch <- true
-			}()
-			for j := 0; j < 10; j++ {
-				count := 0
-				if err := sel.QueryRow().Scan(&count); err != nil && err != sql.ErrNoRows {
-					t.Errorf("Query: %v", err)
-					return
-				}
-				if _, err := ins.Exec(rand.Intn(100)); err != nil {
-					t.Errorf("Insert: %v", err)
-					return
-				}
-			}
-		}()
-	}
-	for i := 0; i < nRuns; i++ {
-		<-ch
-	}
-}
-
-// 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
-// currently hangs go.
-
-func BenchmarkExec(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		if _, err := db.Exec("select 1"); err != nil {
-			panic(err)
-		}
-	}
-}
-
-func BenchmarkQuery(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		var n sql.NullString
-		var i int
-		var f float64
-		var s string
-//		var t time.Time
-		if err := db.QueryRow("select null, 1, 1.1, 'foo'").Scan(&n, &i, &f, &s); err != nil {
-			panic(err)
-		}
-	}
-}
-
-func BenchmarkParams(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		var n sql.NullString
-		var i int
-		var f float64
-		var s string
-//		var t time.Time
-		if err := db.QueryRow("select ?, ?, ?, ?", nil, 1, 1.1, "foo").Scan(&n, &i, &f, &s); err != nil {
-			panic(err)
-		}
-	}
-}
-
-func BenchmarkStmt(b *testing.B) {
-	st, err := db.Prepare("select ?, ?, ?, ?")
-	if err != nil {
-		panic(err)
-	}
-	defer st.Close()
-
-	for n := 0; n < b.N; n++ {
-		var n sql.NullString
-		var i int
-		var f float64
-		var s string
-//		var t time.Time
-		if err := st.QueryRow(nil, 1, 1.1, "foo").Scan(&n, &i, &f, &s); err != nil {
-			panic(err)
-		}
-	}
-}
-
-func BenchmarkRows(b *testing.B) {
-	db.once.Do(makeBench)
-
-	for n := 0; n < b.N; n++ {
-		var n sql.NullString
-		var i int
-		var f float64
-		var s string
-		var t time.Time
-		r, err := db.Query("select * from bench")
-		if err != nil {
-			panic(err)
-		}
-		for r.Next() {
-			if err = r.Scan(&n, &i, &f, &s, &t); err != nil {
-				panic(err)
-			}
-		}
-		if err = r.Err(); err != nil {
-			panic(err)
-		}
-	}
-}
-
-func BenchmarkStmtRows(b *testing.B) {
-	db.once.Do(makeBench)
-
-	st, err := db.Prepare("select * from bench")
-	if err != nil {
-		panic(err)
-	}
-	defer st.Close()
-
-	for n := 0; n < b.N; n++ {
-		var n sql.NullString
-		var i int
-		var f float64
-		var s string
-		var t time.Time
-		r, err := st.Query()
-		if err != nil {
-			panic(err)
-		}
-		for r.Next() {
-			if err = r.Scan(&n, &i, &f, &s, &t); err != nil {
-				panic(err)
-			}
-		}
-		if err = r.Err(); err != nil {
-			panic(err)
-		}
-	}
-}

Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_windows.go

@@ -1,14 +0,0 @@
-// Copyright (C) 2014 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-// +build windows
-
-package sqlite3
-
-/*
-#cgo CFLAGS: -I. -fno-stack-check -fno-stack-protector -mno-stack-arg-probe
-#cgo windows,386 CFLAGS: -D_localtime32=localtime
-#cgo LDFLAGS: -lmingwex -lmingw32
-*/
-import "C"

Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3ext.h

@@ -1,487 +0,0 @@
-/*
-** 2006 June 7
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-*************************************************************************
-** This header file defines the SQLite interface for use by
-** shared libraries that want to be imported as extensions into
-** an SQLite instance.  Shared libraries that intend to be loaded
-** as extensions by SQLite should #include this file instead of 
-** sqlite3.h.
-*/
-#ifndef _SQLITE3EXT_H_
-#define _SQLITE3EXT_H_
-#include "sqlite3-binding.h"
-
-typedef struct sqlite3_api_routines sqlite3_api_routines;
-
-/*
-** The following structure holds pointers to all of the SQLite API
-** routines.
-**
-** WARNING:  In order to maintain backwards compatibility, add new
-** interfaces to the end of this structure only.  If you insert new
-** interfaces in the middle of this structure, then older different
-** versions of SQLite will not be able to load each others' shared
-** libraries!
-*/
-struct sqlite3_api_routines {
-  void * (*aggregate_context)(sqlite3_context*,int nBytes);
-  int  (*aggregate_count)(sqlite3_context*);
-  int  (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*));
-  int  (*bind_double)(sqlite3_stmt*,int,double);
-  int  (*bind_int)(sqlite3_stmt*,int,int);
-  int  (*bind_int64)(sqlite3_stmt*,int,sqlite_int64);
-  int  (*bind_null)(sqlite3_stmt*,int);
-  int  (*bind_parameter_count)(sqlite3_stmt*);
-  int  (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
-  const char * (*bind_parameter_name)(sqlite3_stmt*,int);
-  int  (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*));
-  int  (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*));
-  int  (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*);
-  int  (*busy_handler)(sqlite3*,int(*)(void*,int),void*);
-  int  (*busy_timeout)(sqlite3*,int ms);
-  int  (*changes)(sqlite3*);
-  int  (*close)(sqlite3*);
-  int  (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,
-                           int eTextRep,const char*));
-  int  (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,
-                             int eTextRep,const void*));
-  const void * (*column_blob)(sqlite3_stmt*,int iCol);
-  int  (*column_bytes)(sqlite3_stmt*,int iCol);
-  int  (*column_bytes16)(sqlite3_stmt*,int iCol);
-  int  (*column_count)(sqlite3_stmt*pStmt);
-  const char * (*column_database_name)(sqlite3_stmt*,int);
-  const void * (*column_database_name16)(sqlite3_stmt*,int);
-  const char * (*column_decltype)(sqlite3_stmt*,int i);
-  const void * (*column_decltype16)(sqlite3_stmt*,int);
-  double  (*column_double)(sqlite3_stmt*,int iCol);
-  int  (*column_int)(sqlite3_stmt*,int iCol);
-  sqlite_int64  (*column_int64)(sqlite3_stmt*,int iCol);
-  const char * (*column_name)(sqlite3_stmt*,int);
-  const void * (*column_name16)(sqlite3_stmt*,int);
-  const char * (*column_origin_name)(sqlite3_stmt*,int);
-  const void * (*column_origin_name16)(sqlite3_stmt*,int);
-  const char * (*column_table_name)(sqlite3_stmt*,int);
-  const void * (*column_table_name16)(sqlite3_stmt*,int);
-  const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
-  const void * (*column_text16)(sqlite3_stmt*,int iCol);
-  int  (*column_type)(sqlite3_stmt*,int iCol);
-  sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
-  void * (*commit_hook)(sqlite3*,int(*)(void*),void*);
-  int  (*complete)(const char*sql);
-  int  (*complete16)(const void*sql);
-  int  (*create_collation)(sqlite3*,const char*,int,void*,
-                           int(*)(void*,int,const void*,int,const void*));
-  int  (*create_collation16)(sqlite3*,const void*,int,void*,
-                             int(*)(void*,int,const void*,int,const void*));
-  int  (*create_function)(sqlite3*,const char*,int,int,void*,
-                          void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
-                          void (*xStep)(sqlite3_context*,int,sqlite3_value**),
-                          void (*xFinal)(sqlite3_context*));
-  int  (*create_function16)(sqlite3*,const void*,int,int,void*,
-                            void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xFinal)(sqlite3_context*));
-  int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*);
-  int  (*data_count)(sqlite3_stmt*pStmt);
-  sqlite3 * (*db_handle)(sqlite3_stmt*);
-  int (*declare_vtab)(sqlite3*,const char*);
-  int  (*enable_shared_cache)(int);
-  int  (*errcode)(sqlite3*db);
-  const char * (*errmsg)(sqlite3*);
-  const void * (*errmsg16)(sqlite3*);
-  int  (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**);
-  int  (*expired)(sqlite3_stmt*);
-  int  (*finalize)(sqlite3_stmt*pStmt);
-  void  (*free)(void*);
-  void  (*free_table)(char**result);
-  int  (*get_autocommit)(sqlite3*);
-  void * (*get_auxdata)(sqlite3_context*,int);
-  int  (*get_table)(sqlite3*,const char*,char***,int*,int*,char**);
-  int  (*global_recover)(void);
-  void  (*interruptx)(sqlite3*);
-  sqlite_int64  (*last_insert_rowid)(sqlite3*);
-  const char * (*libversion)(void);
-  int  (*libversion_number)(void);
-  void *(*malloc)(int);
-  char * (*mprintf)(const char*,...);
-  int  (*open)(const char*,sqlite3**);
-  int  (*open16)(const void*,sqlite3**);
-  int  (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
-  int  (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
-  void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*);
-  void  (*progress_handler)(sqlite3*,int,int(*)(void*),void*);
-  void *(*realloc)(void*,int);
-  int  (*reset)(sqlite3_stmt*pStmt);
-  void  (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*));
-  void  (*result_double)(sqlite3_context*,double);
-  void  (*result_error)(sqlite3_context*,const char*,int);
-  void  (*result_error16)(sqlite3_context*,const void*,int);
-  void  (*result_int)(sqlite3_context*,int);
-  void  (*result_int64)(sqlite3_context*,sqlite_int64);
-  void  (*result_null)(sqlite3_context*);
-  void  (*result_text)(sqlite3_context*,const char*,int,void(*)(void*));
-  void  (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*));
-  void  (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*));
-  void  (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*));
-  void  (*result_value)(sqlite3_context*,sqlite3_value*);
-  void * (*rollback_hook)(sqlite3*,void(*)(void*),void*);
-  int  (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,
-                         const char*,const char*),void*);
-  void  (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*));
-  char * (*snprintf)(int,char*,const char*,...);
-  int  (*step)(sqlite3_stmt*);
-  int  (*table_column_metadata)(sqlite3*,const char*,const char*,const char*,
-                                char const**,char const**,int*,int*,int*);
-  void  (*thread_cleanup)(void);
-  int  (*total_changes)(sqlite3*);
-  void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*);
-  int  (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*);
-  void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,
-                                         sqlite_int64),void*);
-  void * (*user_data)(sqlite3_context*);
-  const void * (*value_blob)(sqlite3_value*);
-  int  (*value_bytes)(sqlite3_value*);
-  int  (*value_bytes16)(sqlite3_value*);
-  double  (*value_double)(sqlite3_value*);
-  int  (*value_int)(sqlite3_value*);
-  sqlite_int64  (*value_int64)(sqlite3_value*);
-  int  (*value_numeric_type)(sqlite3_value*);
-  const unsigned char * (*value_text)(sqlite3_value*);
-  const void * (*value_text16)(sqlite3_value*);
-  const void * (*value_text16be)(sqlite3_value*);
-  const void * (*value_text16le)(sqlite3_value*);
-  int  (*value_type)(sqlite3_value*);
-  char *(*vmprintf)(const char*,va_list);
-  /* Added ??? */
-  int (*overload_function)(sqlite3*, const char *zFuncName, int nArg);
-  /* Added by 3.3.13 */
-  int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
-  int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
-  int (*clear_bindings)(sqlite3_stmt*);
-  /* Added by 3.4.1 */
-  int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,
-                          void (*xDestroy)(void *));
-  /* Added by 3.5.0 */
-  int (*bind_zeroblob)(sqlite3_stmt*,int,int);
-  int (*blob_bytes)(sqlite3_blob*);
-  int (*blob_close)(sqlite3_blob*);
-  int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64,
-                   int,sqlite3_blob**);
-  int (*blob_read)(sqlite3_blob*,void*,int,int);
-  int (*blob_write)(sqlite3_blob*,const void*,int,int);
-  int (*create_collation_v2)(sqlite3*,const char*,int,void*,
-                             int(*)(void*,int,const void*,int,const void*),
-                             void(*)(void*));
-  int (*file_control)(sqlite3*,const char*,int,void*);
-  sqlite3_int64 (*memory_highwater)(int);
-  sqlite3_int64 (*memory_used)(void);
-  sqlite3_mutex *(*mutex_alloc)(int);
-  void (*mutex_enter)(sqlite3_mutex*);
-  void (*mutex_free)(sqlite3_mutex*);
-  void (*mutex_leave)(sqlite3_mutex*);
-  int (*mutex_try)(sqlite3_mutex*);
-  int (*open_v2)(const char*,sqlite3**,int,const char*);
-  int (*release_memory)(int);
-  void (*result_error_nomem)(sqlite3_context*);
-  void (*result_error_toobig)(sqlite3_context*);
-  int (*sleep)(int);
-  void (*soft_heap_limit)(int);
-  sqlite3_vfs *(*vfs_find)(const char*);
-  int (*vfs_register)(sqlite3_vfs*,int);
-  int (*vfs_unregister)(sqlite3_vfs*);
-  int (*xthreadsafe)(void);
-  void (*result_zeroblob)(sqlite3_context*,int);
-  void (*result_error_code)(sqlite3_context*,int);
-  int (*test_control)(int, ...);
-  void (*randomness)(int,void*);
-  sqlite3 *(*context_db_handle)(sqlite3_context*);
-  int (*extended_result_codes)(sqlite3*,int);
-  int (*limit)(sqlite3*,int,int);
-  sqlite3_stmt *(*next_stmt)(sqlite3*,sqlite3_stmt*);
-  const char *(*sql)(sqlite3_stmt*);
-  int (*status)(int,int*,int*,int);
-  int (*backup_finish)(sqlite3_backup*);
-  sqlite3_backup *(*backup_init)(sqlite3*,const char*,sqlite3*,const char*);
-  int (*backup_pagecount)(sqlite3_backup*);
-  int (*backup_remaining)(sqlite3_backup*);
-  int (*backup_step)(sqlite3_backup*,int);
-  const char *(*compileoption_get)(int);
-  int (*compileoption_used)(const char*);
-  int (*create_function_v2)(sqlite3*,const char*,int,int,void*,
-                            void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xFinal)(sqlite3_context*),
-                            void(*xDestroy)(void*));
-  int (*db_config)(sqlite3*,int,...);
-  sqlite3_mutex *(*db_mutex)(sqlite3*);
-  int (*db_status)(sqlite3*,int,int*,int*,int);
-  int (*extended_errcode)(sqlite3*);
-  void (*log)(int,const char*,...);
-  sqlite3_int64 (*soft_heap_limit64)(sqlite3_int64);
-  const char *(*sourceid)(void);
-  int (*stmt_status)(sqlite3_stmt*,int,int);
-  int (*strnicmp)(const char*,const char*,int);
-  int (*unlock_notify)(sqlite3*,void(*)(void**,int),void*);
-  int (*wal_autocheckpoint)(sqlite3*,int);
-  int (*wal_checkpoint)(sqlite3*,const char*);
-  void *(*wal_hook)(sqlite3*,int(*)(void*,sqlite3*,const char*,int),void*);
-  int (*blob_reopen)(sqlite3_blob*,sqlite3_int64);
-  int (*vtab_config)(sqlite3*,int op,...);
-  int (*vtab_on_conflict)(sqlite3*);
-  /* Version 3.7.16 and later */
-  int (*close_v2)(sqlite3*);
-  const char *(*db_filename)(sqlite3*,const char*);
-  int (*db_readonly)(sqlite3*,const char*);
-  int (*db_release_memory)(sqlite3*);
-  const char *(*errstr)(int);
-  int (*stmt_busy)(sqlite3_stmt*);
-  int (*stmt_readonly)(sqlite3_stmt*);
-  int (*stricmp)(const char*,const char*);
-  int (*uri_boolean)(const char*,const char*,int);
-  sqlite3_int64 (*uri_int64)(const char*,const char*,sqlite3_int64);
-  const char *(*uri_parameter)(const char*,const char*);
-  char *(*vsnprintf)(int,char*,const char*,va_list);
-  int (*wal_checkpoint_v2)(sqlite3*,const char*,int,int*,int*);
-};
-
-/*
-** The following macros redefine the API routines so that they are
-** redirected throught the global sqlite3_api structure.
-**
-** This header file is also used by the loadext.c source file
-** (part of the main SQLite library - not an extension) so that
-** it can get access to the sqlite3_api_routines structure
-** definition.  But the main library does not want to redefine
-** the API.  So the redefinition macros are only valid if the
-** SQLITE_CORE macros is undefined.
-*/
-#ifndef SQLITE_CORE
-#define sqlite3_aggregate_context      sqlite3_api->aggregate_context
-#ifndef SQLITE_OMIT_DEPRECATED
-#define sqlite3_aggregate_count        sqlite3_api->aggregate_count
-#endif
-#define sqlite3_bind_blob              sqlite3_api->bind_blob
-#define sqlite3_bind_double            sqlite3_api->bind_double
-#define sqlite3_bind_int               sqlite3_api->bind_int
-#define sqlite3_bind_int64             sqlite3_api->bind_int64
-#define sqlite3_bind_null              sqlite3_api->bind_null
-#define sqlite3_bind_parameter_count   sqlite3_api->bind_parameter_count
-#define sqlite3_bind_parameter_index   sqlite3_api->bind_parameter_index
-#define sqlite3_bind_parameter_name    sqlite3_api->bind_parameter_name
-#define sqlite3_bind_text              sqlite3_api->bind_text
-#define sqlite3_bind_text16            sqlite3_api->bind_text16
-#define sqlite3_bind_value             sqlite3_api->bind_value
-#define sqlite3_busy_handler           sqlite3_api->busy_handler
-#define sqlite3_busy_timeout           sqlite3_api->busy_timeout
-#define sqlite3_changes                sqlite3_api->changes
-#define sqlite3_close                  sqlite3_api->close
-#define sqlite3_collation_needed       sqlite3_api->collation_needed
-#define sqlite3_collation_needed16     sqlite3_api->collation_needed16
-#define sqlite3_column_blob            sqlite3_api->column_blob
-#define sqlite3_column_bytes           sqlite3_api->column_bytes
-#define sqlite3_column_bytes16         sqlite3_api->column_bytes16
-#define sqlite3_column_count           sqlite3_api->column_count
-#define sqlite3_column_database_name   sqlite3_api->column_database_name
-#define sqlite3_column_database_name16 sqlite3_api->column_database_name16
-#define sqlite3_column_decltype        sqlite3_api->column_decltype
-#define sqlite3_column_decltype16      sqlite3_api->column_decltype16
-#define sqlite3_column_double          sqlite3_api->column_double
-#define sqlite3_column_int             sqlite3_api->column_int
-#define sqlite3_column_int64           sqlite3_api->column_int64
-#define sqlite3_column_name            sqlite3_api->column_name
-#define sqlite3_column_name16          sqlite3_api->column_name16
-#define sqlite3_column_origin_name     sqlite3_api->column_origin_name
-#define sqlite3_column_origin_name16   sqlite3_api->column_origin_name16
-#define sqlite3_column_table_name      sqlite3_api->column_table_name
-#define sqlite3_column_table_name16    sqlite3_api->column_table_name16
-#define sqlite3_column_text            sqlite3_api->column_text
-#define sqlite3_column_text16          sqlite3_api->column_text16
-#define sqlite3_column_type            sqlite3_api->column_type
-#define sqlite3_column_value           sqlite3_api->column_value
-#define sqlite3_commit_hook            sqlite3_api->commit_hook
-#define sqlite3_complete               sqlite3_api->complete
-#define sqlite3_complete16             sqlite3_api->complete16
-#define sqlite3_create_collation       sqlite3_api->create_collation
-#define sqlite3_create_collation16     sqlite3_api->create_collation16
-#define sqlite3_create_function        sqlite3_api->create_function
-#define sqlite3_create_function16      sqlite3_api->create_function16
-#define sqlite3_create_module          sqlite3_api->create_module
-#define sqlite3_create_module_v2       sqlite3_api->create_module_v2
-#define sqlite3_data_count             sqlite3_api->data_count
-#define sqlite3_db_handle              sqlite3_api->db_handle
-#define sqlite3_declare_vtab           sqlite3_api->declare_vtab
-#define sqlite3_enable_shared_cache    sqlite3_api->enable_shared_cache
-#define sqlite3_errcode                sqlite3_api->errcode
-#define sqlite3_errmsg                 sqlite3_api->errmsg
-#define sqlite3_errmsg16               sqlite3_api->errmsg16
-#define sqlite3_exec                   sqlite3_api->exec
-#ifndef SQLITE_OMIT_DEPRECATED
-#define sqlite3_expired                sqlite3_api->expired
-#endif
-#define sqlite3_finalize               sqlite3_api->finalize
-#define sqlite3_free                   sqlite3_api->free
-#define sqlite3_free_table             sqlite3_api->free_table
-#define sqlite3_get_autocommit         sqlite3_api->get_autocommit
-#define sqlite3_get_auxdata            sqlite3_api->get_auxdata
-#define sqlite3_get_table              sqlite3_api->get_table
-#ifndef SQLITE_OMIT_DEPRECATED
-#define sqlite3_global_recover         sqlite3_api->global_recover
-#endif
-#define sqlite3_interrupt              sqlite3_api->interruptx
-#define sqlite3_last_insert_rowid      sqlite3_api->last_insert_rowid
-#define sqlite3_libversion             sqlite3_api->libversion
-#define sqlite3_libversion_number      sqlite3_api->libversion_number
-#define sqlite3_malloc                 sqlite3_api->malloc
-#define sqlite3_mprintf                sqlite3_api->mprintf
-#define sqlite3_open                   sqlite3_api->open
-#define sqlite3_open16                 sqlite3_api->open16
-#define sqlite3_prepare                sqlite3_api->prepare
-#define sqlite3_prepare16              sqlite3_api->prepare16
-#define sqlite3_prepare_v2             sqlite3_api->prepare_v2
-#define sqlite3_prepare16_v2           sqlite3_api->prepare16_v2
-#define sqlite3_profile                sqlite3_api->profile
-#define sqlite3_progress_handler       sqlite3_api->progress_handler
-#define sqlite3_realloc                sqlite3_api->realloc
-#define sqlite3_reset                  sqlite3_api->reset
-#define sqlite3_result_blob            sqlite3_api->result_blob
-#define sqlite3_result_double          sqlite3_api->result_double
-#define sqlite3_result_error           sqlite3_api->result_error
-#define sqlite3_result_error16         sqlite3_api->result_error16
-#define sqlite3_result_int             sqlite3_api->result_int
-#define sqlite3_result_int64           sqlite3_api->result_int64
-#define sqlite3_result_null            sqlite3_api->result_null
-#define sqlite3_result_text            sqlite3_api->result_text
-#define sqlite3_result_text16          sqlite3_api->result_text16
-#define sqlite3_result_text16be        sqlite3_api->result_text16be
-#define sqlite3_result_text16le        sqlite3_api->result_text16le
-#define sqlite3_result_value           sqlite3_api->result_value
-#define sqlite3_rollback_hook          sqlite3_api->rollback_hook
-#define sqlite3_set_authorizer         sqlite3_api->set_authorizer
-#define sqlite3_set_auxdata            sqlite3_api->set_auxdata
-#define sqlite3_snprintf               sqlite3_api->snprintf
-#define sqlite3_step                   sqlite3_api->step
-#define sqlite3_table_column_metadata  sqlite3_api->table_column_metadata
-#define sqlite3_thread_cleanup         sqlite3_api->thread_cleanup
-#define sqlite3_total_changes          sqlite3_api->total_changes
-#define sqlite3_trace                  sqlite3_api->trace
-#ifndef SQLITE_OMIT_DEPRECATED
-#define sqlite3_transfer_bindings      sqlite3_api->transfer_bindings
-#endif
-#define sqlite3_update_hook            sqlite3_api->update_hook
-#define sqlite3_user_data              sqlite3_api->user_data
-#define sqlite3_value_blob             sqlite3_api->value_blob
-#define sqlite3_value_bytes            sqlite3_api->value_bytes
-#define sqlite3_value_bytes16          sqlite3_api->value_bytes16
-#define sqlite3_value_double           sqlite3_api->value_double
-#define sqlite3_value_int              sqlite3_api->value_int
-#define sqlite3_value_int64            sqlite3_api->value_int64
-#define sqlite3_value_numeric_type     sqlite3_api->value_numeric_type
-#define sqlite3_value_text             sqlite3_api->value_text
-#define sqlite3_value_text16           sqlite3_api->value_text16
-#define sqlite3_value_text16be         sqlite3_api->value_text16be
-#define sqlite3_value_text16le         sqlite3_api->value_text16le
-#define sqlite3_value_type             sqlite3_api->value_type
-#define sqlite3_vmprintf               sqlite3_api->vmprintf
-#define sqlite3_overload_function      sqlite3_api->overload_function
-#define sqlite3_prepare_v2             sqlite3_api->prepare_v2
-#define sqlite3_prepare16_v2           sqlite3_api->prepare16_v2
-#define sqlite3_clear_bindings         sqlite3_api->clear_bindings
-#define sqlite3_bind_zeroblob          sqlite3_api->bind_zeroblob
-#define sqlite3_blob_bytes             sqlite3_api->blob_bytes
-#define sqlite3_blob_close             sqlite3_api->blob_close
-#define sqlite3_blob_open              sqlite3_api->blob_open
-#define sqlite3_blob_read              sqlite3_api->blob_read
-#define sqlite3_blob_write             sqlite3_api->blob_write
-#define sqlite3_create_collation_v2    sqlite3_api->create_collation_v2
-#define sqlite3_file_control           sqlite3_api->file_control
-#define sqlite3_memory_highwater       sqlite3_api->memory_highwater
-#define sqlite3_memory_used            sqlite3_api->memory_used
-#define sqlite3_mutex_alloc            sqlite3_api->mutex_alloc
-#define sqlite3_mutex_enter            sqlite3_api->mutex_enter
-#define sqlite3_mutex_free             sqlite3_api->mutex_free
-#define sqlite3_mutex_leave            sqlite3_api->mutex_leave
-#define sqlite3_mutex_try              sqlite3_api->mutex_try
-#define sqlite3_open_v2                sqlite3_api->open_v2
-#define sqlite3_release_memory         sqlite3_api->release_memory
-#define sqlite3_result_error_nomem     sqlite3_api->result_error_nomem
-#define sqlite3_result_error_toobig    sqlite3_api->result_error_toobig
-#define sqlite3_sleep                  sqlite3_api->sleep
-#define sqlite3_soft_heap_limit        sqlite3_api->soft_heap_limit
-#define sqlite3_vfs_find               sqlite3_api->vfs_find
-#define sqlite3_vfs_register           sqlite3_api->vfs_register
-#define sqlite3_vfs_unregister         sqlite3_api->vfs_unregister
-#define sqlite3_threadsafe             sqlite3_api->xthreadsafe
-#define sqlite3_result_zeroblob        sqlite3_api->result_zeroblob
-#define sqlite3_result_error_code      sqlite3_api->result_error_code
-#define sqlite3_test_control           sqlite3_api->test_control
-#define sqlite3_randomness             sqlite3_api->randomness
-#define sqlite3_context_db_handle      sqlite3_api->context_db_handle
-#define sqlite3_extended_result_codes  sqlite3_api->extended_result_codes
-#define sqlite3_limit                  sqlite3_api->limit
-#define sqlite3_next_stmt              sqlite3_api->next_stmt
-#define sqlite3_sql                    sqlite3_api->sql
-#define sqlite3_status                 sqlite3_api->status
-#define sqlite3_backup_finish          sqlite3_api->backup_finish
-#define sqlite3_backup_init            sqlite3_api->backup_init
-#define sqlite3_backup_pagecount       sqlite3_api->backup_pagecount
-#define sqlite3_backup_remaining       sqlite3_api->backup_remaining
-#define sqlite3_backup_step            sqlite3_api->backup_step
-#define sqlite3_compileoption_get      sqlite3_api->compileoption_get
-#define sqlite3_compileoption_used     sqlite3_api->compileoption_used
-#define sqlite3_create_function_v2     sqlite3_api->create_function_v2
-#define sqlite3_db_config              sqlite3_api->db_config
-#define sqlite3_db_mutex               sqlite3_api->db_mutex
-#define sqlite3_db_status              sqlite3_api->db_status
-#define sqlite3_extended_errcode       sqlite3_api->extended_errcode
-#define sqlite3_log                    sqlite3_api->log
-#define sqlite3_soft_heap_limit64      sqlite3_api->soft_heap_limit64
-#define sqlite3_sourceid               sqlite3_api->sourceid
-#define sqlite3_stmt_status            sqlite3_api->stmt_status
-#define sqlite3_strnicmp               sqlite3_api->strnicmp
-#define sqlite3_unlock_notify          sqlite3_api->unlock_notify
-#define sqlite3_wal_autocheckpoint     sqlite3_api->wal_autocheckpoint
-#define sqlite3_wal_checkpoint         sqlite3_api->wal_checkpoint
-#define sqlite3_wal_hook               sqlite3_api->wal_hook
-#define sqlite3_blob_reopen            sqlite3_api->blob_reopen
-#define sqlite3_vtab_config            sqlite3_api->vtab_config
-#define sqlite3_vtab_on_conflict       sqlite3_api->vtab_on_conflict
-/* Version 3.7.16 and later */
-#define sqlite3_close_v2               sqlite3_api->close_v2
-#define sqlite3_db_filename            sqlite3_api->db_filename
-#define sqlite3_db_readonly            sqlite3_api->db_readonly
-#define sqlite3_db_release_memory      sqlite3_api->db_release_memory
-#define sqlite3_errstr                 sqlite3_api->errstr
-#define sqlite3_stmt_busy              sqlite3_api->stmt_busy
-#define sqlite3_stmt_readonly          sqlite3_api->stmt_readonly
-#define sqlite3_stricmp                sqlite3_api->stricmp
-#define sqlite3_uri_boolean            sqlite3_api->uri_boolean
-#define sqlite3_uri_int64              sqlite3_api->uri_int64
-#define sqlite3_uri_parameter          sqlite3_api->uri_parameter
-#define sqlite3_uri_vsnprintf          sqlite3_api->vsnprintf
-#define sqlite3_wal_checkpoint_v2      sqlite3_api->wal_checkpoint_v2
-#endif /* SQLITE_CORE */
-
-#ifndef SQLITE_CORE
-  /* This case when the file really is being compiled as a loadable 
-  ** extension */
-# define SQLITE_EXTENSION_INIT1     const sqlite3_api_routines *sqlite3_api=0;
-# define SQLITE_EXTENSION_INIT2(v)  sqlite3_api=v;
-# define SQLITE_EXTENSION_INIT3     \
-    extern const sqlite3_api_routines *sqlite3_api;
-#else
-  /* This case when the file is being statically linked into the 
-  ** application */
-# define SQLITE_EXTENSION_INIT1     /*no-op*/
-# define SQLITE_EXTENSION_INIT2(v)  (void)v; /* unused parameter */
-# define SQLITE_EXTENSION_INIT3     /*no-op*/
-#endif
-
-#endif /* _SQLITE3EXT_H_ */

Godeps/_workspace/src/gopkg.in/gorp.v1/gorp_test.go

@@ -7,8 +7,8 @@ import (
 	"errors"
 	"fmt"
 	_ "github.com/letsencrypt/boulder/Godeps/_workspace/src/github.com/go-sql-driver/mysql"
-	_ "github.com/letsencrypt/boulder/Godeps/_workspace/src/github.com/mattn/go-sqlite3"
 	_ "github.com/lib/pq"
+	_ "github.com/mattn/go-sqlite3"
 	_ "github.com/ziutek/mymysql/godrv"
 	"log"
 	"math/rand"

cmd/cert-checker/main.go

@@ -0,0 +1,261 @@
+// Copyright 2015 ISRG.  All rights reserved
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"crypto/x509"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path"
+	"runtime"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/letsencrypt/boulder/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd"
+	"github.com/letsencrypt/boulder/Godeps/_workspace/src/github.com/codegangsta/cli"
+	"github.com/letsencrypt/boulder/Godeps/_workspace/src/github.com/jmhodges/clock"
+	gorp "github.com/letsencrypt/boulder/Godeps/_workspace/src/gopkg.in/gorp.v1"
+
+	"github.com/letsencrypt/boulder/cmd"
+	"github.com/letsencrypt/boulder/core"
+	blog "github.com/letsencrypt/boulder/log"
+	"github.com/letsencrypt/boulder/policy"
+	"github.com/letsencrypt/boulder/sa"
+)
+
+const (
+	good = "valid"
+	bad  = "invalid"
+
+	filenameLayout = "20060102"
+
+	checkPeriod = time.Hour * 24 * 90
+
+	batchSize = 1000
+)
+
+type report struct {
+	begin     time.Time
+	end       time.Time
+	GoodCerts int64
+	BadCerts  int64
+	Entries   map[string]reportEntry
+}
+
+func (r *report) save(directory string) error {
+	filename := path.Join(directory, fmt.Sprintf(
+		"%s-%s-report.json",
+		r.begin.Format(filenameLayout),
+		r.end.Format(filenameLayout),
+	))
+	content, err := json.Marshal(r)
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(filename, content, os.ModePerm)
+}
+
+type reportEntry struct {
+	Valid    bool     `json:"validity"`
+	Problems []string `json:"problem,omitempty"`
+}
+
+type certChecker struct {
+	pa           core.PolicyAuthority
+	dbMap        *gorp.DbMap
+	certs        chan core.Certificate
+	issuedReport report
+	clock        clock.Clock
+}
+
+func newChecker(dbMap *gorp.DbMap) certChecker {
+	c := certChecker{
+		pa:    policy.NewPolicyAuthorityImpl(),
+		dbMap: dbMap,
+		certs: make(chan core.Certificate, batchSize),
+		clock: clock.Default(),
+	}
+	c.issuedReport.Entries = make(map[string]reportEntry)
+	return c
+}
+
+func (c *certChecker) getCerts() error {
+	c.issuedReport.begin = c.clock.Now()
+	c.issuedReport.end = c.issuedReport.begin.Add(-checkPeriod)
+
+	var count int
+	err := c.dbMap.SelectOne(
+		&count,
+		"SELECT count(*) FROM certificates WHERE issued >= :issued",
+		map[string]interface{}{"issued": c.issuedReport.end},
+	)
+	if err != nil {
+		return err
+	}
+
+	// Retrieve certs in batches of 1000 (the size of the certificate channel)
+	// so that we don't eat unnecessary amounts of memory and avoid the 16MB MySQL
+	// packet limit.
+	// TODO(#701): This query needs to make better use of indexes
+	for offset := 0; offset < count; {
+		var certs []core.Certificate
+		_, err = c.dbMap.Select(
+			&certs,
+			"SELECT * FROM certificates WHERE issued >= :issued ORDER BY issued ASC LIMIT :limit OFFSET :offset",
+			map[string]interface{}{"issued": c.issuedReport.end, "limit": batchSize, "offset": offset},
+		)
+		if err != nil {
+			return err
+		}
+		for _, cert := range certs {
+			c.certs <- cert
+		}
+		offset += len(certs)
+	}
+
+	// Close channel so range operations won't block once the channel empties out
+	close(c.certs)
+	return nil
+}
+
+func (c *certChecker) processCerts(wg *sync.WaitGroup) {
+	for cert := range c.certs {
+		problems := c.checkCert(cert)
+		valid := len(problems) == 0
+		c.issuedReport.Entries[cert.Serial] = reportEntry{
+			Valid:    valid,
+			Problems: problems,
+		}
+		if !valid {
+			atomic.AddInt64(&c.issuedReport.BadCerts, 1)
+		} else {
+			atomic.AddInt64(&c.issuedReport.GoodCerts, 1)
+		}
+	}
+	wg.Done()
+}
+
+func (c *certChecker) checkCert(cert core.Certificate) (problems []string) {
+	// Check digests match
+	if cert.Digest != core.Fingerprint256(cert.DER) {
+		problems = append(problems, "Stored digest doesn't match certificate digest")
+	}
+
+	// Parse certificate
+	parsedCert, err := x509.ParseCertificate(cert.DER)
+	if err != nil {
+		problems = append(problems, fmt.Sprintf("Couldn't parse stored certificate: %s", err))
+	} else {
+		// Check stored serial is correct
+		if core.SerialToString(parsedCert.SerialNumber) != cert.Serial {
+			problems = append(problems, "Stored serial doesn't match certificate serial")
+		}
+		// Check we have the right expiration time
+		if !parsedCert.NotAfter.Equal(cert.Expires) {
+			problems = append(problems, "Stored expiration doesn't match certificate NotAfter")
+		}
+		// Check basic constraints are set
+		if !parsedCert.BasicConstraintsValid {
+			problems = append(problems, "Certificate doesn't have basic constraints set")
+		}
+		// Check the cert isn't able to sign other certificates
+		if parsedCert.IsCA {
+			problems = append(problems, "Certificate can sign other certificates")
+		}
+		// Check the cert has the correct validity period +/- an hour
+		if parsedCert.NotAfter.Sub(cert.Issued) > checkPeriod+time.Hour {
+			problems = append(problems, "Certificate has a validity period longer than 90 days")
+		} else if parsedCert.NotAfter.Sub(cert.Issued) < checkPeriod-time.Hour {
+			problems = append(problems, "Certificate has a validity period shorter than 90 days")
+		}
+		// Check that the PA is still willing to issue for each name in DNSNames + CommonName
+		for _, name := range append(parsedCert.DNSNames, parsedCert.Subject.CommonName) {
+			if err = c.pa.WillingToIssue(core.AcmeIdentifier{Type: core.IdentifierDNS, Value: name}); err != nil {
+				problems = append(problems, fmt.Sprintf("Policy Authority isn't willing to issue for %s: %s", name, err))
+			}
+		}
+		// Check the cert has the correct key usage extensions
+		if !core.CmpExtKeyUsageSlice(parsedCert.ExtKeyUsage, []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth}) {
+			problems = append(problems, "Certificate has incorrect key usage extensions")
+		}
+	}
+	return problems
+}
+
+func main() {
+	app := cmd.NewAppShell("cert-checker", "Checks validity of certificates issued in the last 90 days")
+	app.App.Flags = append(app.App.Flags, cli.IntFlag{
+		Name:  "workers",
+		Value: runtime.NumCPU(),
+		Usage: "The number of concurrent workers used to process certificates",
+	}, cli.StringFlag{
+		Name:  "report-dir-path",
+		Usage: "The path to write a JSON report on the certificates checks to (if no path is provided the report will not be written out)",
+	}, cli.StringFlag{
+		Name:  "db-connect",
+		Usage: "SQL URI if not provided in the configuration file",
+	})
+
+	app.Config = func(c *cli.Context, config cmd.Config) cmd.Config {
+		config.CertChecker.ReportDirectoryPath = c.GlobalString("report-dir-path")
+
+		if connect := c.GlobalString("db-connect"); connect != "" {
+			config.CertChecker.DBConnect = connect
+		}
+
+		if workers := c.GlobalInt("workers"); workers != 0 {
+			config.CertChecker.Workers = workers
+		}
+
+		return config
+	}
+
+	app.Action = func(c cmd.Config) {
+		stats, err := statsd.NewClient(c.Statsd.Server, c.Statsd.Prefix)
+		cmd.FailOnError(err, "Couldn't connect to statsd")
+
+		auditlogger, err := blog.Dial(c.Syslog.Network, c.Syslog.Server, c.Syslog.Tag, stats)
+		cmd.FailOnError(err, "Could not connect to Syslog")
+
+		blog.SetAuditLogger(auditlogger)
+		auditlogger.Info(app.VersionString())
+
+		dbMap, err := sa.NewDbMap(c.CertChecker.DBConnect)
+		cmd.FailOnError(err, "Could not connect to database")
+
+		checker := newChecker(dbMap)
+		auditlogger.Info("# Getting certificates issued in the last 90 days")
+
+		// Since we grab certificates in batches we don't want this to block, when it
+		// is finished it will close the certificate channel which allows the range
+		// loops in checker.processCerts to break
+		go func() {
+			err = checker.getCerts()
+			cmd.FailOnError(err, "Batch retrieval of certificates failed")
+		}()
+
+		auditlogger.Info(fmt.Sprintf("# Processing certificates using %d workers", c.CertChecker.Workers))
+		wg := new(sync.WaitGroup)
+		for i := 0; i < c.CertChecker.Workers; i++ {
+			wg.Add(1)
+			go checker.processCerts(wg)
+		}
+		wg.Wait()
+		auditlogger.Info(fmt.Sprintf(
+			"# Finished processing certificates, sample: %d, good: %d, bad: %d",
+			len(checker.issuedReport.Entries),
+			checker.issuedReport.GoodCerts,
+			checker.issuedReport.BadCerts,
+		))
+		err = checker.issuedReport.save(c.CertChecker.ReportDirectoryPath)
+		cmd.FailOnError(err, "Couldn't save issued certificate report")
+	}
+
+	app.Run()
+}

cmd/cert-checker/main_test.go

@@ -0,0 +1,161 @@
+// Copyright 2015 ISRG.  All rights reserved
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"fmt"
+	"math/big"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/letsencrypt/boulder/Godeps/_workspace/src/github.com/jmhodges/clock"
+
+	"github.com/letsencrypt/boulder/core"
+	"github.com/letsencrypt/boulder/sa"
+	"github.com/letsencrypt/boulder/sa/satest"
+	"github.com/letsencrypt/boulder/test"
+)
+
+var dbConnStr = "mysql+tcp://boulder@localhost:3306/boulder_sa_test"
+
+func BenchmarkCheckCert(b *testing.B) {
+	dbMap, err := sa.NewDbMap(dbConnStr)
+	if err != nil {
+		fmt.Println("Couldn't connect to database")
+		return
+	}
+
+	checker := newChecker(dbMap)
+	testKey, _ := rsa.GenerateKey(rand.Reader, 1024)
+	expiry := time.Now().AddDate(0, 0, 1)
+	serial := big.NewInt(1337)
+	rawCert := x509.Certificate{
+		Subject: pkix.Name{
+			CommonName: "example.com",
+		},
+		NotAfter:     expiry,
+		DNSNames:     []string{"example-a.com"},
+		SerialNumber: serial,
+	}
+	certDer, _ := x509.CreateCertificate(rand.Reader, &rawCert, &rawCert, &testKey.PublicKey, testKey)
+	cert := core.Certificate{
+		Status:  core.StatusValid,
+		Serial:  core.SerialToString(serial),
+		Digest:  core.Fingerprint256(certDer),
+		DER:     certDer,
+		Issued:  time.Now(),
+		Expires: expiry,
+	}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		checker.checkCert(cert)
+	}
+}
+
+func TestCheckCert(t *testing.T) {
+	testKey, _ := rsa.GenerateKey(rand.Reader, 1024)
+	checker := newChecker(nil)
+	fc := clock.NewFake()
+	fc.Add(time.Hour * 24 * 90)
+	checker.clock = fc
+
+	issued := checker.clock.Now().Add(-time.Hour * 24 * 45)
+	goodExpiry := issued.Add(checkPeriod)
+	serial := big.NewInt(1337)
+	// Problems
+	//   Blacklsited common name
+	//   Expiry period is too long
+	//   Basic Constraints aren't set
+	//   Wrong key usage (none)
+	rawCert := x509.Certificate{
+		Subject: pkix.Name{
+			CommonName: "example.com",
+		},
+		NotAfter:              goodExpiry.AddDate(0, 0, 1), // Period too long
+		DNSNames:              []string{"example-a.com"},
+		SerialNumber:          serial,
+		BasicConstraintsValid: false,
+	}
+	brokenCertDer, err := x509.CreateCertificate(rand.Reader, &rawCert, &rawCert, &testKey.PublicKey, testKey)
+	test.AssertNotError(t, err, "Couldn't create certificate")
+	// Problems
+	//   Digest doesn't match
+	//   Serial doesn't match
+	//   Expiry doesn't match
+	cert := core.Certificate{
+		Status:  core.StatusValid,
+		DER:     brokenCertDer,
+		Issued:  issued,
+		Expires: goodExpiry.AddDate(0, 0, 2), // Expiration doesn't match
+	}
+
+	problems := checker.checkCert(cert)
+	test.AssertEquals(t, len(problems), 7)
+
+	// Fix the problems
+	rawCert.Subject.CommonName = "example-a.com"
+	rawCert.NotAfter = goodExpiry
+	rawCert.BasicConstraintsValid = true
+	rawCert.ExtKeyUsage = []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth}
+	goodCertDer, err := x509.CreateCertificate(rand.Reader, &rawCert, &rawCert, &testKey.PublicKey, testKey)
+	test.AssertNotError(t, err, "Couldn't create certificate")
+	parsed, err := x509.ParseCertificate(goodCertDer)
+	test.AssertNotError(t, err, "Couldn't parse created certificate")
+	cert.Serial = core.SerialToString(serial)
+	cert.Digest = core.Fingerprint256(goodCertDer)
+	cert.DER = goodCertDer
+	cert.Expires = parsed.NotAfter
+	problems = checker.checkCert(cert)
+	test.AssertEquals(t, len(problems), 0)
+}
+
+func TestGetAndProcessCerts(t *testing.T) {
+	dbMap, err := sa.NewDbMap(dbConnStr)
+	test.AssertNotError(t, err, "Couldn't connect to database")
+	checker := newChecker(dbMap)
+	sa, err := sa.NewSQLStorageAuthority(dbMap)
+	test.AssertNotError(t, err, "Couldn't create SA to insert certificates")
+	defer func() {
+		dbMap.TruncateTables()
+		test.AssertNotError(t, err, "Failed to truncate tables")
+	}()
+
+	testKey, _ := rsa.GenerateKey(rand.Reader, 1024)
+	// Problems
+	//   Expiry period is too long
+	rawCert := x509.Certificate{
+		Subject: pkix.Name{
+			CommonName: "not-blacklisted.com",
+		},
+		BasicConstraintsValid: true,
+		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth},
+	}
+	reg, err := sa.NewRegistration(core.Registration{
+		Key: satest.GoodJWK(),
+	})
+	test.AssertNotError(t, err, "Couldn't create registration")
+	for i := int64(0); i < 5; i++ {
+		rawCert.SerialNumber = big.NewInt(i)
+		certDER, err := x509.CreateCertificate(rand.Reader, &rawCert, &rawCert, &testKey.PublicKey, testKey)
+		test.AssertNotError(t, err, "Couldn't create certificate")
+		_, err = sa.AddCertificate(certDER, reg.ID)
+		test.AssertNotError(t, err, "Couldn't add certificate")
+	}
+
+	err = checker.getCerts()
+	test.AssertNotError(t, err, "Failed to retrieve certificates")
+	test.AssertEquals(t, len(checker.certs), 5)
+	wg := new(sync.WaitGroup)
+	wg.Add(1)
+	checker.processCerts(wg)
+	test.AssertEquals(t, checker.issuedReport.BadCerts, int64(5))
+	test.AssertEquals(t, len(checker.issuedReport.Entries), 5)
+}

cmd/shell.go

@@ -184,6 +184,12 @@ type Config struct {
 		DNSTimeout  string
 	}
 
+	CertChecker struct {
+		Workers             int
+		ReportDirectoryPath string
+		DBConnect           string
+	}
+
 	SubscriberAgreementURL string
 }
 

core/objects.go

@@ -115,7 +115,7 @@ func cmpStrSlice(a, b []string) bool {
 	return true
 }
 
-func cmpExtKeyUsageSlice(a, b []x509.ExtKeyUsage) bool {
+func CmpExtKeyUsageSlice(a, b []x509.ExtKeyUsage) bool {
 	if len(a) != len(b) {
 		return false
 	}
@@ -563,7 +563,7 @@ func (cert Certificate) MatchesCSR(csr *x509.CertificateRequest, earliestExpiry
 		err = InternalServerError("Generated certificate can sign other certificates")
 		return
 	}
-	if !cmpExtKeyUsageSlice(parsedCertificate.ExtKeyUsage, []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth}) {
+	if !CmpExtKeyUsageSlice(parsedCertificate.ExtKeyUsage, []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth}) {
 		err = InternalServerError("Generated certificate doesn't have correct key usage extensions")
 		return
 	}

test/boulder-config.json

@@ -171,5 +171,9 @@
     "dnsTimeout": "10s"
   },
 
+  "certChecker": {
+    "dbConnect": "mysql+tcp://boulder@localhost:3306/boulder_test"
+  },
+
   "subscriberAgreementURL": "http://localhost:4001/terms/v1"
 }