Beispiel #1
0
func TestMediumInt(t *testing.T) {
	db, err := sql.Open("mymysql", "test/testuser/TestPasswd9")
	checkErr(t, err)
	defer db.Exec("DROP TABLE mi")
	defer db.Close()

	db.Exec("DROP TABLE mi")

	_, err = db.Exec(
		`CREATE TABLE mi (
			id INT PRIMARY KEY AUTO_INCREMENT,
			m MEDIUMINT
		)`)
	checkErr(t, err)

	const n = 9

	for i := 0; i < n; i++ {
		_, err = db.Exec("INSERT mi VALUES (0, ?)", i)
		checkErr(t, err)
	}

	rows, err := db.Query("SELECT * FROM mi")
	checkErr(t, err)

	var i int
	for i = 0; rows.Next(); i++ {
		var id, m int
		checkErr(t, rows.Scan(&id, &m))
		if id != i+1 || m != i {
			t.Fatalf("i=%d id=%d m=%d", i, id, m)
		}
	}
	checkErr(t, rows.Err())
	if i != n {
		t.Fatalf("%d rows read, %d expected", i, n)
	}
}
Beispiel #2
0
func TestAll(t *testing.T) {
	data := []string{"jeden", "dwa"}

	db, err := sql.Open("mymysql", "test/testuser/TestPasswd9")
	checkErr(t, err)
	defer db.Close()
	defer db.Exec("DROP TABLE go")

	db.Exec("DROP TABLE go")

	_, err = db.Exec(
		`CREATE TABLE go (
			id  INT PRIMARY KEY AUTO_INCREMENT,
			txt TEXT
		) ENGINE=InnoDB`)
	checkErr(t, err)

	ins, err := db.Prepare("INSERT go SET txt=?")
	checkErr(t, err)

	tx, err := db.Begin()
	checkErr(t, err)

	res, err := ins.Exec(data[0])
	checkErr(t, err)
	id, err := res.LastInsertId()
	checkErrId(t, err, id, 1)

	res, err = ins.Exec(data[1])
	checkErr(t, err)
	id, err = res.LastInsertId()
	checkErrId(t, err, id, 2)

	checkErr(t, tx.Commit())

	tx, err = db.Begin()
	checkErr(t, err)

	res, err = tx.Exec("INSERT go SET txt=?", "trzy")
	checkErr(t, err)
	id, err = res.LastInsertId()
	checkErrId(t, err, id, 3)

	checkErr(t, tx.Rollback())

	rows, err := db.Query("SELECT * FROM go")
	checkErr(t, err)
	for rows.Next() {
		var id int
		var txt string
		checkErr(t, rows.Scan(&id, &txt))
		if id > len(data) {
			t.Fatal("To many rows in table")
		}
		if data[id-1] != txt {
			t.Fatalf("txt[%d] == '%s' != '%s'", id, txt, data[id-1])
		}
	}
	checkErr(t, rows.Err())

	sql := "select sum(41) as test"
	row := db.QueryRow(sql)
	var vi int64
	checkErr(t, row.Scan(&vi))
	if vi != 41 {
		t.Fatal(sql)
	}
	sql = "select sum(4123232323232) as test"
	row = db.QueryRow(sql)
	var vf float64
	checkErr(t, row.Scan(&vf))
	if vf != 4123232323232 {
		t.Fatal(sql)
	}
}
Beispiel #3
0
func TestMultiple(t *testing.T) {
	db, err := sql.Open("mymysql", "test/testuser/TestPasswd9")
	checkErr(t, err)
	defer db.Close()
	defer db.Exec("DROP TABLE t")

	db.Exec("DROP TABLE t")
	_, err = db.Exec(`CREATE TABLE t (
		email       VARCHAR(16),
		password    VARCHAR(16),
		status      VARCHAR(16),
		signup_date DATETIME,
		zipcode     VARCHAR(16),
		fname       VARCHAR(16),
		lname       VARCHAR(16)
	)`)
	checkErr(t, err)

	const shortFormat = "2006-01-02 15:04:05"
	now := time.Now()

	_, err = db.Exec(fmt.Sprintf(`INSERT INTO t (
		email,
		password,
		status,
		signup_date,
		zipcode,
		fname,
		lname
	) VALUES (
		'*****@*****.**',
		'asdf',
		'unverified',
		'%s',
		'111',
		'asdf',
		'asdf'
	);`, now.Format(mysql.TimeFormat)))
	checkErr(t, err)

	_, err = db.Exec(`INSERT INTO t (
		email,
		password,
		status,
		signup_date,
		zipcode,
		fname,
	    lname
	) VALUES (
      ?, ?, ?, ?, ?, ?, ?
	);`, "*****@*****.**", "asdf", "unverified", now, "111", "asdf", "asdf")
	checkErr(t, err)

	_, err = db.Exec(`INSERT INTO t (
		email,
		password,
		status,
		signup_date,
		zipcode,
		fname,
	    lname
	) VALUES (
      "*****@*****.**", 'asdf', ?, ?, ?, ?, 'asdf'
	);`, "unverified", now, "111", "asdf")
	checkErr(t, err)

	rows, err := db.Query("SELECT * FROM t")
	checkErr(t, err)
	var (
		email, password, status, zipcode, fname, lname string
		signup_date                                    time.Time
	)
	n := 0
	for rows.Next() {
		checkErr(t, rows.Scan(
			&email, &password, &status, &signup_date, &zipcode, &fname, &lname,
		))
		if email != "*****@*****.**" {
			t.Fatal(n, "email:", email)
		}
		if password != "asdf" {
			t.Fatal(n, "password:"******"unverified" {
			t.Fatal(n, "status:", status)

		}
		e := signup_date.Format(mysql.TimeFormat)
		d := signup_date.Format(mysql.TimeFormat)
		if e[:len(shortFormat)] != d[:len(shortFormat)] {
			t.Fatal(n, "signup_date:", d)
		}
		if zipcode != "111" {
			t.Fatal(n, "zipcode:", zipcode)
		}
		if fname != "asdf" {
			t.Fatal(n, "fname:", fname)
		}
		if lname != "asdf" {
			t.Fatal(n, "lname:", lname)
		}
		n++
	}
	if n != 3 {
		t.Fatal("Too short result set")
	}
}
Beispiel #4
0
func TestTypes(t *testing.T) {
	db, err := sql.Open("mymysql", "test/testuser/TestPasswd9")
	checkErr(t, err)
	defer db.Close()
	defer db.Exec("DROP TABLE t")

	db.Exec("DROP TABLE t")

	_, err = db.Exec(
		`CREATE TABLE t (
			i INT NOT NULL,
			f DOUBLE NOT NULL, 
			b BOOL NOT NULL,
			s VARCHAR(8) NOT NULL,
			d DATETIME NOT NULL,
			y DATE NOT NULL,
			n INT
		) ENGINE=InnoDB`)
	checkErr(t, err)

	_, err = db.Exec(
		`INSERT t VALUES (
			23, 0.25, true, 'test', '2013-03-06 21:07', '2013-03-19', NULL
		)`,
	)
	checkErr(t, err)
	l, err := time.LoadLocation("Local")
	td := time.Date(2013, 3, 6, 21, 7, 0, 0, l)
	dd := time.Date(2013, 3, 19, 0, 0, 0, 0, l)
	checkErr(t, err)
	_, err = db.Exec(
		"INSERT t VALUES (?, ?, ?, ?, ?, ?)",
		23, 0.25, true, "test", td, dd, nil,
	)

	rows, err := db.Query("SELECT * FROM t")
	checkErr(t, err)
	var (
		i int64
		f float64
		b bool
		s string
		d time.Time
		y time.Time
		n sql.NullInt64
	)

	for rows.Next() {
		checkErr(t, rows.Scan(&i, &f, &b, &s, &d, &y, &n))
		if i != 23 {
			t.Fatal("int64", i)
		}
		if f != 0.25 {
			t.Fatal("float64", f)
		}
		if b != true {
			t.Fatal("bool", b)
		}
		if s != "test" {
			t.Fatal("string", s)
		}
		if d != td {
			t.Fatal("time.Time", d)
		}
		if y != dd {
			t.Fatal("time.Time", y)
		}
		if n.Valid {
			t.Fatal("mysql.NullInt64", n)
		}
	}
}