mymysql

$ go get github.com/ziutek/mymysql/thrsafe
$ go get github.com/ziutek/mymysql/autorc
$ go get github.com/ziutek/mymysql/godrv

$ go get -v github.com/ziutek/mymysql/...

mysql> create database test;
mysql> grant all privileges on test.* to testuser@localhost;
mysql> set password for testuser@localhost = password("TestPasswd9");

$ cd $GOPATH/src/github.com/ziutek/mymysql
$ ./all.bash test

package main

import (
	"os"
	"github.com/ziutek/mymysql/mysql"
	_ "github.com/ziutek/mymysql/native" // Native engine
	// _ "github.com/ziutek/mymysql/thrsafe" // Thread safe engine
)

func main() {
	db := mysql.New("tcp", "", "127.0.0.1:3306", user, pass, dbname)

	err := db.Connect()
	if err != nil {
		panic(err)
	}

	rows, res, err := db.Query("select * from X where id > %d", 20)
	if err != nil {
		panic(err)
	}

	for _, row := range rows {
		for _, col := range row {
			if col == nil {
				// col has NULL value
			} else {
				// Do something with text in col (type []byte)
			}
		}
		// You can get specific value from a row
		val1 := row[1].([]byte)

		// You can use it directly if conversion isn't needed
		os.Stdout.Write(val1)

		// You can get converted value
		number := row.Int(0)      // Zero value
		str    := row.Str(1)      // First value
		bignum := row.MustUint(2) // Second value

		// You may get values by column name
		first := res.Map("FirstColumn")
		second := res.Map("SecondColumn")
		val1, val2 := row.Int(first), row.Str(second)
	}
}

res, err := db.Start("select * from X")
checkError(err)

// Print fields names
for _, field := range res.Fields() {
	fmt.Print(field.Name, " ")
}
fmt.Println()

// Print all rows
for {
	row, err := res.GetRow()
		checkError(err)

		if row == nil {
			// No more rows
			break
		}

	// Print all cols
	for _, col := range row {
		if col == nil {
			fmt.Print("")
		} else {
			os.Stdout.Write(col.([]byte))
		}
		fmt.Print(" ")
	}
	fmt.Println()
}

// Print all rows
row := res.MakeRow()
for {
	err := res.ScanRow(row)
	if err == io.EOF {
		 // No more rows
		 break
	}
	checkError(err)

	// Print all cols
	// [...]
}

stmt, err := db.Prepare("insert into X values (?, ?)")
checkError(err)

type Data struct {
	Id  int
	Tax *float32 // nil means NULL
}

data = new(Data)

for {
	err := getData(data)
	if err == endOfData {
		 break       
	}
	checkError(err)

	_, err = stmt.Run(data.Id, data.Tax)
	checkError(err)
}

stmt.Bind(data.Id, data.Tax)

stmt.Bind(&data.Id, &data.Tax)

stmt.Bind(data)

data = new(Data)
stmt.Bind(data)

for {
	err := getData(data)
	if isEndOfData(error) {
		 break       
	}
	checkError(err)

	_, err = stmt.Run()
	checkError(err)
}

_, err = db.Start("CREATE TABLE web (url VARCHAR(80), content LONGBLOB)")
checkError(err)

ins, err := db.Prepare("INSERT INTO web VALUES (?, ?)")
checkError(err)

var url string

ins.Bind(&url, []byte(nil)) // []byte(nil) for properly type binding

for  {
	// Read URL from stdin
	url = ""
	fmt.Scanln(&url)
	if len(url) == 0 {
		// Stop reading if URL is blank line
		break
	}

	// Make a connection
	resp, err := http.Get(url)
	checkError(err)

	// We can retrieve response directly into database because 
	// the resp.Body implements io.Reader. Use 8 kB buffer.
	err = ins.SendLongData(1, resp.Body, 8192)
	checkError(err)

	// Execute insert statement
	_, err = ins.Run()
	checkError(err)
}

res, err := db.Start("select id from M; select name from M")
checkError(err)

// Get result from first select
for {
	row, err := res.GetRow()
	checkError(err)
	if row == nil {
		// End of first result
		break
	}

	// Do something with with the data
	functionThatUseId(row.Int(0))
}

// Get result from second select
res, err = res.NextResult()
checkError(err)
if res == nil {
	panic("Hmm, there is no result. Why?!")
}
for {
	row, err := res.GetRow()
	checkError(err)
	if row == nil {
		// End of second result
		break
	}

	// Do something with with the data
	functionThatUseName(row.Str(0))
}

import (
	"github.com/ziutek/mymysql/mysql"
	_ "github.com/ziutek/mymysql/thrsafe" // for thread safe transactions
)
// [...]

// Statement prepared before transaction begins
ins, err := db.Prepare("insert A values (?, ?)")
checkError(err)

// Begin a new transaction
tr, err := db.Begin()
checkError(err)

// Now db is locked, so any method that uses db and sends commands to
// MySQL server will be blocked until Commit or Rollback is called.

// Commands in transaction are thread safe to
go func() {
	_, err = tr.Start("insert A values (1, 'jeden')")
	checkError(err)
} ()
_, err = tr.Start("insert A values (2, 'dwa')")
checkError(err)

// You can't use statements prepared before transaction in the usual way,
// because the connection is locked by the Begin method. You must bind the statement
// to the transaction before using it.
_, err = tr.Do(ins).Run(3, "three")
checkError(err)

// For a greater number of calls
ti := tr.Do(ins)
_, err = ti.Run(4, "four")
checkError(err)
_, err = ti.Run(5, "five")
checkError(err)

// At the end you can Commit or Rollback. tr is invalidated and using it
// after Commit/Rollback will cause a panic.
tr.Commit()

import (
	"github.com/ziutek/mymysql/autorc"
	_ "github.com/ziutek/mymysql/thrsafe" // You may also use the native engine
)

// [...]

db := autorc.New("tcp", "", "127.0.0.1:3306", user, pass, dbname)

// Initilisation commands. They will be executed after each connect.
db.Register("set names utf8")

// There is no need to explicitly connect to the MySQL server
rows, res, err := db.Query("SELECT * FROM R")
checkError(err)

// Now we are connected.

// It does not matter if connection will be interrupted during sleep, eg
// due to server reboot or network down.
time.Sleep(9e9)

// If we can reconnect in no more than db.MaxRetries attempts this
// statement will be prepared.
sel, err := db.Prepare("SELECT name FROM R where id > ?")
checkError(err)

// We can destroy our connection server side
_, _, err = db.Query("kill %d", db.Raw.ThreadId())
checkError(err)

// But it doesn't matter
sel.Bind(2)
rows, res, err = sel.Exec()
checkError(err)

import (
    "database/sql"
    _"github.com/ziutek/mymysql/godrv"
)

// [...]

// Open new connection. The UR