From 6796d46c3a2736edc88418f6de515c76e29f4aa9 Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Thu, 3 Nov 2016 23:05:34 +0900 Subject: [PATCH 1/8] implement go18 Pinger --- sqlite3_context.go | 14 ++++++++++++++ sqlite3_test.go | 16 ++++++++++++++++ 2 files changed, 30 insertions(+) create mode 100644 sqlite3_context.go diff --git a/sqlite3_context.go b/sqlite3_context.go new file mode 100644 index 0000000..26e4998 --- /dev/null +++ b/sqlite3_context.go @@ -0,0 +1,14 @@ +package sqlite3 + +import ( + "context" + "errors" +) + +// Ping implement Pinger. +func (c *SQLiteConn) Ping(ctx context.Context) error { + if c.db == nil { + return errors.New("Connection was closed") + } + return nil +} diff --git a/sqlite3_test.go b/sqlite3_test.go index cf826dd..fc5c99c 100644 --- a/sqlite3_test.go +++ b/sqlite3_test.go @@ -1315,6 +1315,22 @@ func TestDeclTypes(t *testing.T) { } } +func TestPinger(t *testing.T) { + db, err := sql.Open("sqlite3", ":memory:") + if err != nil { + t.Fatal(err) + } + err = db.Ping() + if err != nil { + t.Fatal(err) + } + db.Close() + err = db.Ping() + if err == nil { + t.Fatal("Should be closed") + } +} + var customFunctionOnce sync.Once func BenchmarkCustomFunctions(b *testing.B) { From d0e4959926020dc1ef3b001d8677ac94a6ada192 Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Fri, 4 Nov 2016 00:03:16 +0900 Subject: [PATCH 2/8] add go18 new feature --- sqlite3_type.go | 54 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 sqlite3_type.go diff --git a/sqlite3_type.go b/sqlite3_type.go new file mode 100644 index 0000000..748bc42 --- /dev/null +++ b/sqlite3_type.go @@ -0,0 +1,54 @@ +package sqlite3 + +/* +#ifndef USE_LIBSQLITE3 +#include +#else +#include +#endif +*/ +import "C" +import ( + "reflect" + "time" +) + +func (rc *SQLiteRows) ColumnTypeDatabaseTypeName(i int) string { + return C.GoString(C.sqlite3_column_decltype(rc.s.s, C.int(i))) +} + +/* +func (rc *SQLiteRows) ColumnTypeLength(index int) (length int64, ok bool) { + return 0, false +} + +func (rc *SQLiteRows) ColumnTypePrecisionScale(index int) (precision, scale int64, ok bool) { + return 0, 0, false +} +*/ + +func (rc *SQLiteRows) ColumnTypeNullable(i int) (nullable, ok bool) { + return true, true +} + +func (rc *SQLiteRows) ColumnTypeScanType(i int) reflect.Type { + switch C.sqlite3_column_type(rc.s.s, C.int(i)) { + case C.SQLITE_INTEGER: + switch C.GoString(C.sqlite3_column_decltype(rc.s.s, C.int(i))) { + case "timestamp", "datetime", "date": + return reflect.TypeOf(time.Time{}) + case "boolean": + return reflect.TypeOf(false) + } + return reflect.TypeOf(int64(0)) + case C.SQLITE_FLOAT: + return reflect.TypeOf(float64(0)) + case C.SQLITE_BLOB: + return reflect.SliceOf(reflect.TypeOf(byte(0))) + case C.SQLITE_NULL: + return reflect.TypeOf(nil) + case C.SQLITE_TEXT: + return reflect.TypeOf("") + } + return reflect.SliceOf(reflect.TypeOf(byte(0))) +} From c95a77965c55783416165ca638dec12c0f0a9fdb Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Fri, 4 Nov 2016 14:24:22 +0900 Subject: [PATCH 3/8] context features --- sqlite3.go | 74 +++++++++++++++++++++++++++++++++++++++------- sqlite3_context.go | 14 --------- sqlite3_go18.go | 32 ++++++++++++++++++++ 3 files changed, 95 insertions(+), 25 deletions(-) delete mode 100644 sqlite3_context.go create mode 100644 sqlite3_go18.go diff --git a/sqlite3.go b/sqlite3.go index de9d7d2..5087fad 100644 --- a/sqlite3.go +++ b/sqlite3.go @@ -114,6 +114,8 @@ import ( "strings" "time" "unsafe" + + "golang.org/x/net/context" ) // Timestamp formats understood by both this module and SQLite. @@ -295,19 +297,19 @@ func (ai *aggInfo) Done(ctx *C.sqlite3_context) { // Commit transaction. func (tx *SQLiteTx) Commit() error { - _, err := tx.c.exec("COMMIT") + _, err := tx.c.execQuery("COMMIT") if err != nil && err.(Error).Code == C.SQLITE_BUSY { // sqlite3 will leave the transaction open in this scenario. // However, database/sql considers the transaction complete once we // return from Commit() - we must clean up to honour its semantics. - tx.c.exec("ROLLBACK") + tx.c.execQuery("ROLLBACK") } return err } // Rollback transaction. func (tx *SQLiteTx) Rollback() error { - _, err := tx.c.exec("ROLLBACK") + _, err := tx.c.execQuery("ROLLBACK") return err } @@ -404,9 +406,20 @@ func (c *SQLiteConn) lastError() Error { // Implements Execer func (c *SQLiteConn) Exec(query string, args []driver.Value) (driver.Result, error) { if len(args) == 0 { - return c.exec(query) + return c.execQuery(query) } + list := make([]namedValue, len(args)) + for i, v := range args { + list[i] = namedValue{ + Ordinal: i + 1, + Value: v, + } + } + return c.exec(context.Background(), query, list) +} + +func (c *SQLiteConn) exec(ctx context.Context, query string, args []namedValue) (driver.Result, error) { for { s, err := c.Prepare(query) if err != nil { @@ -418,7 +431,7 @@ func (c *SQLiteConn) Exec(query string, args []driver.Value) (driver.Result, err 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]) + res, err = s.(*SQLiteStmt).exec(ctx, args[:na]) if err != nil && err != driver.ErrSkip { s.Close() return nil, err @@ -434,8 +447,25 @@ func (c *SQLiteConn) Exec(query string, args []driver.Value) (driver.Result, err } } +type namedValue struct { + Name string + Ordinal int + Value driver.Value +} + // Implements Queryer func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, error) { + list := make([]namedValue, len(args)) + for i, v := range args { + list[i] = namedValue{ + Ordinal: i + 1, + Value: v, + } + } + return c.query(context.Background(), query, list) +} + +func (c *SQLiteConn) query(ctx context.Context, query string, args []namedValue) (driver.Rows, error) { for { s, err := c.Prepare(query) if err != nil { @@ -446,7 +476,7 @@ func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, erro 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]) + rows, err := s.(*SQLiteStmt).query(ctx, args[:na]) if err != nil && err != driver.ErrSkip { s.Close() return nil, err @@ -462,7 +492,7 @@ func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, erro } } -func (c *SQLiteConn) exec(cmd string) (driver.Result, error) { +func (c *SQLiteConn) execQuery(cmd string) (driver.Result, error) { pcmd := C.CString(cmd) defer C.free(unsafe.Pointer(pcmd)) @@ -476,7 +506,7 @@ func (c *SQLiteConn) exec(cmd string) (driver.Result, error) { // Begin transaction. func (c *SQLiteConn) Begin() (driver.Tx, error) { - if _, err := c.exec(c.txlock); err != nil { + if _, err := c.execQuery(c.txlock); err != nil { return nil, err } return &SQLiteTx{c}, nil @@ -658,7 +688,7 @@ type bindArg struct { v driver.Value } -func (s *SQLiteStmt) bind(args []driver.Value) error { +func (s *SQLiteStmt) bind(args []namedValue) error { rv := C.sqlite3_reset(s.s) if rv != C.SQLITE_ROW && rv != C.SQLITE_OK && rv != C.SQLITE_DONE { return s.c.lastError() @@ -670,12 +700,12 @@ func (s *SQLiteStmt) bind(args []driver.Value) error { if len(s.nn) > 0 { for i, v := range s.nn { if pi, err := strconv.Atoi(v[1:]); err == nil { - vargs[i] = bindArg{pi, args[i]} + vargs[i] = bindArg{pi, args[i].Value} } } } else { for i, v := range args { - vargs[i] = bindArg{i + 1, v} + vargs[i] = bindArg{i + 1, v.Value} } } @@ -722,6 +752,17 @@ func (s *SQLiteStmt) bind(args []driver.Value) error { // Query the statement with arguments. Return records. func (s *SQLiteStmt) Query(args []driver.Value) (driver.Rows, error) { + list := make([]namedValue, len(args)) + for i, v := range args { + list[i] = namedValue{ + Ordinal: i + 1, + Value: v, + } + } + return s.query(context.Background(), list) +} + +func (s *SQLiteStmt) query(ctx context.Context, args []namedValue) (driver.Rows, error) { if err := s.bind(args); err != nil { return nil, err } @@ -740,6 +781,17 @@ func (r *SQLiteResult) RowsAffected() (int64, error) { // Execute the statement with arguments. Return result object. func (s *SQLiteStmt) Exec(args []driver.Value) (driver.Result, error) { + list := make([]namedValue, len(args)) + for i, v := range args { + list[i] = namedValue{ + Ordinal: i + 1, + Value: v, + } + } + return s.exec(context.Background(), list) +} + +func (s *SQLiteStmt) exec(ctx context.Context, args []namedValue) (driver.Result, error) { if err := s.bind(args); err != nil { C.sqlite3_reset(s.s) C.sqlite3_clear_bindings(s.s) diff --git a/sqlite3_context.go b/sqlite3_context.go deleted file mode 100644 index 26e4998..0000000 --- a/sqlite3_context.go +++ /dev/null @@ -1,14 +0,0 @@ -package sqlite3 - -import ( - "context" - "errors" -) - -// Ping implement Pinger. -func (c *SQLiteConn) Ping(ctx context.Context) error { - if c.db == nil { - return errors.New("Connection was closed") - } - return nil -} diff --git a/sqlite3_go18.go b/sqlite3_go18.go new file mode 100644 index 0000000..1ee4c6a --- /dev/null +++ b/sqlite3_go18.go @@ -0,0 +1,32 @@ +package sqlite3 + +import ( + "database/sql/driver" + "errors" + + "golang.org/x/net/context" +) + +// Ping implement Pinger. +func (c *SQLiteConn) Ping(ctx context.Context) error { + if c.db == nil { + return errors.New("Connection was closed") + } + return nil +} + +func (c *SQLiteConn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) { + list := make([]namedValue, len(args)) + for i, nv := range args { + list[i] = namedValue(nv) + } + return c.query(ctx, query, list) +} + +func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) { + list := make([]namedValue, len(args)) + for i, nv := range args { + list[i] = namedValue(nv) + } + return s.query(ctx, list) +} From b23526fb3ce3365cb83fcb1f46ac278d70d8f934 Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Fri, 4 Nov 2016 15:00:29 +0900 Subject: [PATCH 4/8] support named params --- sqlite3.go | 48 ++++++++++++++++++++---------------------------- sqlite3_go18.go | 16 ++++++++++++++++ sqlite3_test.go | 6 +++--- 3 files changed, 39 insertions(+), 31 deletions(-) diff --git a/sqlite3.go b/sqlite3.go index 5087fad..3b80eeb 100644 --- a/sqlite3.go +++ b/sqlite3.go @@ -172,8 +172,6 @@ type SQLiteTx struct { type SQLiteStmt struct { c *SQLiteConn s *C.sqlite3_stmt - nv int - nn []string t string closed bool cls bool @@ -420,6 +418,7 @@ func (c *SQLiteConn) Exec(query string, args []driver.Value) (driver.Result, err } func (c *SQLiteConn) exec(ctx context.Context, query string, args []namedValue) (driver.Result, error) { + start := 0 for { s, err := c.Prepare(query) if err != nil { @@ -431,12 +430,16 @@ func (c *SQLiteConn) exec(ctx context.Context, query string, args []namedValue) if len(args) < na { return nil, fmt.Errorf("Not enough args to execute query. Expected %d, got %d.", na, len(args)) } + for i := 0; i < na; i++ { + args[i].Ordinal -= start + } res, err = s.(*SQLiteStmt).exec(ctx, args[:na]) if err != nil && err != driver.ErrSkip { s.Close() return nil, err } args = args[na:] + start += na } tail := s.(*SQLiteStmt).t s.Close() @@ -466,6 +469,7 @@ func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, erro } func (c *SQLiteConn) query(ctx context.Context, query string, args []namedValue) (driver.Rows, error) { + start := 0 for { s, err := c.Prepare(query) if err != nil { @@ -476,12 +480,16 @@ func (c *SQLiteConn) query(ctx context.Context, query string, args []namedValue) if len(args) < na { return nil, fmt.Errorf("Not enough args to execute query. Expected %d, got %d.", na, len(args)) } + for i := 0; i < na; i++ { + args[i].Ordinal -= start + } rows, err := s.(*SQLiteStmt).query(ctx, args[:na]) if err != nil && err != driver.ErrSkip { s.Close() return nil, err } args = args[na:] + start += na tail := s.(*SQLiteStmt).t if tail == "" { return rows, nil @@ -648,15 +656,7 @@ func (c *SQLiteConn) Prepare(query string) (driver.Stmt, error) { if tail != nil && *tail != '\000' { t = strings.TrimSpace(C.GoString(tail)) } - nv := int(C.sqlite3_bind_parameter_count(s)) - var nn []string - for i := 0; i < nv; i++ { - pn := C.GoString(C.sqlite3_bind_parameter_name(s, C.int(i+1))) - if len(pn) > 1 && pn[0] == '$' && 48 <= pn[1] && pn[1] <= 57 { - nn = append(nn, C.GoString(C.sqlite3_bind_parameter_name(s, C.int(i+1)))) - } - } - ss := &SQLiteStmt{c: c, s: s, nv: nv, nn: nn, t: t} + ss := &SQLiteStmt{c: c, s: s, t: t} runtime.SetFinalizer(ss, (*SQLiteStmt).Close) return ss, nil } @@ -680,7 +680,7 @@ func (s *SQLiteStmt) Close() error { // Return a number of parameters. func (s *SQLiteStmt) NumInput() int { - return s.nv + return int(C.sqlite3_bind_parameter_count(s.s)) } type bindArg struct { @@ -694,25 +694,17 @@ func (s *SQLiteStmt) bind(args []namedValue) error { return s.c.lastError() } - var vargs []bindArg - narg := len(args) - vargs = make([]bindArg, narg) - if len(s.nn) > 0 { - for i, v := range s.nn { - if pi, err := strconv.Atoi(v[1:]); err == nil { - vargs[i] = bindArg{pi, args[i].Value} - } - } - } else { - for i, v := range args { - vargs[i] = bindArg{i + 1, v.Value} + for i, v := range args { + if v.Name != "" { + cname := C.CString(v.Name) + args[i].Ordinal = int(C.sqlite3_bind_parameter_index(s.s, cname)) + C.free(unsafe.Pointer(cname)) } } - for _, varg := range vargs { - n := C.int(varg.n) - v := varg.v - switch v := v.(type) { + for _, arg := range args { + n := C.int(arg.Ordinal) + switch v := arg.Value.(type) { case nil: rv = C.sqlite3_bind_null(s.s, n) case string: diff --git a/sqlite3_go18.go b/sqlite3_go18.go index 1ee4c6a..3993490 100644 --- a/sqlite3_go18.go +++ b/sqlite3_go18.go @@ -23,6 +23,14 @@ func (c *SQLiteConn) QueryContext(ctx context.Context, query string, args []driv return c.query(ctx, query, list) } +func (c *SQLiteConn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) { + list := make([]namedValue, len(args)) + for i, nv := range args { + list[i] = namedValue(nv) + } + return c.exec(ctx, query, list) +} + func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) { list := make([]namedValue, len(args)) for i, nv := range args { @@ -30,3 +38,11 @@ func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue) } return s.query(ctx, list) } + +func (s *SQLiteStmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) { + list := make([]namedValue, len(args)) + for i, nv := range args { + list[i] = namedValue(nv) + } + return s.exec(ctx, list) +} diff --git a/sqlite3_test.go b/sqlite3_test.go index fc5c99c..b126bbd 100644 --- a/sqlite3_test.go +++ b/sqlite3_test.go @@ -993,7 +993,7 @@ func TestVersion(t *testing.T) { } } -func TestNumberNamedParams(t *testing.T) { +func TestNamedParams(t *testing.T) { tempFilename := TempFilename(t) defer os.Remove(tempFilename) db, err := sql.Open("sqlite3", tempFilename) @@ -1009,12 +1009,12 @@ func TestNumberNamedParams(t *testing.T) { t.Error("Failed to call db.Query:", err) } - _, err = db.Exec(`insert into foo(id, name, extra) values($1, $2, $2)`, 1, "foo") + _, err = db.Exec(`insert into foo(id, name, extra) values(:id, :name, :name)`, sql.Param(":name", "foo"), sql.Param(":id", 1)) if err != nil { t.Error("Failed to call db.Exec:", err) } - row := db.QueryRow(`select id, extra from foo where id = $1 and extra = $2`, 1, "foo") + row := db.QueryRow(`select id, extra from foo where id = :id and extra = :extra`, sql.Param(":id", 1), sql.Param(":extra", "foo")) if row == nil { t.Error("Failed to call db.QueryRow") } From 29b191f2068cf75cdb2f9e75274de95a3106b9a2 Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Fri, 4 Nov 2016 15:07:51 +0900 Subject: [PATCH 5/8] build tag --- sqlite3_go18.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/sqlite3_go18.go b/sqlite3_go18.go index 3993490..28a1bbf 100644 --- a/sqlite3_go18.go +++ b/sqlite3_go18.go @@ -1,3 +1,5 @@ +// +build go1.8 + package sqlite3 import ( From 025b917610cf628e9be1dcf9386525d0dbc22659 Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Fri, 4 Nov 2016 15:11:24 +0900 Subject: [PATCH 6/8] add PrepareContext --- sqlite3.go | 4 ++++ sqlite3_go18.go | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/sqlite3.go b/sqlite3.go index 3b80eeb..bef5627 100644 --- a/sqlite3.go +++ b/sqlite3.go @@ -644,6 +644,10 @@ func (c *SQLiteConn) Close() error { // Prepare the query string. Return a new statement. func (c *SQLiteConn) Prepare(query string) (driver.Stmt, error) { + return c.prepare(context.Background(), query) +} + +func (c *SQLiteConn) prepare(ctx context.Context, query string) (driver.Stmt, error) { pquery := C.CString(query) defer C.free(unsafe.Pointer(pquery)) var s *C.sqlite3_stmt diff --git a/sqlite3_go18.go b/sqlite3_go18.go index 28a1bbf..5832a92 100644 --- a/sqlite3_go18.go +++ b/sqlite3_go18.go @@ -33,6 +33,10 @@ func (c *SQLiteConn) ExecContext(ctx context.Context, query string, args []drive return c.exec(ctx, query, list) } +func (c *SQLiteConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) { + return c.prepare(ctx, query) +} + func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) { list := make([]namedValue, len(args)) for i, nv := range args { From 755d5be32c971580a8ae5ed32a6bd5ff774d722d Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Fri, 4 Nov 2016 15:15:16 +0900 Subject: [PATCH 7/8] add BeginContext --- sqlite3.go | 4 ++++ sqlite3_go18.go | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/sqlite3.go b/sqlite3.go index bef5627..cf5e99a 100644 --- a/sqlite3.go +++ b/sqlite3.go @@ -514,6 +514,10 @@ func (c *SQLiteConn) execQuery(cmd string) (driver.Result, error) { // Begin transaction. func (c *SQLiteConn) Begin() (driver.Tx, error) { + return c.begin(context.Background()) +} + +func (c *SQLiteConn) begin(ctx context.Context) (driver.Tx, error) { if _, err := c.execQuery(c.txlock); err != nil { return nil, err } diff --git a/sqlite3_go18.go b/sqlite3_go18.go index 5832a92..7109d58 100644 --- a/sqlite3_go18.go +++ b/sqlite3_go18.go @@ -37,6 +37,10 @@ func (c *SQLiteConn) PrepareContext(ctx context.Context, query string) (driver.S return c.prepare(ctx, query) } +func (c *SQLiteConn) BeginContext(ctx context.Context) (driver.Tx, error) { + return c.begin(ctx) +} + func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) { list := make([]namedValue, len(args)) for i, nv := range args { From 57eaf4c0709539478ef65348d27518327283c840 Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Fri, 4 Nov 2016 15:17:21 +0900 Subject: [PATCH 8/8] separate test --- sqlite3_go18_test.go | 49 ++++++++++++++++++++++++++++++++++++++++++++ sqlite3_test.go | 36 -------------------------------- 2 files changed, 49 insertions(+), 36 deletions(-) create mode 100644 sqlite3_go18_test.go diff --git a/sqlite3_go18_test.go b/sqlite3_go18_test.go new file mode 100644 index 0000000..bc8aa4e --- /dev/null +++ b/sqlite3_go18_test.go @@ -0,0 +1,49 @@ +// Copyright (C) 2014 Yasuhiro Matsumoto . +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file. +// +build go1.8 + +package sqlite3 + +import ( + "database/sql" + "os" + "testing" +) + +func TestNamedParams(t *testing.T) { + tempFilename := TempFilename(t) + defer os.Remove(tempFilename) + db, err := sql.Open("sqlite3", tempFilename) + if err != nil { + t.Fatal("Failed to open database:", err) + } + defer db.Close() + + _, err = db.Exec(` + create table foo (id integer, name text, extra text); + `) + if err != nil { + t.Error("Failed to call db.Query:", err) + } + + _, err = db.Exec(`insert into foo(id, name, extra) values(:id, :name, :name)`, sql.Param(":name", "foo"), sql.Param(":id", 1)) + if err != nil { + t.Error("Failed to call db.Exec:", err) + } + + row := db.QueryRow(`select id, extra from foo where id = :id and extra = :extra`, sql.Param(":id", 1), sql.Param(":extra", "foo")) + if row == nil { + t.Error("Failed to call db.QueryRow") + } + var id int + var extra string + err = row.Scan(&id, &extra) + if err != nil { + t.Error("Failed to db.Scan:", err) + } + if id != 1 || extra != "foo" { + t.Error("Failed to db.QueryRow: not matched results") + } +} diff --git a/sqlite3_test.go b/sqlite3_test.go index b126bbd..e578404 100644 --- a/sqlite3_test.go +++ b/sqlite3_test.go @@ -993,42 +993,6 @@ func TestVersion(t *testing.T) { } } -func TestNamedParams(t *testing.T) { - tempFilename := TempFilename(t) - defer os.Remove(tempFilename) - db, err := sql.Open("sqlite3", tempFilename) - if err != nil { - t.Fatal("Failed to open database:", err) - } - defer db.Close() - - _, err = db.Exec(` - create table foo (id integer, name text, extra text); - `) - if err != nil { - t.Error("Failed to call db.Query:", err) - } - - _, err = db.Exec(`insert into foo(id, name, extra) values(:id, :name, :name)`, sql.Param(":name", "foo"), sql.Param(":id", 1)) - if err != nil { - t.Error("Failed to call db.Exec:", err) - } - - row := db.QueryRow(`select id, extra from foo where id = :id and extra = :extra`, sql.Param(":id", 1), sql.Param(":extra", "foo")) - if row == nil { - t.Error("Failed to call db.QueryRow") - } - var id int - var extra string - err = row.Scan(&id, &extra) - if err != nil { - t.Error("Failed to db.Scan:", err) - } - if id != 1 || extra != "foo" { - t.Error("Failed to db.QueryRow: not matched results") - } -} - func TestStringContainingZero(t *testing.T) { tempFilename := TempFilename(t) defer os.Remove(tempFilename)