diff options
author | Christopher Speller <crspeller@gmail.com> | 2017-02-02 09:32:00 -0500 |
---|---|---|
committer | Harrison Healey <harrisonmhealey@gmail.com> | 2017-02-02 09:32:00 -0500 |
commit | 701d1ab638b23c24877fc41824add66232446676 (patch) | |
tree | ec120c88d38ac9d38d9eabdd3270b52bb6ac9d96 /vendor/github.com/go-sql-driver/mysql/driver_test.go | |
parent | ca3211bc04f6dea34e8168217182637d1419f998 (diff) | |
download | chat-701d1ab638b23c24877fc41824add66232446676.tar.gz chat-701d1ab638b23c24877fc41824add66232446676.tar.bz2 chat-701d1ab638b23c24877fc41824add66232446676.zip |
Updating server dependancies (#5249)
Diffstat (limited to 'vendor/github.com/go-sql-driver/mysql/driver_test.go')
-rw-r--r-- | vendor/github.com/go-sql-driver/mysql/driver_test.go | 940 |
1 files changed, 737 insertions, 203 deletions
diff --git a/vendor/github.com/go-sql-driver/mysql/driver_test.go b/vendor/github.com/go-sql-driver/mysql/driver_test.go index ef5b371cf..78e68f5d0 100644 --- a/vendor/github.com/go-sql-driver/mysql/driver_test.go +++ b/vendor/github.com/go-sql-driver/mysql/driver_test.go @@ -9,12 +9,14 @@ package mysql import ( + "bytes" "crypto/tls" "database/sql" "database/sql/driver" "fmt" "io" "io/ioutil" + "log" "net" "net/url" "os" @@ -74,23 +76,75 @@ type DBTest struct { db *sql.DB } +func runTestsWithMultiStatement(t *testing.T, dsn string, tests ...func(dbt *DBTest)) { + if !available { + t.Skipf("MySQL server not running on %s", netAddr) + } + + dsn += "&multiStatements=true" + var db *sql.DB + if _, err := ParseDSN(dsn); err != errInvalidDSNUnsafeCollation { + db, err = sql.Open("mysql", dsn) + if err != nil { + t.Fatalf("error connecting: %s", err.Error()) + } + defer db.Close() + } + + dbt := &DBTest{t, db} + for _, test := range tests { + test(dbt) + dbt.db.Exec("DROP TABLE IF EXISTS test") + } +} + func runTests(t *testing.T, dsn string, tests ...func(dbt *DBTest)) { if !available { - t.Skipf("MySQL-Server not running on %s", netAddr) + t.Skipf("MySQL server not running on %s", netAddr) } db, err := sql.Open("mysql", dsn) if err != nil { - t.Fatalf("Error connecting: %s", err.Error()) + t.Fatalf("error connecting: %s", err.Error()) } defer db.Close() db.Exec("DROP TABLE IF EXISTS test") + dsn2 := dsn + "&interpolateParams=true" + var db2 *sql.DB + if _, err := ParseDSN(dsn2); err != errInvalidDSNUnsafeCollation { + db2, err = sql.Open("mysql", dsn2) + if err != nil { + t.Fatalf("error connecting: %s", err.Error()) + } + defer db2.Close() + } + + dsn3 := dsn + "&multiStatements=true" + var db3 *sql.DB + if _, err := ParseDSN(dsn3); err != errInvalidDSNUnsafeCollation { + db3, err = sql.Open("mysql", dsn3) + if err != nil { + t.Fatalf("error connecting: %s", err.Error()) + } + defer db3.Close() + } + dbt := &DBTest{t, db} + dbt2 := &DBTest{t, db2} + dbt3 := &DBTest{t, db3} for _, test := range tests { test(dbt) dbt.db.Exec("DROP TABLE IF EXISTS test") + if db2 != nil { + test(dbt2) + dbt2.db.Exec("DROP TABLE IF EXISTS test") + } + if db3 != nil { + test(dbt3) + dbt3.db.Exec("DROP TABLE IF EXISTS test") + } } } @@ -98,13 +152,13 @@ func (dbt *DBTest) fail(method, query string, err error) { if len(query) > 300 { query = "[query too large to print]" } - dbt.Fatalf("Error on %s %s: %s", method, query, err.Error()) + dbt.Fatalf("error on %s %s: %s", method, query, err.Error()) } func (dbt *DBTest) mustExec(query string, args ...interface{}) (res sql.Result) { res, err := dbt.db.Exec(query, args...) if err != nil { - dbt.fail("Exec", query, err) + dbt.fail("exec", query, err) } return res } @@ -112,11 +166,22 @@ func (dbt *DBTest) mustExec(query string, args ...interface{}) (res sql.Result) func (dbt *DBTest) mustQuery(query string, args ...interface{}) (rows *sql.Rows) { rows, err := dbt.db.Query(query, args...) if err != nil { - dbt.fail("Query", query, err) + dbt.fail("query", query, err) } return rows } +func TestEmptyQuery(t *testing.T) { + runTests(t, dsn, func(dbt *DBTest) { + // just a comment, no query + rows := dbt.mustQuery("--") + // will hang before #255 + if rows.Next() { + dbt.Errorf("next on rows must be false") + } + }) +} + func TestCRUD(t *testing.T) { runTests(t, dsn, func(dbt *DBTest) { // Create Table @@ -136,7 +201,7 @@ func TestCRUD(t *testing.T) { dbt.Fatalf("res.RowsAffected() returned error: %s", err.Error()) } if count != 1 { - dbt.Fatalf("Expected 1 affected row, got %d", count) + dbt.Fatalf("expected 1 affected row, got %d", count) } id, err := res.LastInsertId() @@ -144,7 +209,7 @@ func TestCRUD(t *testing.T) { dbt.Fatalf("res.LastInsertId() returned error: %s", err.Error()) } if id != 0 { - dbt.Fatalf("Expected InsertID 0, got %d", id) + dbt.Fatalf("expected InsertId 0, got %d", id) } // Read @@ -169,7 +234,7 @@ func TestCRUD(t *testing.T) { dbt.Fatalf("res.RowsAffected() returned error: %s", err.Error()) } if count != 1 { - dbt.Fatalf("Expected 1 affected row, got %d", count) + dbt.Fatalf("expected 1 affected row, got %d", count) } // Check Update @@ -194,7 +259,7 @@ func TestCRUD(t *testing.T) { dbt.Fatalf("res.RowsAffected() returned error: %s", err.Error()) } if count != 1 { - dbt.Fatalf("Expected 1 affected row, got %d", count) + dbt.Fatalf("expected 1 affected row, got %d", count) } // Check for unexpected rows @@ -204,8 +269,52 @@ func TestCRUD(t *testing.T) { dbt.Fatalf("res.RowsAffected() returned error: %s", err.Error()) } if count != 0 { - dbt.Fatalf("Expected 0 affected row, got %d", count) + dbt.Fatalf("expected 0 affected row, got %d", count) + } + }) +} + +func TestMultiQuery(t *testing.T) { + runTestsWithMultiStatement(t, dsn, func(dbt *DBTest) { + // Create Table + dbt.mustExec("CREATE TABLE `test` (`id` int(11) NOT NULL, `value` int(11) NOT NULL) ") + + // Create Data + res := dbt.mustExec("INSERT INTO test VALUES (1, 1)") + count, err := res.RowsAffected() + if err != nil { + dbt.Fatalf("res.RowsAffected() returned error: %s", err.Error()) + } + if count != 1 { + dbt.Fatalf("expected 1 affected row, got %d", count) + } + + // Update + res = dbt.mustExec("UPDATE test SET value = 3 WHERE id = 1; UPDATE test SET value = 4 WHERE id = 1; UPDATE test SET value = 5 WHERE id = 1;") + count, err = res.RowsAffected() + if err != nil { + dbt.Fatalf("res.RowsAffected() returned error: %s", err.Error()) + } + if count != 1 { + dbt.Fatalf("expected 1 affected row, got %d", count) + } + + // Read + var out int + rows := dbt.mustQuery("SELECT value FROM test WHERE id=1;") + if rows.Next() { + rows.Scan(&out) + if 5 != out { + dbt.Errorf("5 != %d", out) + } + + if rows.Next() { + dbt.Error("unexpected data") + } + } else { + dbt.Error("no data") } + }) } @@ -256,7 +365,7 @@ func TestInt(t *testing.T) { }) } -func TestFloat(t *testing.T) { +func TestFloat32(t *testing.T) { runTests(t, dsn, func(dbt *DBTest) { types := [2]string{"FLOAT", "DOUBLE"} in := float32(42.23) @@ -279,6 +388,52 @@ func TestFloat(t *testing.T) { }) } +func TestFloat64(t *testing.T) { + runTests(t, dsn, func(dbt *DBTest) { + types := [2]string{"FLOAT", "DOUBLE"} + var expected float64 = 42.23 + var out float64 + var rows *sql.Rows + for _, v := range types { + dbt.mustExec("CREATE TABLE test (value " + v + ")") + dbt.mustExec("INSERT INTO test VALUES (42.23)") + rows = dbt.mustQuery("SELECT value FROM test") + if rows.Next() { + rows.Scan(&out) + if expected != out { + dbt.Errorf("%s: %g != %g", v, expected, out) + } + } else { + dbt.Errorf("%s: no data", v) + } + dbt.mustExec("DROP TABLE IF EXISTS test") + } + }) +} + +func TestFloat64Placeholder(t *testing.T) { + runTests(t, dsn, func(dbt *DBTest) { + types := [2]string{"FLOAT", "DOUBLE"} + var expected float64 = 42.23 + var out float64 + var rows *sql.Rows + for _, v := range types { + dbt.mustExec("CREATE TABLE test (id int, value " + v + ")") + dbt.mustExec("INSERT INTO test VALUES (1, 42.23)") + rows = dbt.mustQuery("SELECT value FROM test WHERE id = ?", 1) + if rows.Next() { + rows.Scan(&out) + if expected != out { + dbt.Errorf("%s: %g != %g", v, expected, out) + } + } else { + dbt.Errorf("%s: no data", v) + } + dbt.mustExec("DROP TABLE IF EXISTS test") + } + }) +} + func TestString(t *testing.T) { runTests(t, dsn, func(dbt *DBTest) { types := [6]string{"CHAR(255)", "VARCHAR(255)", "TINYTEXT", "TEXT", "MEDIUMTEXT", "LONGTEXT"} @@ -327,97 +482,281 @@ func TestString(t *testing.T) { }) } -func TestDateTime(t *testing.T) { - type testmode struct { - selectSuffix string - args []interface{} +type timeTests struct { + dbtype string + tlayout string + tests []timeTest +} + +type timeTest struct { + s string // leading "!": do not use t as value in queries + t time.Time +} + +type timeMode byte + +func (t timeMode) String() string { + switch t { + case binaryString: + return "binary:string" + case binaryTime: + return "binary:time.Time" + case textString: + return "text:string" + } + panic("unsupported timeMode") +} + +func (t timeMode) Binary() bool { + switch t { + case binaryString, binaryTime: + return true } - type timetest struct { - in interface{} - sOut string - tOut time.Time - tIsZero bool + return false +} + +const ( + binaryString timeMode = iota + binaryTime + textString +) + +func (t timeTest) genQuery(dbtype string, mode timeMode) string { + var inner string + if mode.Binary() { + inner = "?" + } else { + inner = `"%s"` } - type tester func(dbt *DBTest, rows *sql.Rows, - test *timetest, sqltype, resulttype, mode string) - type setup struct { - vartype string - dsnSuffix string - test tester + return `SELECT cast(` + inner + ` as ` + dbtype + `)` +} + +func (t timeTest) run(dbt *DBTest, dbtype, tlayout string, mode timeMode) { + var rows *sql.Rows + query := t.genQuery(dbtype, mode) + switch mode { + case binaryString: + rows = dbt.mustQuery(query, t.s) + case binaryTime: + rows = dbt.mustQuery(query, t.t) + case textString: + query = fmt.Sprintf(query, t.s) + rows = dbt.mustQuery(query) + default: + panic("unsupported mode") } - var ( - modes = map[string]*testmode{ - "text": &testmode{}, - "binary": &testmode{" WHERE 1 = ?", []interface{}{1}}, - } - timetests = map[string][]*timetest{ - "DATE": { - {sDate, sDate, tDate, false}, - {sDate0, sDate0, tDate0, true}, - {tDate, sDate, tDate, false}, - {tDate0, sDate0, tDate0, true}, - }, - "DATETIME": { - {sDateTime, sDateTime, tDateTime, false}, - {sDateTime0, sDateTime0, tDate0, true}, - {tDateTime, sDateTime, tDateTime, false}, - {tDate0, sDateTime0, tDate0, true}, - }, - } - setups = []*setup{ - {"string", "&parseTime=false", func( - dbt *DBTest, rows *sql.Rows, test *timetest, sqltype, resulttype, mode string) { - var sOut string - if err := rows.Scan(&sOut); err != nil { - dbt.Errorf("%s (%s %s): %s", sqltype, resulttype, mode, err.Error()) - } else if test.sOut != sOut { - dbt.Errorf("%s (%s %s): %s != %s", sqltype, resulttype, mode, test.sOut, sOut) - } - }}, - {"time.Time", "&parseTime=true", func( - dbt *DBTest, rows *sql.Rows, test *timetest, sqltype, resulttype, mode string) { - var tOut time.Time - if err := rows.Scan(&tOut); err != nil { - dbt.Errorf("%s (%s %s): %s", sqltype, resulttype, mode, err.Error()) - } else if test.tOut != tOut || test.tIsZero != tOut.IsZero() { - dbt.Errorf("%s (%s %s): %s [%t] != %s [%t]", sqltype, resulttype, mode, test.tOut, test.tIsZero, tOut, tOut.IsZero()) - } - }}, + defer rows.Close() + var err error + if !rows.Next() { + err = rows.Err() + if err == nil { + err = fmt.Errorf("no data") } - ) + dbt.Errorf("%s [%s]: %s", dbtype, mode, err) + return + } + var dst interface{} + err = rows.Scan(&dst) + if err != nil { + dbt.Errorf("%s [%s]: %s", dbtype, mode, err) + return + } + switch val := dst.(type) { + case []uint8: + str := string(val) + if str == t.s { + return + } + if mode.Binary() && dbtype == "DATETIME" && len(str) == 26 && str[:19] == t.s { + // a fix mainly for TravisCI: + // accept full microsecond resolution in result for DATETIME columns + // where the binary protocol was used + return + } + dbt.Errorf("%s [%s] to string: expected %q, got %q", + dbtype, mode, + t.s, str, + ) + case time.Time: + if val == t.t { + return + } + dbt.Errorf("%s [%s] to string: expected %q, got %q", + dbtype, mode, + t.s, val.Format(tlayout), + ) + default: + fmt.Printf("%#v\n", []interface{}{dbtype, tlayout, mode, t.s, t.t}) + dbt.Errorf("%s [%s]: unhandled type %T (is '%v')", + dbtype, mode, + val, val, + ) + } +} - var s *setup - testTime := func(dbt *DBTest) { - var rows *sql.Rows - for sqltype, tests := range timetests { - dbt.mustExec("CREATE TABLE test (value " + sqltype + ")") - for _, test := range tests { - for mode, q := range modes { - dbt.mustExec("TRUNCATE test") - dbt.mustExec("INSERT INTO test VALUES (?)", test.in) - rows = dbt.mustQuery("SELECT value FROM test"+q.selectSuffix, q.args...) - if rows.Next() { - s.test(dbt, rows, test, sqltype, s.vartype, mode) - } else { - if err := rows.Err(); err != nil { - dbt.Errorf("%s (%s %s): %s", - sqltype, s.vartype, mode, err.Error()) - } else { - dbt.Errorf("%s (%s %s): no data", - sqltype, s.vartype, mode) - } +func TestDateTime(t *testing.T) { + afterTime := func(t time.Time, d string) time.Time { + dur, err := time.ParseDuration(d) + if err != nil { + panic(err) + } + return t.Add(dur) + } + // NOTE: MySQL rounds DATETIME(x) up - but that's not included in the tests + format := "2006-01-02 15:04:05.999999" + t0 := time.Time{} + tstr0 := "0000-00-00 00:00:00.000000" + testcases := []timeTests{ + {"DATE", format[:10], []timeTest{ + {t: time.Date(2011, 11, 20, 0, 0, 0, 0, time.UTC)}, + {t: t0, s: tstr0[:10]}, + }}, + {"DATETIME", format[:19], []timeTest{ + {t: time.Date(2011, 11, 20, 21, 27, 37, 0, time.UTC)}, + {t: t0, s: tstr0[:19]}, + }}, + {"DATETIME(0)", format[:21], []timeTest{ + {t: time.Date(2011, 11, 20, 21, 27, 37, 0, time.UTC)}, + {t: t0, s: tstr0[:19]}, + }}, + {"DATETIME(1)", format[:21], []timeTest{ + {t: time.Date(2011, 11, 20, 21, 27, 37, 100000000, time.UTC)}, + {t: t0, s: tstr0[:21]}, + }}, + {"DATETIME(6)", format, []timeTest{ + {t: time.Date(2011, 11, 20, 21, 27, 37, 123456000, time.UTC)}, + {t: t0, s: tstr0}, + }}, + {"TIME", format[11:19], []timeTest{ + {t: afterTime(t0, "12345s")}, + {s: "!-12:34:56"}, + {s: "!-838:59:59"}, + {s: "!838:59:59"}, + {t: t0, s: tstr0[11:19]}, + }}, + {"TIME(0)", format[11:19], []timeTest{ + {t: afterTime(t0, "12345s")}, + {s: "!-12:34:56"}, + {s: "!-838:59:59"}, + {s: "!838:59:59"}, + {t: t0, s: tstr0[11:19]}, + }}, + {"TIME(1)", format[11:21], []timeTest{ + {t: afterTime(t0, "12345600ms")}, + {s: "!-12:34:56.7"}, + {s: "!-838:59:58.9"}, + {s: "!838:59:58.9"}, + {t: t0, s: tstr0[11:21]}, + }}, + {"TIME(6)", format[11:], []timeTest{ + {t: afterTime(t0, "1234567890123000ns")}, + {s: "!-12:34:56.789012"}, + {s: "!-838:59:58.999999"}, + {s: "!838:59:58.999999"}, + {t: t0, s: tstr0[11:]}, + }}, + } + dsns := []string{ + dsn + "&parseTime=true", + dsn + "&parseTime=false", + } + for _, testdsn := range dsns { + runTests(t, testdsn, func(dbt *DBTest) { + microsecsSupported := false + zeroDateSupported := false + var rows *sql.Rows + var err error + rows, err = dbt.db.Query(`SELECT cast("00:00:00.1" as TIME(1)) = "00:00:00.1"`) + if err == nil { + rows.Scan(µsecsSupported) + rows.Close() + } + rows, err = dbt.db.Query(`SELECT cast("0000-00-00" as DATE) = "0000-00-00"`) + if err == nil { + rows.Scan(&zeroDateSupported) + rows.Close() + } + for _, setups := range testcases { + if t := setups.dbtype; !microsecsSupported && t[len(t)-1:] == ")" { + // skip fractional second tests if unsupported by server + continue + } + for _, setup := range setups.tests { + allowBinTime := true + if setup.s == "" { + // fill time string whereever Go can reliable produce it + setup.s = setup.t.Format(setups.tlayout) + } else if setup.s[0] == '!' { + // skip tests using setup.t as source in queries + allowBinTime = false + // fix setup.s - remove the "!" + setup.s = setup.s[1:] + } + if !zeroDateSupported && setup.s == tstr0[:len(setup.s)] { + // skip disallowed 0000-00-00 date + continue + } + setup.run(dbt, setups.dbtype, setups.tlayout, textString) + setup.run(dbt, setups.dbtype, setups.tlayout, binaryString) + if allowBinTime { + setup.run(dbt, setups.dbtype, setups.tlayout, binaryTime) } } } - dbt.mustExec("DROP TABLE IF EXISTS test") - } + }) } +} - timeDsn := dsn + "&sql_mode=ALLOW_INVALID_DATES" - for _, v := range setups { - s = v - runTests(t, timeDsn+s.dsnSuffix, testTime) - } +func TestTimestampMicros(t *testing.T) { + format := "2006-01-02 15:04:05.999999" + f0 := format[:19] + f1 := format[:21] + f6 := format[:26] + runTests(t, dsn, func(dbt *DBTest) { + // check if microseconds are supported. + // Do not use timestamp(x) for that check - before 5.5.6, x would mean display width + // and not precision. + // Se last paragraph at http://dev.mysql.com/doc/refman/5.6/en/fractional-seconds.html + microsecsSupported := false + if rows, err := dbt.db.Query(`SELECT cast("00:00:00.1" as TIME(1)) = "00:00:00.1"`); err == nil { + rows.Scan(µsecsSupported) + rows.Close() + } + if !microsecsSupported { + // skip test + return + } + _, err := dbt.db.Exec(` + CREATE TABLE test ( + value0 TIMESTAMP NOT NULL DEFAULT '` + f0 + `', + value1 TIMESTAMP(1) NOT NULL DEFAULT '` + f1 + `', + value6 TIMESTAMP(6) NOT NULL DEFAULT '` + f6 + `' + )`, + ) + if err != nil { + dbt.Error(err) + } + defer dbt.mustExec("DROP TABLE IF EXISTS test") + dbt.mustExec("INSERT INTO test SET value0=?, value1=?, value6=?", f0, f1, f6) + var res0, res1, res6 string + rows := dbt.mustQuery("SELECT * FROM test") + if !rows.Next() { + dbt.Errorf("test contained no selectable values") + } + err = rows.Scan(&res0, &res1, &res6) + if err != nil { + dbt.Error(err) + } + if res0 != f0 { + dbt.Errorf("expected %q, got %q", f0, res0) + } + if res1 != f1 { + dbt.Errorf("expected %q, got %q", f1, res1) + } + if res6 != f6 { + dbt.Errorf("expected %q, got %q", f6, res6) + } + }) } func TestNULL(t *testing.T) { @@ -441,14 +780,14 @@ func TestNULL(t *testing.T) { dbt.Fatal(err) } if nb.Valid { - dbt.Error("Valid NullBool which should be invalid") + dbt.Error("valid NullBool which should be invalid") } // Valid if err = nonNullStmt.QueryRow().Scan(&nb); err != nil { dbt.Fatal(err) } if !nb.Valid { - dbt.Error("Invalid NullBool which should be valid") + dbt.Error("invalid NullBool which should be valid") } else if nb.Bool != true { dbt.Errorf("Unexpected NullBool value: %t (should be true)", nb.Bool) } @@ -460,16 +799,16 @@ func TestNULL(t *testing.T) { dbt.Fatal(err) } if nf.Valid { - dbt.Error("Valid NullFloat64 which should be invalid") + dbt.Error("valid NullFloat64 which should be invalid") } // Valid if err = nonNullStmt.QueryRow().Scan(&nf); err != nil { dbt.Fatal(err) } if !nf.Valid { - dbt.Error("Invalid NullFloat64 which should be valid") + dbt.Error("invalid NullFloat64 which should be valid") } else if nf.Float64 != float64(1) { - dbt.Errorf("Unexpected NullFloat64 value: %f (should be 1.0)", nf.Float64) + dbt.Errorf("unexpected NullFloat64 value: %f (should be 1.0)", nf.Float64) } // NullInt64 @@ -479,16 +818,16 @@ func TestNULL(t *testing.T) { dbt.Fatal(err) } if ni.Valid { - dbt.Error("Valid NullInt64 which should be invalid") + dbt.Error("valid NullInt64 which should be invalid") } // Valid if err = nonNullStmt.QueryRow().Scan(&ni); err != nil { dbt.Fatal(err) } if !ni.Valid { - dbt.Error("Invalid NullInt64 which should be valid") + dbt.Error("invalid NullInt64 which should be valid") } else if ni.Int64 != int64(1) { - dbt.Errorf("Unexpected NullInt64 value: %d (should be 1)", ni.Int64) + dbt.Errorf("unexpected NullInt64 value: %d (should be 1)", ni.Int64) } // NullString @@ -498,16 +837,16 @@ func TestNULL(t *testing.T) { dbt.Fatal(err) } if ns.Valid { - dbt.Error("Valid NullString which should be invalid") + dbt.Error("valid NullString which should be invalid") } // Valid if err = nonNullStmt.QueryRow().Scan(&ns); err != nil { dbt.Fatal(err) } if !ns.Valid { - dbt.Error("Invalid NullString which should be valid") + dbt.Error("invalid NullString which should be valid") } else if ns.String != `1` { - dbt.Error("Unexpected NullString value:" + ns.String + " (should be `1`)") + dbt.Error("unexpected NullString value:" + ns.String + " (should be `1`)") } // nil-bytes @@ -517,14 +856,14 @@ func TestNULL(t *testing.T) { dbt.Fatal(err) } if b != nil { - dbt.Error("Non-nil []byte wich should be nil") + dbt.Error("non-nil []byte wich should be nil") } // Read non-nil if err = nonNullStmt.QueryRow().Scan(&b); err != nil { dbt.Fatal(err) } if b == nil { - dbt.Error("Nil []byte wich should be non-nil") + dbt.Error("nil []byte wich should be non-nil") } // Insert nil b = nil @@ -533,7 +872,7 @@ func TestNULL(t *testing.T) { dbt.Fatal(err) } if !success { - dbt.Error("Inserting []byte(nil) as NULL failed") + dbt.Error("inserting []byte(nil) as NULL failed") } // Check input==output with input==nil b = nil @@ -541,7 +880,7 @@ func TestNULL(t *testing.T) { dbt.Fatal(err) } if b != nil { - dbt.Error("Non-nil echo from nil input") + dbt.Error("non-nil echo from nil input") } // Check input==output with input!=nil b = []byte("") @@ -570,6 +909,49 @@ func TestNULL(t *testing.T) { }) } +func TestUint64(t *testing.T) { + const ( + u0 = uint64(0) + uall = ^u0 + uhigh = uall >> 1 + utop = ^uhigh + s0 = int64(0) + sall = ^s0 + shigh = int64(uhigh) + stop = ^shigh + ) + runTests(t, dsn, func(dbt *DBTest) { + stmt, err := dbt.db.Prepare(`SELECT ?, ?, ? ,?, ?, ?, ?, ?`) + if err != nil { + dbt.Fatal(err) + } + defer stmt.Close() + row := stmt.QueryRow( + u0, uhigh, utop, uall, + s0, shigh, stop, sall, + ) + + var ua, ub, uc, ud uint64 + var sa, sb, sc, sd int64 + + err = row.Scan(&ua, &ub, &uc, &ud, &sa, &sb, &sc, &sd) + if err != nil { + dbt.Fatal(err) + } + switch { + case ua != u0, + ub != uhigh, + uc != utop, + ud != uall, + sa != s0, + sb != shigh, + sc != stop, + sd != sall: + dbt.Fatal("unexpected result value") + } + }) +} + func TestLongData(t *testing.T) { runTests(t, dsn, func(dbt *DBTest) { var maxAllowedPacketSize int @@ -660,7 +1042,7 @@ func TestLoadData(t *testing.T) { dbt.Fatalf("%d != %d", i, id) } if values[i-1] != value { - dbt.Fatalf("%s != %s", values[i-1], value) + dbt.Fatalf("%q != %q", values[i-1], value) } } err = rows.Err() @@ -669,7 +1051,7 @@ func TestLoadData(t *testing.T) { } if i != 4 { - dbt.Fatalf("Rows count mismatch. Got %d, want 4", i) + dbt.Fatalf("rows count mismatch. Got %d, want 4", i) } } file, err := ioutil.TempFile("", "gotest") @@ -685,13 +1067,13 @@ func TestLoadData(t *testing.T) { // Local File RegisterLocalFile(file.Name()) - dbt.mustExec(fmt.Sprintf("LOAD DATA LOCAL INFILE '%q' INTO TABLE test", file.Name())) + dbt.mustExec(fmt.Sprintf("LOAD DATA LOCAL INFILE %q INTO TABLE test", file.Name())) verifyLoadDataResult() // negative test _, err = dbt.db.Exec("LOAD DATA LOCAL INFILE 'doesnotexist' INTO TABLE test") if err == nil { - dbt.Fatal("Load non-existent file didn't fail") - } else if err.Error() != "Local File 'doesnotexist' is not registered. Use the DSN parameter 'allowAllFiles=true' to allow all files" { + dbt.Fatal("load non-existent file didn't fail") + } else if err.Error() != "local file 'doesnotexist' is not registered" { dbt.Fatal(err.Error()) } @@ -711,7 +1093,7 @@ func TestLoadData(t *testing.T) { // negative test _, err = dbt.db.Exec("LOAD DATA LOCAL INFILE 'Reader::doesnotexist' INTO TABLE test") if err == nil { - dbt.Fatal("Load non-existent Reader didn't fail") + dbt.Fatal("load non-existent Reader didn't fail") } else if err.Error() != "Reader 'doesnotexist' is not registered" { dbt.Fatal(err.Error()) } @@ -765,7 +1147,18 @@ func TestFoundRows(t *testing.T) { func TestStrict(t *testing.T) { // ALLOW_INVALID_DATES to get rid of stricter modes - we want to test for warnings, not errors - relaxedDsn := dsn + "&sql_mode=ALLOW_INVALID_DATES" + relaxedDsn := dsn + "&sql_mode='ALLOW_INVALID_DATES,NO_AUTO_CREATE_USER'" + // make sure the MySQL version is recent enough with a separate connection + // before running the test + conn, err := MySQLDriver{}.Open(relaxedDsn) + if conn != nil { + conn.Close() + } + if me, ok := err.(*MySQLError); ok && me.Number == 1231 { + // Error 1231: Variable 'sql_mode' can't be set to the value of 'ALLOW_INVALID_DATES' + // => skip test, MySQL server version is too old + return + } runTests(t, relaxedDsn, func(dbt *DBTest) { dbt.mustExec("CREATE TABLE test (a TINYINT NOT NULL, b CHAR(4))") @@ -780,7 +1173,7 @@ func TestStrict(t *testing.T) { var checkWarnings = func(err error, mode string, idx int) { if err == nil { - dbt.Errorf("Expected STRICT error on query [%s] %s", mode, queries[idx].in) + dbt.Errorf("expected STRICT error on query [%s] %s", mode, queries[idx].in) } if warnings, ok := err.(MySQLWarnings); ok { @@ -789,18 +1182,18 @@ func TestStrict(t *testing.T) { codes[i] = warnings[i].Code } if len(codes) != len(queries[idx].codes) { - dbt.Errorf("Unexpected STRICT error count on query [%s] %s: Wanted %v, Got %v", mode, queries[idx].in, queries[idx].codes, codes) + dbt.Errorf("unexpected STRICT error count on query [%s] %s: Wanted %v, Got %v", mode, queries[idx].in, queries[idx].codes, codes) } for i := range warnings { if codes[i] != queries[idx].codes[i] { - dbt.Errorf("Unexpected STRICT error codes on query [%s] %s: Wanted %v, Got %v", mode, queries[idx].in, queries[idx].codes, codes) + dbt.Errorf("unexpected STRICT error codes on query [%s] %s: Wanted %v, Got %v", mode, queries[idx].in, queries[idx].codes, codes) return } } } else { - dbt.Errorf("Unexpected error on query [%s] %s: %s", mode, queries[idx].in, err.Error()) + dbt.Errorf("unexpected error on query [%s] %s: %s", mode, queries[idx].in, err.Error()) } } @@ -816,7 +1209,7 @@ func TestStrict(t *testing.T) { for i := range queries { stmt, err = dbt.db.Prepare(queries[i].in) if err != nil { - dbt.Errorf("Error on preparing query %s: %s", queries[i].in, err.Error()) + dbt.Errorf("error on preparing query %s: %s", queries[i].in, err.Error()) } _, err = stmt.Exec() @@ -824,7 +1217,7 @@ func TestStrict(t *testing.T) { err = stmt.Close() if err != nil { - dbt.Errorf("Error on closing stmt for query %s: %s", queries[i].in, err.Error()) + dbt.Errorf("error on closing stmt for query %s: %s", queries[i].in, err.Error()) } } }) @@ -834,9 +1227,9 @@ func TestTLS(t *testing.T) { tlsTest := func(dbt *DBTest) { if err := dbt.db.Ping(); err != nil { if err == ErrNoTLS { - dbt.Skip("Server does not support TLS") + dbt.Skip("server does not support TLS") } else { - dbt.Fatalf("Error on Ping: %s", err.Error()) + dbt.Fatalf("error on Ping: %s", err.Error()) } } @@ -849,7 +1242,7 @@ func TestTLS(t *testing.T) { } if value == nil { - dbt.Fatal("No Cipher") + dbt.Fatal("no Cipher") } } } @@ -866,42 +1259,42 @@ func TestTLS(t *testing.T) { func TestReuseClosedConnection(t *testing.T) { // this test does not use sql.database, it uses the driver directly if !available { - t.Skipf("MySQL-Server not running on %s", netAddr) + t.Skipf("MySQL server not running on %s", netAddr) } md := &MySQLDriver{} conn, err := md.Open(dsn) if err != nil { - t.Fatalf("Error connecting: %s", err.Error()) + t.Fatalf("error connecting: %s", err.Error()) } stmt, err := conn.Prepare("DO 1") if err != nil { - t.Fatalf("Error preparing statement: %s", err.Error()) + t.Fatalf("error preparing statement: %s", err.Error()) } _, err = stmt.Exec(nil) if err != nil { - t.Fatalf("Error executing statement: %s", err.Error()) + t.Fatalf("error executing statement: %s", err.Error()) } err = conn.Close() if err != nil { - t.Fatalf("Error closing connection: %s", err.Error()) + t.Fatalf("error closing connection: %s", err.Error()) } defer func() { if err := recover(); err != nil { - t.Errorf("Panic after reusing a closed connection: %v", err) + t.Errorf("panic after reusing a closed connection: %v", err) } }() _, err = stmt.Exec(nil) if err != nil && err != driver.ErrBadConn { - t.Errorf("Unexpected error '%s', expected '%s'", + t.Errorf("unexpected error '%s', expected '%s'", err.Error(), driver.ErrBadConn.Error()) } } func TestCharset(t *testing.T) { if !available { - t.Skipf("MySQL-Server not running on %s", netAddr) + t.Skipf("MySQL server not running on %s", netAddr) } mustSetCharset := func(charsetParam, expected string) { @@ -910,14 +1303,14 @@ func TestCharset(t *testing.T) { defer rows.Close() if !rows.Next() { - dbt.Fatalf("Error getting connection charset: %s", rows.Err()) + dbt.Fatalf("error getting connection charset: %s", rows.Err()) } var got string rows.Scan(&got) if got != expected { - dbt.Fatalf("Expected connection charset %s but got %s", expected, got) + dbt.Fatalf("expected connection charset %s but got %s", expected, got) } }) } @@ -939,14 +1332,14 @@ func TestFailingCharset(t *testing.T) { _, err := dbt.db.Exec("SELECT 1") if err == nil { dbt.db.Close() - t.Fatalf("Connection must not succeed without a valid charset") + t.Fatalf("connection must not succeed without a valid charset") } }) } func TestCollation(t *testing.T) { if !available { - t.Skipf("MySQL-Server not running on %s", netAddr) + t.Skipf("MySQL server not running on %s", netAddr) } defaultCollation := "utf8_general_ci" @@ -956,7 +1349,7 @@ func TestCollation(t *testing.T) { "latin1_general_ci", "binary", "utf8_unicode_ci", - "utf8mb4_general_ci", + "cp1257_bin", } for _, collation := range testCollations { @@ -976,12 +1369,36 @@ func TestCollation(t *testing.T) { } if got != expected { - dbt.Fatalf("Expected connection collation %s but got %s", expected, got) + dbt.Fatalf("expected connection collation %s but got %s", expected, got) } }) } } +func TestColumnsWithAlias(t *testing.T) { + runTests(t, dsn+"&columnsWithAlias=true", func(dbt *DBTest) { + rows := dbt.mustQuery("SELECT 1 AS A") + defer rows.Close() + cols, _ := rows.Columns() + if len(cols) != 1 { + t.Fatalf("expected 1 column, got %d", len(cols)) + } + if cols[0] != "A" { + t.Fatalf("expected column name \"A\", got \"%s\"", cols[0]) + } + rows.Close() + + rows = dbt.mustQuery("SELECT * FROM (SELECT 1 AS one) AS A") + cols, _ = rows.Columns() + if len(cols) != 1 { + t.Fatalf("expected 1 column, got %d", len(cols)) + } + if cols[0] != "A.one" { + t.Fatalf("expected column name \"A.one\", got \"%s\"", cols[0]) + } + }) +} + func TestRawBytesResultExceedsBuffer(t *testing.T) { runTests(t, dsn, func(dbt *DBTest) { // defaultBufSize from buffer.go @@ -1011,26 +1428,26 @@ func TestTimezoneConversion(t *testing.T) { // Insert local time into database (should be converted) usCentral, _ := time.LoadLocation("US/Central") - now := time.Now().In(usCentral) - dbt.mustExec("INSERT INTO test VALUE (?)", now) + reftime := time.Date(2014, 05, 30, 18, 03, 17, 0, time.UTC).In(usCentral) + dbt.mustExec("INSERT INTO test VALUE (?)", reftime) // Retrieve time from DB rows := dbt.mustQuery("SELECT ts FROM test") if !rows.Next() { - dbt.Fatal("Didn't get any rows out") + dbt.Fatal("did not get any rows out") } - var nowDB time.Time - err := rows.Scan(&nowDB) + var dbTime time.Time + err := rows.Scan(&dbTime) if err != nil { dbt.Fatal("Err", err) } // Check that dates match - if now.Unix() != nowDB.Unix() { - dbt.Errorf("Times don't match.\n") - dbt.Errorf(" Now(%v)=%v\n", usCentral, now) - dbt.Errorf(" Now(UTC)=%v\n", nowDB) + if reftime.Unix() != dbTime.Unix() { + dbt.Errorf("times do not match.\n") + dbt.Errorf(" Now(%v)=%v\n", usCentral, reftime) + dbt.Errorf(" Now(UTC)=%v\n", dbTime) } } @@ -1039,42 +1456,6 @@ func TestTimezoneConversion(t *testing.T) { } } -// This tests for https://github.com/go-sql-driver/mysql/pull/139 -// -// An extra (invisible) nil byte was being added to the beginning of positive -// time strings. -func TestTimeSign(t *testing.T) { - runTests(t, dsn, func(dbt *DBTest) { - var sTimes = []struct { - value string - fieldType string - }{ - {"12:34:56", "TIME"}, - {"-12:34:56", "TIME"}, - // As described in http://dev.mysql.com/doc/refman/5.6/en/fractional-seconds.html - // they *should* work, but only in 5.6+. - // { "12:34:56.789", "TIME(3)" }, - // { "-12:34:56.789", "TIME(3)" }, - } - - for _, sTime := range sTimes { - dbt.db.Exec("DROP TABLE IF EXISTS test") - dbt.mustExec("CREATE TABLE test (id INT, time_field " + sTime.fieldType + ")") - dbt.mustExec("INSERT INTO test (id, time_field) VALUES(1, '" + sTime.value + "')") - rows := dbt.mustQuery("SELECT time_field FROM test WHERE id = ?", 1) - if rows.Next() { - var oTime string - rows.Scan(&oTime) - if oTime != sTime.value { - dbt.Errorf(`time values differ: got %q, expected %q.`, oTime, sTime.value) - } - } else { - dbt.Error("expecting at least one row.") - } - } - }) -} - // Special cases func TestRowsClose(t *testing.T) { @@ -1090,7 +1471,7 @@ func TestRowsClose(t *testing.T) { } if rows.Next() { - dbt.Fatal("Unexpected row after rows.Close()") + dbt.Fatal("unexpected row after rows.Close()") } err = rows.Err() @@ -1122,7 +1503,7 @@ func TestCloseStmtBeforeRows(t *testing.T) { } if !rows.Next() { - dbt.Fatal("Getting row failed") + dbt.Fatal("getting row failed") } else { err = rows.Err() if err != nil { @@ -1132,7 +1513,7 @@ func TestCloseStmtBeforeRows(t *testing.T) { var out bool err = rows.Scan(&out) if err != nil { - dbt.Fatalf("Error on rows.Scan(): %s", err.Error()) + dbt.Fatalf("error on rows.Scan(): %s", err.Error()) } if out != true { dbt.Errorf("true != %t", out) @@ -1168,7 +1549,7 @@ func TestStmtMultiRows(t *testing.T) { // 1 if !rows1.Next() { - dbt.Fatal("1st rows1.Next failed") + dbt.Fatal("first rows1.Next failed") } else { err = rows1.Err() if err != nil { @@ -1177,7 +1558,7 @@ func TestStmtMultiRows(t *testing.T) { err = rows1.Scan(&out) if err != nil { - dbt.Fatalf("Error on rows.Scan(): %s", err.Error()) + dbt.Fatalf("error on rows.Scan(): %s", err.Error()) } if out != true { dbt.Errorf("true != %t", out) @@ -1185,7 +1566,7 @@ func TestStmtMultiRows(t *testing.T) { } if !rows2.Next() { - dbt.Fatal("1st rows2.Next failed") + dbt.Fatal("first rows2.Next failed") } else { err = rows2.Err() if err != nil { @@ -1194,7 +1575,7 @@ func TestStmtMultiRows(t *testing.T) { err = rows2.Scan(&out) if err != nil { - dbt.Fatalf("Error on rows.Scan(): %s", err.Error()) + dbt.Fatalf("error on rows.Scan(): %s", err.Error()) } if out != true { dbt.Errorf("true != %t", out) @@ -1203,7 +1584,7 @@ func TestStmtMultiRows(t *testing.T) { // 2 if !rows1.Next() { - dbt.Fatal("2nd rows1.Next failed") + dbt.Fatal("second rows1.Next failed") } else { err = rows1.Err() if err != nil { @@ -1212,14 +1593,14 @@ func TestStmtMultiRows(t *testing.T) { err = rows1.Scan(&out) if err != nil { - dbt.Fatalf("Error on rows.Scan(): %s", err.Error()) + dbt.Fatalf("error on rows.Scan(): %s", err.Error()) } if out != false { dbt.Errorf("false != %t", out) } if rows1.Next() { - dbt.Fatal("Unexpected row on rows1") + dbt.Fatal("unexpected row on rows1") } err = rows1.Close() if err != nil { @@ -1228,7 +1609,7 @@ func TestStmtMultiRows(t *testing.T) { } if !rows2.Next() { - dbt.Fatal("2nd rows2.Next failed") + dbt.Fatal("second rows2.Next failed") } else { err = rows2.Err() if err != nil { @@ -1237,14 +1618,14 @@ func TestStmtMultiRows(t *testing.T) { err = rows2.Scan(&out) if err != nil { - dbt.Fatalf("Error on rows.Scan(): %s", err.Error()) + dbt.Fatalf("error on rows.Scan(): %s", err.Error()) } if out != false { dbt.Errorf("false != %t", out) } if rows2.Next() { - dbt.Fatal("Unexpected row on rows2") + dbt.Fatal("unexpected row on rows2") } err = rows2.Close() if err != nil { @@ -1289,7 +1670,7 @@ func TestConcurrent(t *testing.T) { if err != nil { dbt.Fatalf("%s", err.Error()) } - dbt.Logf("Testing up to %d concurrent connections \r\n", max) + dbt.Logf("testing up to %d concurrent connections \r\n", max) var remaining, succeeded int32 = int32(max), 0 @@ -1313,7 +1694,7 @@ func TestConcurrent(t *testing.T) { if err != nil { if err.Error() != "Error 1040: Too many connections" { - fatalf("Error on Conn %d: %s", id, err.Error()) + fatalf("error on conn %d: %s", id, err.Error()) } return } @@ -1321,13 +1702,13 @@ func TestConcurrent(t *testing.T) { // keep the connection busy until all connections are open for remaining > 0 { if _, err = tx.Exec("DO 1"); err != nil { - fatalf("Error on Conn %d: %s", id, err.Error()) + fatalf("error on conn %d: %s", id, err.Error()) return } } if err = tx.Commit(); err != nil { - fatalf("Error on Conn %d: %s", id, err.Error()) + fatalf("error on conn %d: %s", id, err.Error()) return } @@ -1343,14 +1724,14 @@ func TestConcurrent(t *testing.T) { dbt.Fatal(fatalError) } - dbt.Logf("Reached %d concurrent connections\r\n", succeeded) + dbt.Logf("reached %d concurrent connections\r\n", succeeded) }) } // Tests custom dial functions func TestCustomDial(t *testing.T) { if !available { - t.Skipf("MySQL-Server not running on %s", netAddr) + t.Skipf("MySQL server not running on %s", netAddr) } // our custom dial function which justs wraps net.Dial here @@ -1360,11 +1741,164 @@ func TestCustomDial(t *testing.T) { db, err := sql.Open("mysql", fmt.Sprintf("%s:%s@mydial(%s)/%s?timeout=30s&strict=true", user, pass, addr, dbname)) if err != nil { - t.Fatalf("Error connecting: %s", err.Error()) + t.Fatalf("error connecting: %s", err.Error()) } defer db.Close() if _, err = db.Exec("DO 1"); err != nil { - t.Fatalf("Connection failed: %s", err.Error()) + t.Fatalf("connection failed: %s", err.Error()) + } +} + +func TestSQLInjection(t *testing.T) { + createTest := func(arg string) func(dbt *DBTest) { + return func(dbt *DBTest) { + dbt.mustExec("CREATE TABLE test (v INTEGER)") + dbt.mustExec("INSERT INTO test VALUES (?)", 1) + + var v int + // NULL can't be equal to anything, the idea here is to inject query so it returns row + // This test verifies that escapeQuotes and escapeBackslash are working properly + err := dbt.db.QueryRow("SELECT v FROM test WHERE NULL = ?", arg).Scan(&v) + if err == sql.ErrNoRows { + return // success, sql injection failed + } else if err == nil { + dbt.Errorf("sql injection successful with arg: %s", arg) + } else { + dbt.Errorf("error running query with arg: %s; err: %s", arg, err.Error()) + } + } + } + + dsns := []string{ + dsn, + dsn + "&sql_mode='NO_BACKSLASH_ESCAPES,NO_AUTO_CREATE_USER'", + } + for _, testdsn := range dsns { + runTests(t, testdsn, createTest("1 OR 1=1")) + runTests(t, testdsn, createTest("' OR '1'='1")) + } +} + +// Test if inserted data is correctly retrieved after being escaped +func TestInsertRetrieveEscapedData(t *testing.T) { + testData := func(dbt *DBTest) { + dbt.mustExec("CREATE TABLE test (v VARCHAR(255))") + + // All sequences that are escaped by escapeQuotes and escapeBackslash + v := "foo \x00\n\r\x1a\"'\\" + dbt.mustExec("INSERT INTO test VALUES (?)", v) + + var out string + err := dbt.db.QueryRow("SELECT v FROM test").Scan(&out) + if err != nil { + dbt.Fatalf("%s", err.Error()) + } + + if out != v { + dbt.Errorf("%q != %q", out, v) + } + } + + dsns := []string{ + dsn, + dsn + "&sql_mode='NO_BACKSLASH_ESCAPES,NO_AUTO_CREATE_USER'", } + for _, testdsn := range dsns { + runTests(t, testdsn, testData) + } +} + +func TestUnixSocketAuthFail(t *testing.T) { + runTests(t, dsn, func(dbt *DBTest) { + // Save the current logger so we can restore it. + oldLogger := errLog + + // Set a new logger so we can capture its output. + buffer := bytes.NewBuffer(make([]byte, 0, 64)) + newLogger := log.New(buffer, "prefix: ", 0) + SetLogger(newLogger) + + // Restore the logger. + defer SetLogger(oldLogger) + + // Make a new DSN that uses the MySQL socket file and a bad password, which + // we can make by simply appending any character to the real password. + badPass := pass + "x" + socket := "" + if prot == "unix" { + socket = addr + } else { + // Get socket file from MySQL. + err := dbt.db.QueryRow("SELECT @@socket").Scan(&socket) + if err != nil { + t.Fatalf("error on SELECT @@socket: %s", err.Error()) + } + } + t.Logf("socket: %s", socket) + badDSN := fmt.Sprintf("%s:%s@unix(%s)/%s?timeout=30s&strict=true", user, badPass, socket, dbname) + db, err := sql.Open("mysql", badDSN) + if err != nil { + t.Fatalf("error connecting: %s", err.Error()) + } + defer db.Close() + + // Connect to MySQL for real. This will cause an auth failure. + err = db.Ping() + if err == nil { + t.Error("expected Ping() to return an error") + } + + // The driver should not log anything. + if actual := buffer.String(); actual != "" { + t.Errorf("expected no output, got %q", actual) + } + }) +} + +// See Issue #422 +func TestInterruptBySignal(t *testing.T) { + runTestsWithMultiStatement(t, dsn, func(dbt *DBTest) { + dbt.mustExec(` + DROP PROCEDURE IF EXISTS test_signal; + CREATE PROCEDURE test_signal(ret INT) + BEGIN + SELECT ret; + SIGNAL SQLSTATE + '45001' + SET + MESSAGE_TEXT = "an error", + MYSQL_ERRNO = 45001; + END + `) + defer dbt.mustExec("DROP PROCEDURE test_signal") + + var val int + + // text protocol + rows, err := dbt.db.Query("CALL test_signal(42)") + if err != nil { + dbt.Fatalf("error on text query: %s", err.Error()) + } + for rows.Next() { + if err := rows.Scan(&val); err != nil { + dbt.Error(err) + } else if val != 42 { + dbt.Errorf("expected val to be 42") + } + } + + // binary protocol + rows, err = dbt.db.Query("CALL test_signal(?)", 42) + if err != nil { + dbt.Fatalf("error on binary query: %s", err.Error()) + } + for rows.Next() { + if err := rows.Scan(&val); err != nil { + dbt.Error(err) + } else if val != 42 { + dbt.Errorf("expected val to be 42") + } + } + }) } |