func (s *Statement) RunParams(params []interface{}) (e error) {
	return s.run(params)
}
RunParams is shorthand for Bind() + Step() + Reset(). Bind the values, execute the
statement, ignoring the rows it returns, and resets it

See http://kripken.github.io/sql.js/documentation/class/Statement.html#run-dynamic
package bindings
import (
	"bytes"
	"errors"
	"io"
	"github.com/gopherjs/gopherjs/js"
)
type Database struct {
	*js.Object
}
type Statement struct {
	*js.Object
}
func New() *Database {
	return &Database{js.Global.Get("SQL").Get("Database").New()}
}
func OpenReader(r io.Reader) *Database {
	buf := new(bytes.Buffer)
	buf.ReadFrom(r)
	db := js.Global.Get("SQL").Get("Database").New([]uint8(buf.Bytes()))
	return &Database{db}
}
func captureError(fn func()) (e error) {
	defer func() {
		if r := recover(); r != nil {
			switch r.(type) {
			case *js.Error:
				e = r.(*js.Error)
			case error:
				e = r.(error)
			}
		}
	}()
	fn()
	return nil
}
func (d *Database) Run(query string) (e error) {
	return captureError(func() {
		d.Call("run", query)
	})
}
func (d *Database) RunParams(query string, params []interface{}) (e error) {
	return captureError(func() {
		d.Call("run", query, params)
	})
}
func (d *Database) Export() io.Reader {
	array := d.Call("export").Interface()
	return bytes.NewReader([]byte(array.([]uint8)))
}
func (d *Database) Close() (e error) {
	return captureError(func() {
		d.Call("close")
	})
}
func (d *Database) prepare(query string, params interface{}) (*Statement, error) {
	var s *js.Object
	err := captureError(func() {
		s = d.Call("prepare", query, params)
	})
	return &Statement{s}, err
}
func (d *Database) Prepare(query string) (s *Statement, e error) {
	return d.prepare(query, nil)
}
func (d *Database) PrepareParams(query string, params []interface{}) (s *Statement, e error) {
	return d.prepare(query, params)
}
func (d *Database) PrepareNamedParams(query string, params map[string]interface{}) (s *Statement, e error) {
	return d.prepare(query, params)
}
func (d *Database) GetRowsModified() int64 {
	return d.Call("getRowsModified").Int64()
}
type Result struct {
	Columns []string
	Values  [][]interface{}
}
func (d *Database) Exec(query string) (r []Result, e error) {
	var result *js.Object
	e = captureError(func() {
		result = d.Call("exec", query)
	})
	if e != nil {
		return
	}
	r = make([]Result, result.Length())
	for i := 0; i < result.Length(); i++ {
		cols := result.Index(i).Get("columns")
		rows := result.Index(i).Get("values")
		r[i].Columns = make([]string, cols.Length())
		for j := 0; j < cols.Length(); j++ {
			r[i].Columns[j] = cols.Index(j).String()
		}
		r[i].Values = make([][]interface{}, rows.Length())
		for j := 0; j < rows.Length(); j++ {
			vals := rows.Index(j)
			r[i].Values[j] = make([]interface{}, vals.Length())
			for k := 0; k < vals.Length(); k++ {
				r[i].Values[j][k] = vals.Index(k).Interface()
			}
		}
	}
	return r, nil
}
func (s *Statement) Step() (ok bool, e error) {
	err := captureError(func() {
		ok = s.Call("step").Bool()
	})
	return ok, err
}
func (s *Statement) get(params interface{}) (r []interface{}, e error) {
	err := captureError(func() {
		results := s.Call("get", params)
		r = make([]interface{}, results.Length())
		for i := 0; i < results.Length(); i++ {
			r[i] = results.Index(i).Interface()
		}
	})
	return r, err
}
func (s *Statement) Get() (r []interface{}, e error) {
	return s.get(nil)
}
func (s *Statement) GetParams(params []interface{}) (r []interface{}, e error) {
	return s.get(params)
}
func (s *Statement) GetNamedParams(params map[string]interface{}) (r []interface{}, e error) {
	return s.get(params)
}
func (s *Statement) GetColumnNames() (c []string, e error) {
	cols := s.Call("getColumnNames")
	c = make([]string, cols.Length())
	for i := 0; i < cols.Length(); i++ {
		c[i] = cols.Index(i).String()
	}
	return c, nil
}
func (s *Statement) bind(params interface{}) (e error) {
	var tf bool
	err := captureError(func() {
		tf = s.Call("bind", params).Bool()
	})
	if err != nil {
		return err
	}
	if !tf {
		return errors.New("Unknown error binding parameters")
	}
	return nil
}
func (s *Statement) Bind(params []interface{}) (e error) {
	return s.bind(params)
}
func (s *Statement) BindNamed(params map[string]interface{}) (e error) {
	return s.bind(params)
}
func (s *Statement) Reset() {
	s.Call("reset")
}
func (s *Statement) Freemem() {
	s.Call("freemem")
}
func (s *Statement) Free() bool {
	return s.Call("free").Bool()
}
func (s *Statement) getAsMap(params interface{}) (m map[string]interface{}, e error) {
	err := captureError(func() {
		o := s.Call("getAsObject", params)
		m = make(map[string]interface{}, o.Length())
		for _, key := range js.Keys(o) {
			m[key] = o.Get(key).Interface()
		}
	})
	return m, err
}
func (s *Statement) GetAsMap() (m map[string]interface{}, e error) {
	return s.getAsMap(nil)
}
func (s *Statement) GetAsMapParams(params []interface{}) (m map[string]interface{}, e error) {
	return s.getAsMap(params)
}
func (s *Statement) GetAsMapNamedParams(params map[string]interface{}) (m map[string]interface{}, e error) {
	return s.getAsMap(params)
}
func (s *Statement) run(params interface{}) (e error) {
	return captureError(func() {
		s.Call("run", params)
	})
}
func (s *Statement) Run() (e error) {
	return s.run(nil)
}