From 57eaf4c0709539478ef65348d27518327283c840 Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Fri, 4 Nov 2016 15:17:21 +0900 Subject: separate test --- sqlite3_go18_test.go | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) create mode 100644 sqlite3_go18_test.go (limited to '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") + } +} -- cgit v1.2.3 From 15491aeb9ce9ce0ec580011e1bbc3d83c6be4953 Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Sun, 6 Nov 2016 13:16:38 +0900 Subject: go vet && golint --- sqlite3_go18.go | 7 ++++++- sqlite3_go18_test.go | 1 + sqlite3_test.go | 42 +++++++++++++++++++++--------------------- sqlite3_type.go | 3 +++ 4 files changed, 31 insertions(+), 22 deletions(-) (limited to 'sqlite3_go18_test.go') diff --git a/sqlite3_go18.go b/sqlite3_go18.go index 9ad7baf..ec2c3a8 100644 --- a/sqlite3_go18.go +++ b/sqlite3_go18.go @@ -1,3 +1,8 @@ +// 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 @@ -6,7 +11,7 @@ import ( "database/sql/driver" "errors" - "golang.org/x/net/context" + "context" ) // Ping implement Pinger. diff --git a/sqlite3_go18_test.go b/sqlite3_go18_test.go index bc8aa4e..54e6604 100644 --- a/sqlite3_go18_test.go +++ b/sqlite3_go18_test.go @@ -2,6 +2,7 @@ // // 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 diff --git a/sqlite3_test.go b/sqlite3_test.go index e578404..eb9d18e 100644 --- a/sqlite3_test.go +++ b/sqlite3_test.go @@ -207,12 +207,12 @@ func TestUpdate(t *testing.T) { if err != nil { t.Fatal("Failed to update record:", err) } - lastId, err := res.LastInsertId() + 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) + if expected != lastID { + t.Errorf("Expected %q for last Id, but %q:", expected, lastID) } affected, _ = res.RowsAffected() if err != nil { @@ -272,12 +272,12 @@ func TestDelete(t *testing.T) { if err != nil { t.Fatal("Failed to delete record:", err) } - lastId, err := res.LastInsertId() + 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) + if expected != lastID { + t.Errorf("Expected %q for last Id, but %q:", expected, lastID) } affected, err = res.RowsAffected() if err != nil { @@ -1070,12 +1070,12 @@ func TestDateTimeNow(t *testing.T) { } func TestFunctionRegistration(t *testing.T) { - addi_8_16_32 := func(a int8, b int16) int32 { return int32(a) + int32(b) } - addi_64 := func(a, b int64) int64 { return a + b } - addu_8_16_32 := func(a uint8, b uint16) uint32 { return uint32(a) + uint32(b) } - addu_64 := func(a, b uint64) uint64 { return a + b } + addi8_16_32 := func(a int8, b int16) int32 { return int32(a) + int32(b) } + addi64 := func(a, b int64) int64 { return a + b } + addu8_16_32 := func(a uint8, b uint16) uint32 { return uint32(a) + uint32(b) } + addu64 := func(a, b uint64) uint64 { return a + b } addiu := func(a int, b uint) int64 { return int64(a) + int64(b) } - addf_32_64 := func(a float32, b float64) float64 { return float64(a) + b } + addf32_64 := func(a float32, b float64) float64 { return float64(a) + b } not := func(a bool) bool { return !a } regex := func(re, s string) (bool, error) { return regexp.MatchString(re, s) @@ -1107,22 +1107,22 @@ func TestFunctionRegistration(t *testing.T) { sql.Register("sqlite3_FunctionRegistration", &SQLiteDriver{ ConnectHook: func(conn *SQLiteConn) error { - if err := conn.RegisterFunc("addi_8_16_32", addi_8_16_32, true); err != nil { + if err := conn.RegisterFunc("addi8_16_32", addi8_16_32, true); err != nil { return err } - if err := conn.RegisterFunc("addi_64", addi_64, true); err != nil { + if err := conn.RegisterFunc("addi64", addi64, true); err != nil { return err } - if err := conn.RegisterFunc("addu_8_16_32", addu_8_16_32, true); err != nil { + if err := conn.RegisterFunc("addu8_16_32", addu8_16_32, true); err != nil { return err } - if err := conn.RegisterFunc("addu_64", addu_64, true); err != nil { + if err := conn.RegisterFunc("addu64", addu64, true); err != nil { return err } if err := conn.RegisterFunc("addiu", addiu, true); err != nil { return err } - if err := conn.RegisterFunc("addf_32_64", addf_32_64, true); err != nil { + if err := conn.RegisterFunc("addf32_64", addf32_64, true); err != nil { return err } if err := conn.RegisterFunc("not", not, true); err != nil { @@ -1153,12 +1153,12 @@ func TestFunctionRegistration(t *testing.T) { query string expected interface{} }{ - {"SELECT addi_8_16_32(1,2)", int32(3)}, - {"SELECT addi_64(1,2)", int64(3)}, - {"SELECT addu_8_16_32(1,2)", uint32(3)}, - {"SELECT addu_64(1,2)", uint64(3)}, + {"SELECT addi8_16_32(1,2)", int32(3)}, + {"SELECT addi64(1,2)", int64(3)}, + {"SELECT addu8_16_32(1,2)", uint32(3)}, + {"SELECT addu64(1,2)", uint64(3)}, {"SELECT addiu(1,2)", int64(3)}, - {"SELECT addf_32_64(1.5,1.5)", float64(3)}, + {"SELECT addf32_64(1.5,1.5)", float64(3)}, {"SELECT not(1)", false}, {"SELECT not(0)", true}, {`SELECT regex("^foo.*", "foobar")`, true}, diff --git a/sqlite3_type.go b/sqlite3_type.go index 748bc42..200d071 100644 --- a/sqlite3_type.go +++ b/sqlite3_type.go @@ -13,6 +13,7 @@ import ( "time" ) +// ColumnTypeDatabaseTypeName implement RowsColumnTypeDatabaseTypeName. func (rc *SQLiteRows) ColumnTypeDatabaseTypeName(i int) string { return C.GoString(C.sqlite3_column_decltype(rc.s.s, C.int(i))) } @@ -27,10 +28,12 @@ func (rc *SQLiteRows) ColumnTypePrecisionScale(index int) (precision, scale int6 } */ +// ColumnTypeNullable implement RowsColumnTypeNullable. func (rc *SQLiteRows) ColumnTypeNullable(i int) (nullable, ok bool) { return true, true } +// ColumnTypeScanType implement RowsColumnTypeScanType. func (rc *SQLiteRows) ColumnTypeScanType(i int) reflect.Type { switch C.sqlite3_column_type(rc.s.s, C.int(i)) { case C.SQLITE_INTEGER: -- cgit v1.2.3 From dd2c82226baa4c72a4b99efb07d048e9d2e92796 Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Tue, 8 Nov 2016 12:19:13 +0900 Subject: fix trace callback. Close #352 --- callback.go | 4 ++-- sqlite3.go | 56 +++++++++++++++++++++++++++++++--------------------- sqlite3_go18_test.go | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++++ tracecallback.go | 12 +++++------ 4 files changed, 97 insertions(+), 31 deletions(-) (limited to 'sqlite3_go18_test.go') diff --git a/callback.go b/callback.go index 190b695..48fc63a 100644 --- a/callback.go +++ b/callback.go @@ -40,8 +40,8 @@ func callbackTrampoline(ctx *C.sqlite3_context, argc int, argv **C.sqlite3_value } //export stepTrampoline -func stepTrampoline(ctx *C.sqlite3_context, argc int, argv **C.sqlite3_value) { - args := (*[(math.MaxInt32 - 1) / unsafe.Sizeof((*C.sqlite3_value)(nil))]*C.sqlite3_value)(unsafe.Pointer(argv))[:argc:argc] +func stepTrampoline(ctx *C.sqlite3_context, argc C.int, argv **C.sqlite3_value) { + args := (*[(math.MaxInt32 - 1) / unsafe.Sizeof((*C.sqlite3_value)(nil))]*C.sqlite3_value)(unsafe.Pointer(argv))[:int(argc):int(argc)] ai := lookupHandle(uintptr(C.sqlite3_user_data(ctx))).(*aggInfo) ai.Step(ctx, args) } diff --git a/sqlite3.go b/sqlite3.go index 9b55ef1..71a791f 100644 --- a/sqlite3.go +++ b/sqlite3.go @@ -191,6 +191,7 @@ type SQLiteRows struct { decltype []string cls bool done chan struct{} + next *SQLiteRows } type functionInfo struct { @@ -296,19 +297,19 @@ func (ai *aggInfo) Done(ctx *C.sqlite3_context) { // Commit transaction. func (tx *SQLiteTx) Commit() error { - _, err := tx.c.execQuery("COMMIT") + _, err := tx.c.exec(context.Background(), "COMMIT", nil) 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.execQuery("ROLLBACK") + tx.c.exec(context.Background(), "ROLLBACK", nil) } return err } // Rollback transaction. func (tx *SQLiteTx) Rollback() error { - _, err := tx.c.execQuery("ROLLBACK") + _, err := tx.c.exec(context.Background(), "ROLLBACK", nil) return err } @@ -382,13 +383,17 @@ func (c *SQLiteConn) RegisterFunc(name string, impl interface{}, pure bool) erro if pure { opts |= C.SQLITE_DETERMINISTIC } - rv := C._sqlite3_create_function(c.db, cname, C.int(numArgs), C.int(opts), C.uintptr_t(newHandle(c, &fi)), (*[0]byte)(unsafe.Pointer(C.callbackTrampoline)), nil, nil) + rv := sqlite3_create_function(c.db, cname, numArgs, opts, newHandle(c, &fi), C.callbackTrampoline, nil, nil) if rv != C.SQLITE_OK { return c.lastError() } return nil } +func sqlite3_create_function(db *C.sqlite3, zFunctionName *C.char, nArg C.int, eTextRep C.int, pApp C.uintptr_t, xFunc unsafe.Pointer, xStep unsafe.Pointer, xFinal unsafe.Pointer) C.int { + return C._sqlite3_create_function(db, zFunctionName, nArg, eTextRep, pApp, (*[0]byte)(unsafe.Pointer(xFunc)), (*[0]byte)(unsafe.Pointer(xStep)), (*[0]byte)(unsafe.Pointer(xFinal))) +} + // AutoCommit return which currently auto commit or not. func (c *SQLiteConn) AutoCommit() bool { return int(C.sqlite3_get_autocommit(c.db)) != 0 @@ -404,10 +409,6 @@ func (c *SQLiteConn) lastError() Error { // Exec implements Execer. func (c *SQLiteConn) Exec(query string, args []driver.Value) (driver.Result, error) { - if len(args) == 0 { - return c.execQuery(query) - } - list := make([]namedValue, len(args)) for i, v := range args { list[i] = namedValue{ @@ -470,6 +471,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) { + var top, cur *SQLiteRows start := 0 for { s, err := c.Prepare(query) @@ -487,7 +489,14 @@ func (c *SQLiteConn) query(ctx context.Context, query string, args []namedValue) rows, err := s.(*SQLiteStmt).query(ctx, args[:na]) if err != nil && err != driver.ErrSkip { s.Close() - return nil, err + return top, err + } + if top == nil { + top = rows.(*SQLiteRows) + cur = top + } else { + cur.next = rows.(*SQLiteRows) + cur = cur.next } args = args[na:] start += na @@ -501,25 +510,13 @@ func (c *SQLiteConn) query(ctx context.Context, query string, args []namedValue) } } -func (c *SQLiteConn) execQuery(cmd string) (driver.Result, error) { - pcmd := C.CString(cmd) - defer C.free(unsafe.Pointer(pcmd)) - - var rowid, changes C.longlong - rv := C._sqlite3_exec(c.db, pcmd, &rowid, &changes) - if rv != C.SQLITE_OK { - return nil, c.lastError() - } - return &SQLiteResult{int64(rowid), int64(changes)}, nil -} - // 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 { + if _, err := c.exec(ctx, c.txlock, nil); err != nil { return nil, err } return &SQLiteTx{c}, nil @@ -775,6 +772,7 @@ func (s *SQLiteStmt) query(ctx context.Context, args []namedValue) (driver.Rows, decltype: nil, cls: s.cls, done: make(chan struct{}), + next: nil, } go func() { @@ -837,7 +835,7 @@ func (s *SQLiteStmt) exec(ctx context.Context, args []namedValue) (driver.Result return nil, err } - return &SQLiteResult{int64(rowid), int64(changes)}, nil + return &SQLiteResult{id: int64(rowid), changes: int64(changes)}, nil } // Close the rows. @@ -972,3 +970,15 @@ func (rc *SQLiteRows) Next(dest []driver.Value) error { } return nil } + +func (rc *SQLiteRows) HasNextResultSet() bool { + return rc.next != nil +} + +func (rc *SQLiteRows) NextResultSet() error { + if rc.next == nil { + return io.EOF + } + *rc = *rc.next + return nil +} diff --git a/sqlite3_go18_test.go b/sqlite3_go18_test.go index 54e6604..0536042 100644 --- a/sqlite3_go18_test.go +++ b/sqlite3_go18_test.go @@ -9,6 +9,7 @@ package sqlite3 import ( "database/sql" + "fmt" "os" "testing" ) @@ -48,3 +49,58 @@ func TestNamedParams(t *testing.T) { t.Error("Failed to db.QueryRow: not matched results") } } + +func TestMultipleResultSet(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); + `) + if err != nil { + t.Error("Failed to call db.Query:", err) + } + + for i := 0; i < 100; i++ { + _, err = db.Exec(`insert into foo(id, name) values(?, ?)`, i+1, fmt.Sprintf("foo%03d", i+1)) + if err != nil { + t.Error("Failed to call db.Exec:", err) + } + } + + rows, err := db.Query(` + select id, name from foo where id < :id1; + select id, name from foo where id = :id2; + select id, name from foo where id > :id3; + `, + sql.Param(":id1", 3), + sql.Param(":id2", 50), + sql.Param(":id3", 98), + ) + if err != nil { + t.Error("Failed to call db.Query:", err) + } + + var id int + var extra string + + for { + for rows.Next() { + err = rows.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") + } + } + if !rows.NextResultSet() { + break + } + } +} diff --git a/tracecallback.go b/tracecallback.go index bf222b5..9c42791 100644 --- a/tracecallback.go +++ b/tracecallback.go @@ -17,7 +17,7 @@ package sqlite3 void stepTrampoline(sqlite3_context*, int, sqlite3_value**); void doneTrampoline(sqlite3_context*); -void traceCallbackTrampoline(unsigned traceEventCode, void *ctx, void *p, void *x); +int traceCallbackTrampoline(unsigned int traceEventCode, void *ctx, void *p, void *x); */ import "C" @@ -76,7 +76,7 @@ type TraceUserCallback func(TraceInfo) int type TraceConfig struct { Callback TraceUserCallback - EventMask uint + EventMask C.uint WantExpandedSQL bool } @@ -102,13 +102,13 @@ func fillExpandedSQL(info *TraceInfo, db *C.sqlite3, pStmt unsafe.Pointer) { //export traceCallbackTrampoline func traceCallbackTrampoline( - traceEventCode uint, + traceEventCode C.uint, // Parameter named 'C' in SQLite docs = Context given at registration: ctx unsafe.Pointer, // Parameter named 'P' in SQLite docs (Primary event data?): p unsafe.Pointer, // Parameter named 'X' in SQLite docs (eXtra event data?): - xValue unsafe.Pointer) int { + xValue unsafe.Pointer) C.int { if ctx == nil { panic(fmt.Sprintf("No context (ev 0x%x)", traceEventCode)) @@ -196,7 +196,7 @@ func traceCallbackTrampoline( if traceConf.Callback != nil { r = traceConf.Callback(info) } - return r + return C.int(r) } type traceMapEntry struct { @@ -358,7 +358,7 @@ func (c *SQLiteConn) RegisterAggregator(name string, impl interface{}, pure bool if pure { opts |= C.SQLITE_DETERMINISTIC } - rv := C._sqlite3_create_function(c.db, cname, C.int(stepNArgs), C.int(opts), C.uintptr_t(newHandle(c, &ai)), nil, (*[0]byte)(unsafe.Pointer(C.stepTrampoline)), (*[0]byte)(unsafe.Pointer(C.doneTrampoline))) + rv := sqlite3_create_function(c.db, cname, C.int(stepNArgs), C.int(opts), C.uintptr_t(newHandle(c, &ai)), nil, C.stepTrampoline, C.doneTrampoline) if rv != C.SQLITE_OK { return c.lastError() } -- cgit v1.2.3 From ea2afbe9e89fa28e9b4ce5942179bb1fa2bb977d Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Tue, 8 Nov 2016 13:22:46 +0900 Subject: revert Multiple Result Set --- sqlite3.go | 24 +--------------------- sqlite3_go18_test.go | 56 ---------------------------------------------------- 2 files changed, 1 insertion(+), 79 deletions(-) (limited to 'sqlite3_go18_test.go') diff --git a/sqlite3.go b/sqlite3.go index cfbdae3..1855eb0 100644 --- a/sqlite3.go +++ b/sqlite3.go @@ -191,7 +191,6 @@ type SQLiteRows struct { decltype []string cls bool done chan struct{} - next *SQLiteRows } type functionInfo struct { @@ -471,7 +470,6 @@ 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) { - var top, cur *SQLiteRows start := 0 for { s, err := c.Prepare(query) @@ -489,14 +487,7 @@ func (c *SQLiteConn) query(ctx context.Context, query string, args []namedValue) rows, err := s.(*SQLiteStmt).query(ctx, args[:na]) if err != nil && err != driver.ErrSkip { s.Close() - return top, err - } - if top == nil { - top = rows.(*SQLiteRows) - cur = top - } else { - cur.next = rows.(*SQLiteRows) - cur = cur.next + return rows, err } args = args[na:] start += na @@ -772,7 +763,6 @@ func (s *SQLiteStmt) query(ctx context.Context, args []namedValue) (driver.Rows, decltype: nil, cls: s.cls, done: make(chan struct{}), - next: nil, } go func() { @@ -970,15 +960,3 @@ func (rc *SQLiteRows) Next(dest []driver.Value) error { } return nil } - -func (rc *SQLiteRows) HasNextResultSet() bool { - return rc.next != nil -} - -func (rc *SQLiteRows) NextResultSet() error { - if rc.next == nil { - return io.EOF - } - *rc = *rc.next - return nil -} diff --git a/sqlite3_go18_test.go b/sqlite3_go18_test.go index 0536042..54e6604 100644 --- a/sqlite3_go18_test.go +++ b/sqlite3_go18_test.go @@ -9,7 +9,6 @@ package sqlite3 import ( "database/sql" - "fmt" "os" "testing" ) @@ -49,58 +48,3 @@ func TestNamedParams(t *testing.T) { t.Error("Failed to db.QueryRow: not matched results") } } - -func TestMultipleResultSet(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); - `) - if err != nil { - t.Error("Failed to call db.Query:", err) - } - - for i := 0; i < 100; i++ { - _, err = db.Exec(`insert into foo(id, name) values(?, ?)`, i+1, fmt.Sprintf("foo%03d", i+1)) - if err != nil { - t.Error("Failed to call db.Exec:", err) - } - } - - rows, err := db.Query(` - select id, name from foo where id < :id1; - select id, name from foo where id = :id2; - select id, name from foo where id > :id3; - `, - sql.Param(":id1", 3), - sql.Param(":id2", 50), - sql.Param(":id3", 98), - ) - if err != nil { - t.Error("Failed to call db.Query:", err) - } - - var id int - var extra string - - for { - for rows.Next() { - err = rows.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") - } - } - if !rows.NextResultSet() { - break - } - } -} -- cgit v1.2.3 From 8ecd77c707d698b39fbcf76e4e8d08f284c8307f Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Thu, 1 Dec 2016 12:12:18 +0900 Subject: fix test see https://github.com/golang/go/issues/18099 --- sqlite3_go18_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'sqlite3_go18_test.go') diff --git a/sqlite3_go18_test.go b/sqlite3_go18_test.go index 54e6604..f95f9bc 100644 --- a/sqlite3_go18_test.go +++ b/sqlite3_go18_test.go @@ -29,12 +29,12 @@ func TestNamedParams(t *testing.T) { 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)) + _, err = db.Exec(`insert into foo(id, name, extra) values(:id, :name, :name)`, sql.Named(":name", "foo"), sql.Named(":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")) + row := db.QueryRow(`select id, extra from foo where id = :id and extra = :extra`, sql.Named(":id", 1), sql.Named(":extra", "foo")) if row == nil { t.Error("Failed to call db.QueryRow") } -- cgit v1.2.3 From 35cf400919eb9c0fc5bb69860421d6597318a13b Mon Sep 17 00:00:00 2001 From: Yasuhiro Matsumoto Date: Fri, 9 Dec 2016 12:58:20 +0900 Subject: fix tests --- sqlite3_go18_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'sqlite3_go18_test.go') diff --git a/sqlite3_go18_test.go b/sqlite3_go18_test.go index f95f9bc..f076b81 100644 --- a/sqlite3_go18_test.go +++ b/sqlite3_go18_test.go @@ -29,12 +29,12 @@ func TestNamedParams(t *testing.T) { t.Error("Failed to call db.Query:", err) } - _, err = db.Exec(`insert into foo(id, name, extra) values(:id, :name, :name)`, sql.Named(":name", "foo"), sql.Named(":id", 1)) + _, err = db.Exec(`insert into foo(id, name, extra) values(:id, :name, :name)`, sql.Named("name", "foo"), sql.Named("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.Named(":id", 1), sql.Named(":extra", "foo")) + row := db.QueryRow(`select id, extra from foo where id = :id and extra = :extra`, sql.Named("id", 1), sql.Named("extra", "foo")) if row == nil { t.Error("Failed to call db.QueryRow") } -- cgit v1.2.3