pax_global_header00006660000000000000000000000064123276423340014520gustar00rootroot0000000000000052 comment=0475b64a2b5be0ec5b28f1d638c2927805cbfe60 sqlx-sqlx-v1.0/000077500000000000000000000000001232764233400135225ustar00rootroot00000000000000sqlx-sqlx-v1.0/.gitignore000066400000000000000000000003741232764233400155160ustar00rootroot00000000000000# Compiled Object files, Static and Dynamic libs (Shared Objects) *.o *.a *.so # Folders _obj _test # Architecture specific extensions/prefixes *.[568vq] [568vq].out *.cgo1.go *.cgo2.c _cgo_defun.c _cgo_gotypes.go _cgo_export.* _testmain.go *.exe sqlx-sqlx-v1.0/LICENSE000066400000000000000000000020651232764233400145320ustar00rootroot00000000000000 Copyright (c) 2013, Jason Moiron Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. sqlx-sqlx-v1.0/README.md000066400000000000000000000207751232764233400150140ustar00rootroot00000000000000#sqlx [![Build Status](https://drone.io/github.com/jmoiron/sqlx/status.png)](https://drone.io/github.com/jmoiron/sqlx/latest) sqlx is a library which provides a set of extensions on go's standard `database/sql` library. The sqlx versions of `sql.DB`, `sql.TX`, `sql.Stmt`, et al. all leave the underlying interfaces untouched, so that their interfaces are a superset on the standard ones. This makes it relatively painless to integrate existing codebases using database/sql with sqlx. Major additional concepts are: * Marshal rows into structs (with embedded struct support), maps, and slices * Named parameter support including prepared statements * `Get` and `Select` to go quickly from query to struct/slice * Common error handling mnemonics (eg. `Execf`, `Execp` (`MustExec`), and `Execl`) * `LoadFile` for executing statements from a file There is now some [fairly comprehensive documentation](http://jmoiron.github.io/sqlx/) for sqlx. You can also read the usage below for a quick sample on how sqlx works, or check out the [API documentation on godoc](http://godoc.org/github.com/jmoiron/sqlx). ## install go get github.com/jmoiron/sqlx ## issues Row headers can be ambiguous (`SELECT 1 AS a, 2 AS a`), and the result of `Columns()` can have duplicate names on queries like: ```sql SELECT a.id, a.name, b.id, b.name FROM foos AS a JOIN foos AS b ON a.parent = b.id; ``` making a struct or map destination ambiguous. Use `AS` in your queries to give rows distinct names, `rows.Scan` to scan them manually, or `SliceScan` to get a slice of results. ## usage Below is an example which shows some common use cases for sqlx. Check [sqlx_test.go](https://github.com/jmoiron/sqlx/blob/master/sqlx_test.go) for more usage. ```go package main import ( _ "github.com/lib/pq" "database/sql" "github.com/jmoiron/sqlx" "log" ) var schema = ` CREATE TABLE person ( first_name text, last_name text, email text ); CREATE TABLE place ( country text, city text NULL, telcode integer )` type Person struct { FirstName string `db:"first_name"` LastName string `db:"last_name"` Email string } type Place struct { Country string City sql.NullString TelCode int } func main() { // this connects & tries a simple 'SELECT 1', panics on error // use sqlx.Open() for sql.Open() semantics db, err := sqlx.Connect("postgres", "user=foo dbname=bar sslmode=disable") if err != nil { log.Fatalln(err) } // exec the schema or fail; multi-statement Exec behavior varies between // database drivers; pq will exec them all, sqlite3 won't, ymmv db.Execf(schema) tx := db.MustBegin() tx.Execl("INSERT INTO person (first_name, last_name, email) VALUES ($1, $2, $3)", "Jason", "Moiron", "jmoiron@jmoiron.net") tx.Execl("INSERT INTO person (first_name, last_name, email) VALUES ($1, $2, $3)", "John", "Doe", "johndoeDNE@gmail.net") tx.Execl("INSERT INTO place (country, city, telcode) VALUES ($1, $2, $3)", "United States", "New York", "1") tx.Execl("INSERT INTO place (country, telcode) VALUES ($1, $2)", "Hong Kong", "852") tx.Execl("INSERT INTO place (country, telcode) VALUES ($1, $2)", "Singapore", "65") // Named queries can use structs, so if you have an existing struct (i.e. person := &Person{}) that you have populated, you can pass it in as &person tx.NamedExec("INSERT INTO person (first_name, last_name, email) VALUES (:first_name, :last_name, :email)", &Person{"Jane", "Citizen", "jane.citzen@example.com"}) tx.Commit() // Query the database, storing results in a []Person (wrapped in []interface{}) people := []Person{} db.Select(&people, "SELECT * FROM person ORDER BY first_name ASC") jason, john := people[0], people[1] fmt.Printf("%#v\n%#v", jason, john) // Person{FirstName:"Jason", LastName:"Moiron", Email:"jmoiron@jmoiron.net"} // Person{FirstName:"John", LastName:"Doe", Email:"johndoeDNE@gmail.net"} // You can also get a single result, a la QueryRow jason = Person{} err = db.Get(&jason, "SELECT * FROM person WHERE first_name=$1", "Jason") fmt.Printf("%#v\n", jason) // Person{FirstName:"Jason", LastName:"Moiron", Email:"jmoiron@jmoiron.net"} // if you have null fields and use SELECT *, you must use sql.Null* in your struct places := []Place{} err := db.Select(&places, "SELECT * FROM place ORDER BY telcode ASC") if err != nil { fmt.Printf(err) return } usa, singsing, honkers = places[0], places[1], places[2] fmt.Printf("%#v\n%#v\n%#v\n", usa, singsing, honkers) // Place{Country:"United States", City:sql.NullString{String:"New York", Valid:true}, TelCode:1} // Place{Country:"Singapore", City:sql.NullString{String:"", Valid:false}, TelCode:65} // Place{Country:"Hong Kong", City:sql.NullString{String:"", Valid:false}, TelCode:852} // Loop through rows using only one struct place := Place{} rows, err := db.Queryx("SELECT * FROM place") for rows.Next() { err := rows.StructScan(&place) if err != nil { log.Fataln(err) } fmt.Printf("%#v\n", place) } // Place{Country:"United States", City:sql.NullString{String:"New York", Valid:true}, TelCode:1} // Place{Country:"Hong Kong", City:sql.NullString{String:"", Valid:false}, TelCode:852} // Place{Country:"Singapore", City:sql.NullString{String:"", Valid:false}, TelCode:65} // Named queries, using `:name` as the bindvar. Automatic bindvar support // which takes into account the dbtype based on the driverName on sqlx.Open/Connect _, err = db.NamedExec(`INSERT INTO person (first_name,last_name,email) VALUES (:first,:last,:email)`, map[string]interface{}{ "first": "Bin", "last": "Smuth", "email": "bensmith@allblacks.nz", }) // Selects Mr. Smith from the database rows, err := db.NamedQuery(`SELECT * FROM person WHERE first_name=:fn`, map[string]interface{}{"fn": "Bin"}) // Named queries can also use structs. Their bind names follow the same rules // as the name -> db mapping, so struct fields are lowercased and the `db` tag // is taken into consideration. rows, err := db.NamedQuery(`SELECT * FROM person WHERE first_name=:first_name`, jason) } ``` ## embedded structs Structs which do not implement the [sql.Scanner](http://golang.org/pkg/database/sql/#Scanner) interface will be inspected and their fields used as possible targets for a scan. This includes embedded and non-embedded structs. Go makes '[ambiguous selectors](http://play.golang.org/p/MGRxdjLaUc)' a compile time error, but does not make structs with possible ambiguous selectors errors. Sqlx will decide which field to use on a struct based on a breadth first search of the struct and any structs it contains or embeds, as specified by the order of the fields as accessible by `reflect`, which generally means in source-order. ## scan safety By default, scanning into structs requires the structs to have fields for all of the columns in the query. This was done for a few reasons: * A mistake in naming during development could lead you to believe that data is being written to a field when actually it can't be found and it is being dropped * This behavior mirrors the behavior of the Go compiler with respect to unused variables * Selecting more data than you need is wasteful (more data on the wire, more time marshalling, etc) Unlike Marshallers in the stdlib, the programmer scanning an sql result into a struct will generally have a full understanding of what the underlying data model is *and* full control over the SQL statement. Despite this, there are use cases where it's convenient to be able to ignore unknown columns. In most of these cases, you might be better off with `ScanSlice`, but where you want to still use structs, there is now the `Unsafe` method. Its usage is most simply shown in an example: ```go db, err := sqlx.Connect("postgres", "user=foo dbname=bar sslmode=disable") if err != nil { log.Fatal(err) } type Person { Name string } var p Person // This fails, because there is no destination for location in Person err = db.Get(&p, "SELECT name, location FROM person LIMIT 1") udb := db.Unsafe() // This succeeds and just sets `Name` in the p struct err = udb.Get(&p, "SELECT name, location FROM person LIMIT 1") ``` The `Unsafe` method is implemented on `Tx`, `DB`, and `Stmt`. When you use an unsafe `Tx` or `DB` to create a new `Tx` or `Stmt`, those inherit its lack of safety. sqlx-sqlx-v1.0/bind.go000066400000000000000000000034351232764233400147720ustar00rootroot00000000000000package sqlx import ( "bytes" "strconv" ) // Bindvar types supported by sqlx's Rebind & BindMap/Struct functions. const ( UNKNOWN = iota QUESTION DOLLAR NAMED ) // BindType returns the bindtype for a given database given a drivername func BindType(driverName string) int { switch driverName { case "postgres": return DOLLAR case "mysql": return QUESTION case "sqlite": return QUESTION case "oci8": return NAMED } return UNKNOWN } // FIXME: this should be able to be tolerant of escaped ?'s in queries without // losing much speed, and should be to avoid confusion. // FIXME: this is now produces the wrong results for oracle's NAMED bindtype // Rebind a query from the default bindtype (QUESTION) to the target bindtype func Rebind(bindType int, query string) string { if bindType != DOLLAR { return query } qb := []byte(query) // Add space enough for 10 params before we have to allocate rqb := make([]byte, 0, len(qb)+10) j := 1 for _, b := range qb { if b == '?' { rqb = append(rqb, '$') for _, b := range strconv.Itoa(j) { rqb = append(rqb, byte(b)) } j++ } else { rqb = append(rqb, b) } } return string(rqb) } // Experimental implementation of Rebind which uses a bytes.Buffer. The code is // much simpler and should be more resistant to odd unicode, but it is twice as // slow. Kept here for benchmarking purposes and to possibly replace Rebind if // problems arise with its somewhat naive handling of unicode. func rebindBuff(bindType int, query string) string { if bindType != DOLLAR { return query } b := make([]byte, 0, len(query)) rqb := bytes.NewBuffer(b) j := 1 for _, r := range query { if r == '?' { rqb.WriteRune('$') rqb.WriteString(strconv.Itoa(j)) j++ } else { rqb.WriteRune(r) } } return rqb.String() } sqlx-sqlx-v1.0/doc.go000066400000000000000000000010721232764233400146160ustar00rootroot00000000000000// Package sqlx provides general purpose extensions to database/sql. // // sqlx is intended to seamlessly wrap database/sql and provide convenience // methods which are useful in the development of database driven applications. // None of the underlying database/sql methods are changed, instead all extended // behavior is implemented through new methods defined on wrapper types. // // sqlx adds struct scanning, named queries, query rebinding between drivers, // convenient shorthand for common error handling, from-file query execution, // and more. // package sqlx sqlx-sqlx-v1.0/named.go000066400000000000000000000270171232764233400151440ustar00rootroot00000000000000package sqlx // Named Query Support // // * BindStruct, BindMap - bind query bindvars to map/struct args // * NamedExec, NamedQuery - named query w/ struct or map // * NamedExecMap, NamedQueryMap - named query w/ maps (DEPRECATED) // * NamedStmt - a pre-compiled named query which is a prepared statement // // Internal Interfaces: // // * compileNamedQuery - rebind a named query, returning a query and list of names // * bindArgs, bindMapArgs, bindAnyArgs - given a list of names, return an arglist // * bindAny - call BindStruct or BindMap depending on the type of the argument // import ( "database/sql" "errors" "fmt" "log" "reflect" "strconv" "unicode" ) // NamedStmt is a prepared statement that executes named queries. Prepare it // how you would execute a NamedQuery, but pass in a struct or map when executing. type NamedStmt struct { Params []string QueryString string Stmt *Stmt } // Close closes the named statement. func (n *NamedStmt) Close() error { return n.Stmt.Close() } // Exec executes a named statement using the struct passed. func (n *NamedStmt) Exec(arg interface{}) (sql.Result, error) { args, err := bindAnyArgs(n.Params, arg) if err != nil { return *new(sql.Result), err } return n.Stmt.Exec(args...) } // Query executes a named statement using the struct argument, returning rows. func (n *NamedStmt) Query(arg interface{}) (*sql.Rows, error) { args, err := bindAnyArgs(n.Params, arg) if err != nil { return nil, err } return n.Stmt.Query(args...) } // QueryRow executes a named statement against the database. Because sqlx cannot // create a *sql.Row with an error condition pre-set for binding errors, sqlx // returns a *sqlx.Row instead. func (n *NamedStmt) QueryRow(arg interface{}) *Row { args, err := bindAnyArgs(n.Params, arg) if err != nil { return &Row{err: err} } return n.Stmt.QueryRowx(args...) } // Execv execs a NamedStmt with the given arg, printing errors and returning them func (n *NamedStmt) Execv(arg interface{}) (sql.Result, error) { res, err := n.Exec(arg) if err != nil { log.Println(n.QueryString, res, err) } return res, err } // Execl execs a NamedStmt with the given arg, logging errors func (n *NamedStmt) Execl(arg interface{}) sql.Result { res, err := n.Exec(arg) if err != nil { log.Println(n.QueryString, res, err) } return res } // Execf execs a NamedStmt, using log.fatal to print out errors func (n *NamedStmt) Execf(arg interface{}) sql.Result { res, err := n.Exec(arg) if err != nil { log.Fatal(n.QueryString, res, err) } return res } // Execp execs a NamedStmt, panicing on error func (n *NamedStmt) Execp(arg interface{}) sql.Result { return n.MustExec(arg) } // MustExec execs a NamedStmt, panicing on error func (n *NamedStmt) MustExec(arg interface{}) sql.Result { res, err := n.Exec(arg) if err != nil { panic(err) } return res } // Queryx using this NamedStmt func (n *NamedStmt) Queryx(arg interface{}) (*Rows, error) { r, err := n.Query(arg) if err != nil { return nil, err } return &Rows{Rows: *r}, err } // QueryRowx this NamedStmt. Because of limitations with QueryRow, this is // an alias for QueryRow. func (n *NamedStmt) QueryRowx(arg interface{}) *Row { return n.QueryRow(arg) } // Select using this NamedStmt func (n *NamedStmt) Select(dest interface{}, arg interface{}) error { rows, err := n.Query(arg) if err != nil { return err } // if something happens here, we want to make sure the rows are Closed defer rows.Close() return StructScan(rows, dest) } // Selectv using this NamedStmt func (n *NamedStmt) Selectv(dest interface{}, arg interface{}) error { err := n.Select(dest, arg) if err != nil { log.Println(n.QueryString, err) } return err } // Selectf using this NamedStmt func (n *NamedStmt) Selectf(dest interface{}, arg interface{}) { err := n.Select(dest, arg) if err != nil { log.Fatal(n.QueryString, err) } } // Get using this NamedStmt func (n *NamedStmt) Get(dest interface{}, arg interface{}) error { r := n.QueryRowx(arg) return r.StructScan(dest) } // A union interface of preparer and binder, required to be able to prepare // named statements (as the bindtype must be determined). type namedPreparer interface { Preparer Binder } func prepareNamed(p namedPreparer, query string) (*NamedStmt, error) { bindType := BindType(p.DriverName()) q, args, err := compileNamedQuery([]byte(query), bindType) if err != nil { return nil, err } stmt, err := Preparex(p, q) if err != nil { return nil, err } return &NamedStmt{ QueryString: q, Params: args, Stmt: stmt, }, nil } func bindAnyArgs(names []string, arg interface{}) ([]interface{}, error) { if maparg, ok := arg.(map[string]interface{}); ok { return bindMapArgs(names, maparg) } return bindArgs(names, arg) } // private interface to generate a list of interfaces from a given struct // type, given a list of names to pull out of the struct. Used by public // BindStruct interface. func bindArgs(names []string, arg interface{}) ([]interface{}, error) { arglist := make([]interface{}, 0, len(names)) t, err := BaseStructType(reflect.TypeOf(arg)) if err != nil { return arglist, err } // resolve this arg's type into a map of fields to field positions fm, err := getFieldMap(t) if err != nil { return arglist, err } // grab the indirected value of arg v := reflect.ValueOf(arg) for v = reflect.ValueOf(arg); v.Kind() == reflect.Ptr; { v = v.Elem() } // FIXME: why aren't we using reflect helpers here? values := fm.allValues(v) for _, name := range names { val, ok := fm[name] if !ok { return arglist, fmt.Errorf("could not find name %s in %v", name, arg) } arglist = append(arglist, values[val]) } return arglist, nil } // like bindArgs, but for maps. func bindMapArgs(names []string, arg map[string]interface{}) ([]interface{}, error) { arglist := make([]interface{}, 0, len(names)) for _, name := range names { val, ok := arg[name] if !ok { return arglist, fmt.Errorf("could not find name %s in %v", name, arg) } arglist = append(arglist, val) } return arglist, nil } // BindStruct binds a named parameter query with fields from a struct argument. // The rules for binding field names to parameter names follow the same // conventions as for StructScan, including obeying the `db` struct tags. func BindStruct(bindType int, query string, arg interface{}) (string, []interface{}, error) { bound, names, err := compileNamedQuery([]byte(query), bindType) if err != nil { return "", []interface{}{}, err } arglist, err := bindArgs(names, arg) if err != nil { return "", []interface{}{}, err } return bound, arglist, nil } // BindMap binds a named parameter query with a map of arguments. func BindMap(bindType int, query string, args map[string]interface{}) (string, []interface{}, error) { bound, names, err := compileNamedQuery([]byte(query), bindType) if err != nil { return "", []interface{}{}, err } arglist, err := bindMapArgs(names, args) return bound, arglist, err } // -- Compilation of Named Queries // Allow digits and letters in bind params; additionally runes are // checked against underscores, meaning that bind params can have be // alphanumeric with underscores. Mind the difference between unicode // digits and numbers, where '5' is a digit but '五' is not. var allowedBindRunes = []*unicode.RangeTable{unicode.Letter, unicode.Digit} // FIXME: this function isn't safe for unicode named params, as a failing test // can testify. This is not a regression but a failure of the original code // as well. It should be modified to range over runes in a string rather than // bytes, even though this is less convenient and slower. Hopefully the // addition of the prepared NamedStmt (which will only do this once) will make // up for the slightly slower ad-hoc NamedExec/NamedQuery. // compile a NamedQuery into an unbound query (using the '?' bindvar) and // a list of names. func compileNamedQuery(qs []byte, bindType int) (query string, names []string, err error) { names = make([]string, 0, 10) rebound := make([]byte, 0, len(qs)) inName := false last := len(qs) - 1 currentVar := 1 name := make([]byte, 0, 10) for i, b := range qs { // a ':' while we're in a name is an error if b == ':' && inName { err = errors.New("unexpected `:` while reading named param at " + strconv.Itoa(i)) return query, names, err // if we encounter a ':' and we aren't in a name, it's a new parameter // FIXME: escaping? } else if b == ':' { inName = true name = []byte{} // if we're in a name, and this is an allowed character, continue } else if inName && (unicode.IsOneOf(allowedBindRunes, rune(b)) || b == '_') && i != last { // append the byte to the name if we are in a name and not on the last byte name = append(name, b) // if we're in a name and it's not an allowed character, the name is done } else if inName { inName = false // if this is the final byte of the string and it is part of the name, then // make sure to add it to the name if i == last && unicode.IsOneOf(allowedBindRunes, rune(b)) { name = append(name, b) } // add the string representation to the names list names = append(names, string(name)) // add a proper bindvar for the bindType switch bindType { // oracle only supports named type bind vars even for positional case NAMED: rebound = append(rebound, ':') rebound = append(rebound, name...) case QUESTION, UNKNOWN: rebound = append(rebound, '?') case DOLLAR: rebound = append(rebound, '$') for _, b := range strconv.Itoa(currentVar) { rebound = append(rebound, byte(b)) } currentVar++ } // add this byte to string unless it was not part of the name if i != last { rebound = append(rebound, b) } else if !unicode.IsOneOf(allowedBindRunes, rune(b)) { rebound = append(rebound, b) } } else { // this is a normal byte and should just go onto the rebound query rebound = append(rebound, b) } } return string(rebound), names, err } // bindAny binds a struct or a map by inspecting the arg interface. func bindAny(e Ext, query string, arg interface{}) (string, []interface{}, error) { if maparg, ok := arg.(map[string]interface{}); ok { return e.BindMap(query, maparg) } return e.BindStruct(query, arg) } // NamedQuery binds a named query and then runs Query on the result using the // provided Ext (sqlx.Tx, sqlx.Db). It works with both structs and with // map[string]interface{} types. func NamedQuery(e Ext, query string, arg interface{}) (*Rows, error) { q, args, err := bindAny(e, query, arg) if err != nil { return nil, err } return e.Queryx(q, args...) } // NamedExec uses BindStruct to get a query executable by the driver and // then runs Exec on the result. Returns an error from the binding // or the query excution itself. func NamedExec(e Ext, query string, arg interface{}) (sql.Result, error) { q, args, err := bindAny(e, query, arg) if err != nil { return nil, err } return e.Exec(q, args...) } // NamedQueryMap runs a named query using a map instead of a struct. // DEPRECATED: Use NamedQuery instead, which also supports maps. func NamedQueryMap(e Ext, query string, argmap map[string]interface{}) (*Rows, error) { q, args, err := e.BindMap(query, argmap) if err != nil { return nil, err } return e.Queryx(q, args...) } // NamedExecMap executes a named query using a map instead of a struct. // DEPRECATED: Use NamedExec instead, which also supports maps. func NamedExecMap(e Ext, query string, argmap map[string]interface{}) (sql.Result, error) { q, args, err := e.BindMap(query, argmap) if err != nil { return nil, err } return e.Exec(q, args...) } sqlx-sqlx-v1.0/named_test.go000066400000000000000000000126551232764233400162050ustar00rootroot00000000000000package sqlx import ( "database/sql" "testing" ) func TestCompileQuery(t *testing.T) { table := []struct { Q, R, D string N []string }{ // basic test for named parameters, invalid char ',' terminating { Q: `INSERT INTO foo (a,b,c,d) VALUES (:name, :age, :first, :last)`, R: `INSERT INTO foo (a,b,c,d) VALUES (?, ?, ?, ?)`, D: `INSERT INTO foo (a,b,c,d) VALUES ($1, $2, $3, $4)`, N: []string{"name", "age", "first", "last"}, }, // This query tests a named parameter ending the string as well as numbers { Q: `SELECT * FROM a WHERE first_name=:name1 AND last_name=:name2`, R: `SELECT * FROM a WHERE first_name=? AND last_name=?`, D: `SELECT * FROM a WHERE first_name=$1 AND last_name=$2`, N: []string{"name1", "name2"}, }, /* This unicode awareness test sadly fails, because of our byte-wise worldview. * We could certainly iterate by Rune instead, though it's a great deal slower, * it's probably the RightWay(tm) { Q: `INSERT INTO foo (a,b,c,d) VALUES (:あ, :b, :キコ, :名前)`, R: `INSERT INTO foo (a,b,c,d) VALUES (?, ?, ?, ?)`, D: `INSERT INTO foo (a,b,c,d) VALUES ($1, $2, $3, $4)`, N: []string{"name", "age", "first", "last"}, }, */ } for _, test := range table { qr, names, err := compileNamedQuery([]byte(test.Q), QUESTION) if err != nil { t.Error(err) } if qr != test.R { t.Errorf("expected %s, got %s", test.R, qr) } if len(names) != len(test.N) { t.Errorf("expected %#v, got %#v", test.N, names) } else { for i, name := range names { if name != test.N[i] { t.Errorf("expected %dth name to be %s, got %s", i+1, test.N[i], name) } } } qd, _, _ := compileNamedQuery([]byte(test.Q), DOLLAR) if qd != test.D { t.Errorf("expected %s, got %s", test.D, qd) } qq, _, _ := compileNamedQuery([]byte(test.Q), NAMED) if qq != test.Q { t.Errorf("expected %s, got %s", test.Q, qq) } } } type Test struct { t *testing.T } func (t Test) Error(err error, msg ...interface{}) { if err != nil { if len(msg) == 0 { t.t.Error(err) } else { t.t.Error(msg...) } } } func (t Test) Errorf(err error, format string, args ...interface{}) { if err != nil { t.t.Errorf(format, args...) } } func TestNamedQueries(t *testing.T) { RunWithSchema(defaultSchema, t, func(db *DB, t *testing.T) { loadDefaultFixture(db, t) test := Test{t} var ns *NamedStmt var err error // Check that invalid preparations fail ns, err = db.PrepareNamed("SELECT * FROM person WHERE first_name=:first:name") if err == nil { t.Error("Expected an error with invalid prepared statement.") } ns, err = db.PrepareNamed("invalid sql") if err == nil { t.Error("Expected an error with invalid prepared statement.") } // Check closing works as anticipated ns, err = db.PrepareNamed("SELECT * FROM person WHERE first_name=:first_name") test.Error(err) err = ns.Close() test.Error(err) ns, err = db.PrepareNamed(` SELECT first_name, last_name, email FROM person WHERE first_name=:first_name AND email=:email`) test.Error(err) // test Queryx w/ uses Query p := Person{FirstName: "Jason", LastName: "Moiron", Email: "jmoiron@jmoiron.net"} rows, err := ns.Queryx(p) test.Error(err) for rows.Next() { var p2 Person rows.StructScan(&p2) if p.FirstName != p2.FirstName { t.Error("got %s, expected %s", p.FirstName, p2.FirstName) } if p.LastName != p2.LastName { t.Error("got %s, expected %s", p.LastName, p2.LastName) } if p.Email != p2.Email { t.Error("got %s, expected %s", p.Email, p2.Email) } } // test Select people := make([]Person, 0, 5) err = ns.Select(&people, p) test.Error(err) if len(people) != 1 { t.Errorf("got %d results, expected %d", len(people), 1) } if p.FirstName != people[0].FirstName { t.Error("got %s, expected %s", p.FirstName, people[0].FirstName) } if p.LastName != people[0].LastName { t.Error("got %s, expected %s", p.LastName, people[0].LastName) } if p.Email != people[0].Email { t.Error("got %s, expected %s", p.Email, people[0].Email) } // test Exec ns, err = db.PrepareNamed(` INSERT INTO person (first_name, last_name, email) VALUES (:first_name, :last_name, :email)`) test.Error(err) js := Person{ FirstName: "Julien", LastName: "Savea", Email: "jsavea@ab.co.nz", } _, err = ns.Exec(js) test.Error(err) // Make sure we can pull him out again p2 := Person{} db.Get(&p2, db.Rebind("SELECT * FROM person WHERE email=?"), js.Email) if p2.Email != js.Email { t.Errorf("expected %s, got %s", js.Email, p2.Email) } // test Txn NamedStmts tx := db.MustBegin() txns := tx.NamedStmt(ns) // We're going to add Steven in this txn sl := Person{ FirstName: "Steven", LastName: "Luatua", Email: "sluatua@ab.co.nz", } _, err = txns.Exec(sl) test.Error(err) // then rollback... tx.Rollback() // looking for Steven after a rollback should fail err = db.Get(&p2, db.Rebind("SELECT * FROM person WHERE email=?"), sl.Email) if err != sql.ErrNoRows { t.Errorf("expected no rows error, got %v", err) } // now do the same, but commit tx = db.MustBegin() txns = tx.NamedStmt(ns) _, err = txns.Exec(sl) test.Error(err) tx.Commit() // looking for Steven after a Commit should succeed err = db.Get(&p2, db.Rebind("SELECT * FROM person WHERE email=?"), sl.Email) test.Error(err) if p2.Email != sl.Email { t.Errorf("expected %s, got %s", sl.Email, p2.Email) } }) } sqlx-sqlx-v1.0/reflect.go000066400000000000000000000161511232764233400155010ustar00rootroot00000000000000package sqlx import ( "database/sql" "database/sql/driver" "errors" "fmt" "reflect" "sync" "time" ) // reflect.go contains extensions to reflect that make it easy to deal with // structs with reflect. // commonly used reflect types. var ( scannerIface = reflect.TypeOf((*sql.Scanner)(nil)).Elem() valuerIface = reflect.TypeOf((*driver.Valuer)(nil)).Elem() timeType = reflect.TypeOf(time.Time{}) ) // deref will dereference t until it is of kind k func deref(t reflect.Type, k reflect.Kind) (reflect.Type, error) { for { switch t.Kind() { case reflect.Ptr: t = t.Elem() continue case k: return t, nil default: return nil, fmt.Errorf("destination must be %s", k) } } } // BaseSliceType returns the type for a slice, dereferencing it if it is a pointer. // Returns an error if the destination is not a slice or a pointer to a slice. func BaseSliceType(t reflect.Type) (reflect.Type, error) { return deref(t, reflect.Slice) } // BaseStructType returns the type of a struct, dereferencing it if it is a pointer. // Returns an error if the destination is not a struct or a pointer to a struct. func BaseStructType(t reflect.Type) (reflect.Type, error) { return deref(t, reflect.Struct) } // an fmc is a cache of fieldmaps by reflect type to avoid having to do the // costly traversal of a fieldmap each time. type fmc struct { cache map[reflect.Type]fieldMap sync.RWMutex } var cache = fmc{cache: map[reflect.Type]fieldMap{}} func getFieldMap(t reflect.Type) (fieldMap, error) { t, err := BaseStructType(t) if err != nil { return nil, err } cache.RLock() fm, ok := cache.cache[t] cache.RUnlock() if ok { return fm, nil } fm, err = newFieldMap(t) if err != nil { return nil, err } cache.Lock() cache.cache[t] = fm cache.Unlock() return fm, nil } // A FieldMap maintains mappings which allow it quick access to struct fields in // a way that is consistent with the Go compiler's name resolution, eg. with // respect to embedded struct fields. type fieldMap map[string]int // newFieldMap creates a new fieldMap based on t. A fieldMap is a map of field // names to an integer, where the integer is its breadth first position in its // tree of embedded types. func newFieldMap(t reflect.Type) (fieldMap, error) { t, err := BaseStructType(t) if err != nil { return nil, err } fm := fieldMap{} // maintain a queue of embedded types to descend into queue := []reflect.Type{t} for pos := 0; len(queue) != 0; { // pop the first item off of the queue ty := queue[0] queue = queue[1:] // iterate through all of its fields for fieldPos := 0; fieldPos < ty.NumField(); fieldPos++ { f := ty.Field(fieldPos) ft := f.Type // skip unexported fields if len(f.PkgPath) != 0 { continue } // perform one level of indirection for pointers, so that checking if a // type implements an interface is consistent across *Type & Type. if ft.Kind() == reflect.Ptr { ft = ft.Elem() } // if this field is a struct, it doesn't implement scanner, and it's not a Time, // throw it on the queue to be descended into. if ft.Kind() == reflect.Struct && !reflect.PtrTo(ft).Implements(scannerIface) && ft != timeType { queue = append(queue, ft) } else { // otherwise, figure out its name name := NameMapper(f.Name) if tag := f.Tag.Get("db"); tag != "" { name = tag } // if the name is shadowed by an earlier identical name in the search, skip it if _, ok := fm[name]; ok { continue } // if the name is "-", skip it if name == "-" { continue } // add it to the map at the current position fm[name] = pos pos++ } } } return fm, nil } // getFieldIndexes returns a list of indexes corresponding to names from the // fieldmap. If a name can't be found, it gets a -1 associated with it. func (f fieldMap) getFieldIndexes(names []string, unsafe bool) ([]int, error) { fields := make([]int, len(names)) for i, name := range names { // find that name in the struct num, ok := f[name] if !ok && unsafe { fields[i] = -1 } else if !ok { return fields, fmt.Errorf("Could not find name %s in destination.", name) } else { fields[i] = num } } return fields, nil } // getValues fills values with the interface{} from v for fields corresponding // to indexes. If v is addressable, these are pointers, otherwise they are just // copies. func (f fieldMap) getValues(v reflect.Value, indexes []int, values []interface{}, unsafe bool) error { all := f.allValues(v) for i, index := range indexes { if index >= 0 { values[i] = all[index] } else if unsafe { values[i] = new(interface{}) } else { return errors.New("Unsafe not set but unknown field found.") } } return nil } // allValues fetches all field values from a struct value. These values are in // field order, as they use the same breadth-first search as the fieldmap. // // This code is shared between code which sets values (like rows.Scan) and code // that reads values (named query support). If v is addressable, we return // pointers which are settable, but if it isn't, then we return copies. func (f fieldMap) allValues(v reflect.Value) []interface{} { // as before, we use a queue, but this time of reflect.Value queue := []reflect.Value{v} values := make([]interface{}, len(f)) // since we're building a list instead of a mapping, we have to have a // way to implement the Go selection shadowing properly, so more-nested // names don't clobber less-nested ones. seen := struct{}{} encountered := map[string]struct{}{} var isPtr, isScanner, isValuer bool returnAddrs := v.CanAddr() for pos := 0; len(queue) != 0; { va := queue[0] queue = queue[1:] for fieldPos := 0; fieldPos < va.NumField(); fieldPos++ { // fieldVal, fieldType, structFieldType fv := va.Field(fieldPos) ft := fv.Type() sft := va.Type().Field(fieldPos) isPtr, isScanner = false, false // skip unexported fields if len(sft.PkgPath) != 0 { continue } // skip duplicate names in the struct tree if _, ok := encountered[sft.Name]; ok { continue } // skip fields with the db tag set to "-" if tag := sft.Tag.Get("db"); tag == "-" { continue } encountered[sft.Name] = seen if ft.Kind() == reflect.Ptr { ft = ft.Elem() isPtr = true } if isPtr || !returnAddrs { _, isScanner = fv.Interface().(sql.Scanner) _, isValuer = fv.Interface().(driver.Valuer) } else { _, isScanner = fv.Addr().Interface().(sql.Scanner) _, isValuer = fv.Addr().Interface().(driver.Valuer) } // if the field is a struct but not a scanner, valuer, or timeType, then we // will descend into it if ft.Kind() == reflect.Struct && !isScanner && !isValuer && ft != timeType { // if this is a pointer, it's possible it is nil, so just allocate a new one val := fv if isPtr { alloc := reflect.New(ft) fv.Set(alloc) val = reflect.Indirect(fv) } // descend into the struct to handle embeds queue = append(queue, val) } else { if !returnAddrs { values[pos] = fv.Interface() } else if returnAddrs { values[pos] = fv.Addr().Interface() } pos++ } } } return values } sqlx-sqlx-v1.0/sqlx.go000066400000000000000000000707251232764233400150530ustar00rootroot00000000000000package sqlx import ( "database/sql" "errors" "io/ioutil" "log" "path/filepath" "reflect" "strings" ) // FIXME: I should deprecate this. It makes it difficult to write libraries // which use sqlx, because programs can set this and break them. // NameMapper is used to map column names to struct field names. By default, // it uses strings.ToLower to lowercase struct field names. It can be set // to whatever you want, but it is encouraged to be set before sqlx is used // as field-to-name mappings are cached after first use on a type. var NameMapper = strings.ToLower // ColScanner is an interface for something which can Scan and return a list // of columns (Row, Rows) type ColScanner interface { Columns() ([]string, error) Scan(dest ...interface{}) error Err() error } // Queryer is an interface for something which can Query (Tx, DB, Stmt) type Queryer interface { Query(query string, args ...interface{}) (*sql.Rows, error) Queryx(query string, args ...interface{}) (*Rows, error) QueryRowx(query string, args ...interface{}) *Row } // Execer is an interface for something which can Exec (Tx, DB, Stmt) type Execer interface { Exec(query string, args ...interface{}) (sql.Result, error) } // Binder is an interface for something which can bind queries (Tx, DB) type Binder interface { DriverName() string Rebind(string) string BindMap(string, map[string]interface{}) (string, []interface{}, error) BindStruct(string, interface{}) (string, []interface{}, error) } // Ext is a union interface which can bind, query, and exec (Tx, DB), used for // NamedQuery and NamedExec, which requires exec/query and BindMap/Struct type Ext interface { Binder Queryer Execer } // Preparer is an interface for something which can prepare sql statements (Tx, DB) type Preparer interface { Prepare(query string) (*sql.Stmt, error) } // determine if any of our extensions are unsafe func isUnsafe(i interface{}) bool { switch i.(type) { case Row: return i.(Row).unsafe case *Row: return i.(*Row).unsafe case Rows: return i.(Rows).unsafe case *Rows: return i.(*Rows).unsafe case Stmt: return i.(Stmt).unsafe case qStmt: return i.(qStmt).Stmt.unsafe case *qStmt: return i.(*qStmt).Stmt.unsafe case DB: return i.(DB).unsafe case *DB: return i.(*DB).unsafe case Tx: return i.(Tx).unsafe case *Tx: return i.(*Tx).unsafe case sql.Rows, *sql.Rows: return false default: return false } } // Row is a reimplementation of sql.Row in order to gain access to the underlying // sql.Rows.Columns() data, necessary for StructScan. type Row struct { err error unsafe bool rows *sql.Rows } // Scan is a fixed implementation of sql.Row.Scan, which does not discard the // underlying error from the internal rows object if it exists. func (r *Row) Scan(dest ...interface{}) error { if r.err != nil { return r.err } // TODO(bradfitz): for now we need to defensively clone all // []byte that the driver returned (not permitting // *RawBytes in Rows.Scan), since we're about to close // the Rows in our defer, when we return from this function. // the contract with the driver.Next(...) interface is that it // can return slices into read-only temporary memory that's // only valid until the next Scan/Close. But the TODO is that // for a lot of drivers, this copy will be unnecessary. We // should provide an optional interface for drivers to // implement to say, "don't worry, the []bytes that I return // from Next will not be modified again." (for instance, if // they were obtained from the network anyway) But for now we // don't care. for _, dp := range dest { if _, ok := dp.(*sql.RawBytes); ok { return errors.New("sql: RawBytes isn't allowed on Row.Scan") } } defer r.rows.Close() if !r.rows.Next() { if r.rows.Err() != nil { r.err = r.rows.Err() return r.err } return sql.ErrNoRows } return r.rows.Scan(dest...) } // Columns returns the underlying sql.Rows.Columns(), or the deferred error usually // returned by Row.Scan() func (r *Row) Columns() ([]string, error) { if r.err != nil { return []string{}, r.err } return r.rows.Columns() } // Err returns the error encountered while scanning. func (r *Row) Err() error { return r.err } // DB is a wrapper around sql.DB which keeps track of the driverName upon Open, // used mostly to automatically bind named queries using the right bindvars. type DB struct { *sql.DB driverName string unsafe bool } // NewDb returns a new sqlx DB wrapper for a pre-existing *sql.DB. The // driverName of the original database is required for named query support. func NewDb(db *sql.DB, driverName string) *DB { return &DB{DB: db, driverName: driverName} } // DriverName returns the driverName passed to the Open function for this DB. func (db *DB) DriverName() string { return db.driverName } // Open is the same as database/sql's Open, but returns an *sqlx.DB instead. func Open(driverName, dataSourceName string) (*DB, error) { db, err := sql.Open(driverName, dataSourceName) if err != nil { return nil, err } return &DB{DB: db, driverName: driverName}, err } // Rebind transforms a query from QUESTION to the DB driver's bindvar type. func (db *DB) Rebind(query string) string { return Rebind(BindType(db.driverName), query) } // Unsafe returns a version of DB which will silently succeed to scan when // columns in the SQL result have no fields in the destination struct. // sqlx.Stmt and sqlx.Tx which are created from this DB will inherit its // safety behavior. func (db *DB) Unsafe() *DB { return &DB{DB: db.DB, driverName: db.driverName, unsafe: true} } // BindMap binds a query using the DB driver's bindvar type. func (db *DB) BindMap(query string, argmap map[string]interface{}) (string, []interface{}, error) { return BindMap(BindType(db.driverName), query, argmap) } // BindStruct binds a query using the DB driver's bindvar type. func (db *DB) BindStruct(query string, arg interface{}) (string, []interface{}, error) { return BindStruct(BindType(db.driverName), query, arg) } // NamedQueryMap using this DB. // DEPRECATED: use NamedQuery instead. func (db *DB) NamedQueryMap(query string, argmap map[string]interface{}) (*Rows, error) { return NamedQueryMap(db, query, argmap) } // NamedExecMap using this DB. // DEPRECATED: use NamedExec instead func (db *DB) NamedExecMap(query string, argmap map[string]interface{}) (sql.Result, error) { return NamedExecMap(db, query, argmap) } // NamedQuery using this DB. func (db *DB) NamedQuery(query string, arg interface{}) (*Rows, error) { return NamedQuery(db, query, arg) } // NamedExec using this DB. func (db *DB) NamedExec(query string, arg interface{}) (sql.Result, error) { return NamedExec(db, query, arg) } // Select using this DB. func (db *DB) Select(dest interface{}, query string, args ...interface{}) error { return Select(db, dest, query, args...) } // Selectf using this DB. func (db *DB) Selectf(dest interface{}, query string, args ...interface{}) { Selectf(db, dest, query, args...) } // Selectv using this DB. func (db *DB) Selectv(dest interface{}, query string, args ...interface{}) error { return Selectv(db, dest, query, args...) } // Get using this DB. func (db *DB) Get(dest interface{}, query string, args ...interface{}) error { return Get(db, dest, query, args...) } // LoadFile using this DB. func (db *DB) LoadFile(path string) (*sql.Result, error) { return LoadFile(db, path) } // MustBegin starts a transaction, and panics on error. Returns an *sqlx.Tx instead // of an *sql.Tx. func (db *DB) MustBegin() *Tx { tx, err := db.Beginx() if err != nil { panic(err) } return tx } // Beginx begins a transaction and returns an *sqlx.Tx instead of an *sql.Tx. func (db *DB) Beginx() (*Tx, error) { tx, err := db.DB.Begin() if err != nil { return nil, err } return &Tx{Tx: tx, driverName: db.driverName, unsafe: db.unsafe}, err } // Queryx queries the database and returns an *sqlx.Rows. func (db *DB) Queryx(query string, args ...interface{}) (*Rows, error) { r, err := db.DB.Query(query, args...) if err != nil { return nil, err } return &Rows{Rows: *r, unsafe: db.unsafe}, err } // QueryRowx queries the database and returns an *sqlx.Row. func (db *DB) QueryRowx(query string, args ...interface{}) *Row { rows, err := db.DB.Query(query, args...) return &Row{rows: rows, err: err, unsafe: db.unsafe} } // Execv (verbose) runs Execv using this database. func (db *DB) Execv(query string, args ...interface{}) (sql.Result, error) { return Execv(db, query, args...) } // Execl (log) runs Execl using this database. func (db *DB) Execl(query string, args ...interface{}) sql.Result { return Execl(db, query, args...) } // Execf (fatal) runs Execf using this database. func (db *DB) Execf(query string, args ...interface{}) sql.Result { return Execf(db, query, args...) } // Execp (panic) runs Execp using this database. func (db *DB) Execp(query string, args ...interface{}) sql.Result { return Execp(db, query, args...) } // MustExec (panic) runs MustExec using this database. func (db *DB) MustExec(query string, args ...interface{}) sql.Result { return MustExec(db, query, args...) } // Preparex returns an sqlx.Stmt instead of a sql.Stmt func (db *DB) Preparex(query string) (*Stmt, error) { return Preparex(db, query) } // PrepareNamed returns an sqlx.NamedStmt func (db *DB) PrepareNamed(query string) (*NamedStmt, error) { return prepareNamed(db, query) } // Tx is an sqlx wrapper around database/sql's Tx with extra functionality type Tx struct { *sql.Tx driverName string unsafe bool } // DriverName returns the driverName used by the DB which began this transaction. func (tx *Tx) DriverName() string { return tx.driverName } // Rebind a query within a transaction's bindvar type. func (tx *Tx) Rebind(query string) string { return Rebind(BindType(tx.driverName), query) } // Unsafe returns a version of Tx which will silently succeed to scan when // columns in the SQL result have no fields in the destination struct. func (tx *Tx) Unsafe() *Tx { return &Tx{Tx: tx.Tx, driverName: tx.driverName, unsafe: true} } // BindMap binds a query within a transaction's bindvar type. func (tx *Tx) BindMap(query string, argmap map[string]interface{}) (string, []interface{}, error) { return BindMap(BindType(tx.driverName), query, argmap) } // BindStruct binds a query within a transaction's bindvar type. func (tx *Tx) BindStruct(query string, arg interface{}) (string, []interface{}, error) { return BindStruct(BindType(tx.driverName), query, arg) } // NamedQuery within a transaction. func (tx *Tx) NamedQuery(query string, arg interface{}) (*Rows, error) { return NamedQuery(tx, query, arg) } // NamedExec a named query within a transaction. func (tx *Tx) NamedExec(query string, arg interface{}) (sql.Result, error) { return NamedExec(tx, query, arg) } // NamedQueryMap within a transaction. // DEPRECATED: Use NamedQuery instead func (tx *Tx) NamedQueryMap(query string, arg map[string]interface{}) (*Rows, error) { return NamedQueryMap(tx, query, arg) } // NamedExecMap a named query within a transaction. // DEPRECATED: Use NamedExec instead func (tx *Tx) NamedExecMap(query string, arg map[string]interface{}) (sql.Result, error) { return NamedExecMap(tx, query, arg) } // LoadFile within a transaction. func (tx *Tx) LoadFile(path string) (*sql.Result, error) { return LoadFile(tx, path) } // Select within a transaction. func (tx *Tx) Select(dest interface{}, query string, args ...interface{}) error { return Select(tx, dest, query, args...) } // Queryx within a transaction. func (tx *Tx) Queryx(query string, args ...interface{}) (*Rows, error) { r, err := tx.Tx.Query(query, args...) if err != nil { return nil, err } return &Rows{Rows: *r, unsafe: tx.unsafe}, err } // QueryRowx within a transaction. func (tx *Tx) QueryRowx(query string, args ...interface{}) *Row { rows, err := tx.Tx.Query(query, args...) return &Row{rows: rows, err: err, unsafe: tx.unsafe} } // Get within a transaction. func (tx *Tx) Get(dest interface{}, query string, args ...interface{}) error { return Get(tx, dest, query, args...) } // Selectv (verbose) within a transaction. func (tx *Tx) Selectv(dest interface{}, query string, args ...interface{}) error { return Selectv(tx, dest, query, args...) } // Selectf (fatal) within a transaction. func (tx *Tx) Selectf(dest interface{}, query string, args ...interface{}) { Selectf(tx, dest, query, args...) } // Execv (verbose) runs Execv within a transaction. func (tx *Tx) Execv(query string, args ...interface{}) (sql.Result, error) { return Execv(tx, query, args...) } // Execl (log) runs Execl within a transaction. func (tx *Tx) Execl(query string, args ...interface{}) sql.Result { return Execl(tx, query, args...) } // Execf (fatal) runs Execf within a transaction. func (tx *Tx) Execf(query string, args ...interface{}) sql.Result { return Execf(tx, query, args...) } // Execp (panic) runs Execp within a transaction. func (tx *Tx) Execp(query string, args ...interface{}) sql.Result { return Execp(tx, query, args...) } // MustExec runs MustExec within a transaction. func (tx *Tx) MustExec(query string, args ...interface{}) sql.Result { return MustExec(tx, query, args...) } // Preparex a statement within a transaction. func (tx *Tx) Preparex(query string) (*Stmt, error) { return Preparex(tx, query) } // Stmtx returns a version of the prepared statement which runs within a transaction. Provided // stmt can be either *sql.Stmt or *sqlx.Stmt. func (tx *Tx) Stmtx(stmt interface{}) *Stmt { var st sql.Stmt var s *sql.Stmt switch stmt.(type) { case sql.Stmt: st = stmt.(sql.Stmt) s = &st case Stmt: s = stmt.(Stmt).Stmt case *Stmt: s = stmt.(*Stmt).Stmt case *sql.Stmt: s = stmt.(*sql.Stmt) } return &Stmt{Stmt: tx.Stmt(s)} } // NamedStmt returns a version of the prepared statement which runs within a transaction. func (tx *Tx) NamedStmt(stmt *NamedStmt) *NamedStmt { return &NamedStmt{ QueryString: stmt.QueryString, Params: stmt.Params, Stmt: tx.Stmtx(stmt.Stmt), } } // PrepareNamed returns an sqlx.NamedStmt func (tx *Tx) PrepareNamed(query string) (*NamedStmt, error) { return prepareNamed(tx, query) } // Stmt is an sqlx wrapper around database/sql's Stmt with extra functionality type Stmt struct { *sql.Stmt unsafe bool } // Unsafe returns a version of Stmt which will silently succeed to scan when // columns in the SQL result have no fields in the destination struct. func (s *Stmt) Unsafe() *Stmt { return &Stmt{Stmt: s.Stmt, unsafe: true} } // Select using the prepared statement. func (s *Stmt) Select(dest interface{}, args ...interface{}) error { return Select(&qStmt{*s}, dest, "", args...) } // Selectv (verbose) using the prepared statement. func (s *Stmt) Selectv(dest interface{}, args ...interface{}) error { return Selectv(&qStmt{*s}, dest, "", args...) } // Selectf (fatal) using the prepared statement. func (s *Stmt) Selectf(dest interface{}, args ...interface{}) { Selectf(&qStmt{*s}, dest, "", args...) } // Get using the prepared statement. func (s *Stmt) Get(dest interface{}, args ...interface{}) error { return Get(&qStmt{*s}, dest, "", args...) } // Execv (verbose) runs Execv using this statement. Note that the query // portion of the error output will be blank, as Stmt does not expose its query. func (s *Stmt) Execv(args ...interface{}) (sql.Result, error) { return Execv(&qStmt{*s}, "", args...) } // Execl (log) using this statement. Note that the query portion of the error // output will be blank, as Stmt does not expose its query. func (s *Stmt) Execl(args ...interface{}) sql.Result { return Execl(&qStmt{*s}, "", args...) } // Execf (fatal) using this statement. Note that the query portion of the error // output will be blank, as Stmt does not expose its query. func (s *Stmt) Execf(args ...interface{}) sql.Result { return Execf(&qStmt{*s}, "", args...) } // Execp (panic) using this statement. Note that the query portion of the error // output will be blank, as Stmt does not expose its query. func (s *Stmt) Execp(args ...interface{}) sql.Result { return Execp(&qStmt{*s}, "", args...) } // MustExec (panic) using this statement. Note that the query portion of the error // output will be blank, as Stmt does not expose its query. func (s *Stmt) MustExec(args ...interface{}) sql.Result { return MustExec(&qStmt{*s}, "", args...) } // QueryRowx using this statement. func (s *Stmt) QueryRowx(args ...interface{}) *Row { qs := &qStmt{*s} return qs.QueryRowx("", args...) } // Queryx using this statement. func (s *Stmt) Queryx(args ...interface{}) (*Rows, error) { qs := &qStmt{*s} return qs.Queryx("", args...) } // qStmt is an unexposed wrapper which lets you use a Stmt as a Queryer & Execer by // implementing those interfaces and ignoring the `query` argument. type qStmt struct{ Stmt } func (q *qStmt) Query(query string, args ...interface{}) (*sql.Rows, error) { return q.Stmt.Query(args...) } func (q *qStmt) Queryx(query string, args ...interface{}) (*Rows, error) { r, err := q.Stmt.Query(args...) if err != nil { return nil, err } return &Rows{Rows: *r, unsafe: q.Stmt.unsafe}, err } func (q *qStmt) QueryRowx(query string, args ...interface{}) *Row { rows, err := q.Stmt.Query(args...) return &Row{rows: rows, err: err, unsafe: q.Stmt.unsafe} } func (q *qStmt) Exec(query string, args ...interface{}) (sql.Result, error) { return q.Stmt.Exec(args...) } // Rows is a wrapper around sql.Rows which caches costly reflect operations // during a looped StructScan type Rows struct { sql.Rows started bool fields []int base reflect.Type values []interface{} unsafe bool } // SliceScan using this Rows. func (r *Rows) SliceScan() ([]interface{}, error) { return SliceScan(r) } // MapScan using this Rows. func (r *Rows) MapScan(dest map[string]interface{}) error { return MapScan(r, dest) } // StructScan is like sql.Rows.Scan, but scans a single Row into a single Struct. // Use this and iterate over Rows manually when the memory load of Select() might be // prohibitive. *Rows.StructScan caches the reflect work of matching up column // positions to fields to avoid that overhead per scan, which means it is not safe // to run StructScan on the same Rows instance with different struct types. func (r *Rows) StructScan(dest interface{}) error { var v reflect.Value v = reflect.ValueOf(dest) if v.Kind() != reflect.Ptr { return errors.New("must pass a pointer, not a value, to StructScan destination") } base := reflect.Indirect(v) fm, err := getFieldMap(base.Type()) if err != nil { return err } if !r.started { columns, err := r.Columns() if err != nil { return err } var ok bool var num int r.fields = make([]int, len(columns)) r.values = make([]interface{}, len(columns)) for i, name := range columns { // find that name in the struct num, ok = fm[name] if !ok { return errors.New("Could not find name " + name + " in interface.") } r.fields[i] = num } r.started = true } // create a new struct type (which returns PtrTo) and indirect it err = fm.getValues(reflect.Indirect(v), r.fields, r.values, r.unsafe) if err != nil { return err } // scan into the struct field pointers and append to our results err = r.Scan(r.values...) if err != nil { return err } return r.Err() } // Connect to a database and verify with a ping. func Connect(driverName, dataSourceName string) (*DB, error) { db, err := Open(driverName, dataSourceName) if err != nil { return db, err } err = db.Ping() return db, err } // MustConnect connects to a database and panics on error. func MustConnect(driverName, dataSourceName string) *DB { db, err := Connect(driverName, dataSourceName) if err != nil { panic(err) } return db } // Preparex prepares a statement. func Preparex(p Preparer, query string) (*Stmt, error) { s, err := p.Prepare(query) if err != nil { return nil, err } return &Stmt{Stmt: s, unsafe: isUnsafe(p)}, err } // Select executes a query using the provided Queryer, and StructScans each row // into dest, which must be a slice of structs. The *sql.Rows are closed // automatically. func Select(q Queryer, dest interface{}, query string, args ...interface{}) error { rows, err := q.Queryx(query, args...) if err != nil { return err } // if something happens here, we want to make sure the rows are Closed defer rows.Close() return StructScan(rows, dest) } // Selectv (verbose) will Select using a Queryer and use log.Println to print //the query and the error in the event of an error. func Selectv(q Queryer, dest interface{}, query string, args ...interface{}) error { err := Select(q, dest, query, args...) if err != nil { log.Println(query, err) } return err } // Selectf (fatal) will Select using a Queryer and use log.Fatal to print // the query and the error in the event of an error. func Selectf(q Queryer, dest interface{}, query string, args ...interface{}) { err := Select(q, dest, query, args...) if err != nil { log.Fatal(query, err) } } // Get does a QueryRow using the provided Queryer, and StructScan the resulting // row into dest, which must be a pointer to a struct. If there was no row, // Get will return sql.ErrNoRows like row.Scan would. func Get(q Queryer, dest interface{}, query string, args ...interface{}) error { r := q.QueryRowx(query, args...) return r.StructScan(dest) } // LoadFile exec's every statement in a file (as a single call to Exec). // LoadFile may return a nil *sql.Result if errors are encountered locating or // reading the file at path. LoadFile reads the entire file into memory, so it // is not suitable for loading large data dumps, but can be useful for initializing // schemas or loading indexes. // FIXME: this does not really work with multi-statement files for mattn/go-sqlite3 // or the go-mysql-driver/mysql drivers; pq seems to be an exception here. Detecting // this by requiring something with DriverName() and then attempting to split the // queries will be difficult to get right, and its current driver-specific behavior // is deemed at least not complex in its incorrectness. func LoadFile(e Execer, path string) (*sql.Result, error) { realpath, err := filepath.Abs(path) if err != nil { return nil, err } contents, err := ioutil.ReadFile(realpath) if err != nil { return nil, err } res, err := e.Exec(string(contents)) return &res, err } // Execv (verbose) Exec's the query using the Execer and uses log.Println to // print the query, result, and error in the event of an error. func Execv(e Execer, query string, args ...interface{}) (sql.Result, error) { res, err := e.Exec(query, args...) if err != nil { log.Println(query, res, err) } return res, err } // Execl (log) runs Exec on the query and args and ses log.Println to // print the query, result, and error in the event of an error. Unlike Execv, // Execl does not return the error, and can be used in single-value contexts. // // Do not abuse Execl; it is convenient for experimentation but generally not // for production use. func Execl(e Execer, query string, args ...interface{}) sql.Result { res, err := e.Exec(query, args...) if err != nil { log.Println(query, res, err) } return res } // Execf (fatal) runs Exec on the query and args and uses log.Fatal to // print the query, result, and error in the event of an error. func Execf(e Execer, query string, args ...interface{}) sql.Result { res, err := e.Exec(query, args...) if err != nil { log.Fatal(query, res, err) } return res } // Execp (panic) runs Exec on the query and args and panics on error. func Execp(e Execer, query string, args ...interface{}) sql.Result { return MustExec(e, query, args...) } // MustExec (panic) is an alias for Execp. func MustExec(e Execer, query string, args ...interface{}) sql.Result { res, err := e.Exec(query, args...) if err != nil { panic(err) } return res } // SliceScan using this Rows. func (r *Row) SliceScan() ([]interface{}, error) { return SliceScan(r) } // MapScan using this Rows. func (r *Row) MapScan(dest map[string]interface{}) error { return MapScan(r, dest) } // StructScan a single Row into dest. func (r *Row) StructScan(dest interface{}) error { if r.err != nil { return r.err } defer r.rows.Close() var v reflect.Value v = reflect.ValueOf(dest) if v.Kind() != reflect.Ptr { return errors.New("must pass a pointer, not a value, to StructScan destination") } if v.IsNil() { return errors.New("nil pointer passed to StructScan destination") } direct := reflect.Indirect(v) base, err := BaseStructType(direct.Type()) if err != nil { return err } fm, err := getFieldMap(base) if err != nil { return err } columns, err := r.Columns() if err != nil { return err } indexes, err := fm.getFieldIndexes(columns, r.unsafe) if err != nil { return err } values := make([]interface{}, len(columns)) // create a new struct type (which returns PtrTo) and indirect it err = fm.getValues(reflect.Indirect(v), indexes, values, r.unsafe) if err != nil { return err } // scan into the struct field pointers and append to our results return r.Scan(values...) } // SliceScan a row, returning a []interface{} with values similar to MapScan. // This function is primarly intended for use where the number of columns // is not known. Because you can pass an []interface{} directly to Scan, // it's recommended that you do that as it will not have to allocate new // slices per row. func SliceScan(r ColScanner) ([]interface{}, error) { // ignore r.started, since we needn't use reflect for anything. columns, err := r.Columns() if err != nil { return []interface{}{}, err } values := make([]interface{}, len(columns)) for i := range values { values[i] = &sql.NullString{} } err = r.Scan(values...) if err != nil { return values, err } for i := range columns { ns := *(values[i].(*sql.NullString)) if ns.Valid { values[i] = ns.String } else { values[i] = nil } } return values, r.Err() } // MapScan scans a single Row into the dest map[string]interface{}. // Use this to get results for SQL that might not be under your control // (for instance, if you're building an interface for an SQL server that // executes SQL from input). Please do not use this as a primary interface! // This will modify the map sent to it in place, so do not reuse the same one // on different queries or you may end up with something odd! Columns which // occur more than once in the result will overwrite eachother! // // The resultant map values will be string representations of the various // SQL datatypes for existing values and a nil for null values. func MapScan(r ColScanner, dest map[string]interface{}) error { // ignore r.started, since we needn't use reflect for anything. columns, err := r.Columns() if err != nil { return err } values := make([]interface{}, len(columns)) for i := range values { values[i] = &sql.NullString{} } err = r.Scan(values...) if err != nil { return err } for i, column := range columns { ns := *(values[i].(*sql.NullString)) if ns.Valid { dest[column] = ns.String } else { dest[column] = nil } } return r.Err() } type rowsi interface { Close() error Columns() ([]string, error) Err() error Next() bool Scan(...interface{}) error } // StructScan all rows from an sql.Rows or an sqlx.Rows into the dest slice. // StructScan will scan in the entire rows result, so if you need do not want to // allocate structs for the entire result, use Queryx and see sqlx.Rows.StructScan. func StructScan(rows rowsi, dest interface{}) error { var v, vp reflect.Value var isPtr bool value := reflect.ValueOf(dest) if value.Kind() != reflect.Ptr { return errors.New("must pass a pointer, not a value, to StructScan destination") } if value.IsNil() { return errors.New("nil pointer passed to StructScan destination") } direct := reflect.Indirect(value) slice, err := BaseSliceType(value.Type()) if err != nil { return err } isPtr = slice.Elem().Kind() == reflect.Ptr base, err := BaseStructType(slice.Elem()) if err != nil { return err } fm, err := getFieldMap(base) if err != nil { return err } columns, err := rows.Columns() if err != nil { return err } indexes, err := fm.getFieldIndexes(columns, isUnsafe(rows)) if err != nil { return err } // this will hold interfaces which are pointers to each field in the struct values := make([]interface{}, len(columns)) for rows.Next() { // create a new struct type (which returns PtrTo) and indirect it vp = reflect.New(base) v = reflect.Indirect(vp) err = fm.getValues(v, indexes, values, isUnsafe(rows)) if err != nil { return err } // scan into the struct field pointers and append to our results err = rows.Scan(values...) if err != nil { return err } if isPtr { direct.Set(reflect.Append(direct, vp)) } else { direct.Set(reflect.Append(direct, v)) } } return rows.Err() } sqlx-sqlx-v1.0/sqlx_test.go000066400000000000000000000622751232764233400161130ustar00rootroot00000000000000// The following environment variables, if set, will be used: // // * SQLX_SQLITE_DSN // * SQLX_POSTGRES_DSN // * SQLX_MYSQL_DSN // // Set any of these variables to 'skip' to skip them. Note that for MySQL, // the string '?parseTime=True' will be appended to the DSN if it's not there // already. // package sqlx import ( "database/sql" "fmt" "log" "os" "reflect" "strings" "testing" "time" _ "github.com/go-sql-driver/mysql" _ "github.com/lib/pq" _ "github.com/mattn/go-sqlite3" ) /* compile time checks that Db, Tx, Stmt (qStmt) implement expected interfaces */ var _, _ Ext = &DB{}, &Tx{} var _, _ ColScanner = &Row{}, &Rows{} var _ Queryer = &qStmt{} var _ Execer = &qStmt{} var TestPostgres = true var TestSqlite = true var TestMysql = true var sldb *DB var pgdb *DB var mysqldb *DB var active = []*DB{} func init() { ConnectAll() } func ConnectAll() { var err error pgdsn := os.Getenv("SQLX_POSTGRES_DSN") mydsn := os.Getenv("SQLX_MYSQL_DSN") sqdsn := os.Getenv("SQLX_SQLITE_DSN") TestPostgres = pgdsn != "skip" TestMysql = mydsn != "skip" TestSqlite = sqdsn != "skip" if TestPostgres { pgdb, err = Connect("postgres", pgdsn) if err != nil { fmt.Printf("Disabling PG tests:\n %v\n", err) TestPostgres = false } } else { fmt.Println("Disabling Postgres tests.") } if TestMysql { mysqldb, err = Connect("mysql", mydsn) if err != nil { fmt.Printf("Disabling MySQL tests:\n %v", err) TestMysql = false } } else { fmt.Println("Disabling MySQL tests.") } if TestSqlite { sldb, err = Connect("sqlite3", sqdsn) if err != nil { fmt.Printf("Disabling SQLite:\n %v", err) TestSqlite = false } } else { fmt.Println("Disabling SQLite tests.") } } type Schema struct { create string drop string } func (s Schema) Postgres() (string, string) { return s.create, s.drop } func (s Schema) MySQL() (string, string) { return strings.Replace(s.create, `"`, "`", -1), s.drop } func (s Schema) Sqlite3() (string, string) { return strings.Replace(s.create, `now()`, `CURRENT_TIMESTAMP`, -1), s.drop } var defaultSchema = Schema{ create: ` CREATE TABLE person ( first_name text, last_name text, email text, added_at timestamp default now() ); CREATE TABLE place ( country text, city text NULL, telcode integer ); CREATE TABLE capplace ( "COUNTRY" text, "CITY" text NULL, "TELCODE" integer ); CREATE TABLE nullperson ( first_name text NULL, last_name text NULL, email text NULL ); `, drop: ` drop table person; drop table place; drop table capplace; drop table nullperson; `, } type Person struct { FirstName string `db:"first_name"` LastName string `db:"last_name"` Email string AddedAt time.Time `db:"added_at"` } type Person2 struct { FirstName sql.NullString `db:"first_name"` LastName sql.NullString `db:"last_name"` Email sql.NullString } type Place struct { Country string City sql.NullString TelCode int } type PlacePtr struct { Country string City *string TelCode int } type PersonPlace struct { Person Place } type PersonPlacePtr struct { *Person *Place } type NonEmbedded struct { Person Person Place Place } type EmbedConflict struct { FirstName string `db:"first_name"` Person } type Loop1 struct { Person } type Loop2 struct { Loop1 } type Loop3 struct { Loop2 } type SliceMember struct { Country string City sql.NullString TelCode int People []Person `db:"-"` Addresses []Place `db:"-"` } // Note that because of field map caching, we need a new type here // if we've used Place already soemwhere in sqlx type CPlace Place func MultiExec(e Execer, query string) { stmts := strings.Split(query, ";\n") if len(strings.Trim(stmts[len(stmts)-1], " \n\t\r")) == 0 { stmts = stmts[:len(stmts)-1] } for _, s := range stmts { _, err := e.Exec(s) if err != nil { fmt.Println(err, s) } } } func RunWithSchema(schema Schema, t *testing.T, test func(db *DB, t *testing.T)) { runner := func(db *DB, t *testing.T, create, drop string) { defer func() { MultiExec(db, drop) }() MultiExec(db, create) test(db, t) } if TestPostgres { create, drop := schema.Postgres() runner(pgdb, t, create, drop) } if TestSqlite { create, drop := schema.Sqlite3() runner(sldb, t, create, drop) } if TestMysql { create, drop := schema.MySQL() runner(mysqldb, t, create, drop) } } func loadDefaultFixture(db *DB, t *testing.T) { tx := db.MustBegin() tx.Execl(tx.Rebind("INSERT INTO person (first_name, last_name, email) VALUES (?, ?, ?)"), "Jason", "Moiron", "jmoiron@jmoiron.net") tx.Execl(tx.Rebind("INSERT INTO person (first_name, last_name, email) VALUES (?, ?, ?)"), "John", "Doe", "johndoeDNE@gmail.net") tx.Execl(tx.Rebind("INSERT INTO place (country, city, telcode) VALUES (?, ?, ?)"), "United States", "New York", "1") tx.Execl(tx.Rebind("INSERT INTO place (country, telcode) VALUES (?, ?)"), "Hong Kong", "852") tx.Execl(tx.Rebind("INSERT INTO place (country, telcode) VALUES (?, ?)"), "Singapore", "65") if db.DriverName() == "mysql" { tx.Execl(tx.Rebind("INSERT INTO capplace (`COUNTRY`, `TELCODE`) VALUES (?, ?)"), "Sarf Efrica", "27") } else { tx.Execl(tx.Rebind("INSERT INTO capplace (\"COUNTRY\", \"TELCODE\") VALUES (?, ?)"), "Sarf Efrica", "27") } tx.Commit() } // Test a new backwards compatible feature, that missing scan destinations // will silently scan into sql.RawText rather than failing/panicing func TestMissingNames(t *testing.T) { RunWithSchema(defaultSchema, t, func(db *DB, t *testing.T) { loadDefaultFixture(db, t) type PersonPlus struct { FirstName string `db:"first_name"` LastName string `db:"last_name"` Email string //AddedAt time.Time `db:"added_at"` } // test Select first pps := []PersonPlus{} // pps lacks added_at destination err := db.Select(&pps, "SELECT * FROM person") if err == nil { t.Error("Expected missing name from Select to fail, but it did not.") } // test Get pp := PersonPlus{} err = db.Get(&pp, "SELECT * FROM person LIMIT 1") if err == nil { t.Error("Expected missing name Get to fail, but it did not.") } // test naked StructScan pps = []PersonPlus{} rows, err := db.Query("SELECT * FROM person LIMIT 1") if err != nil { t.Fatal(err) } rows.Next() err = StructScan(rows, &pps) if err == nil { t.Error("Expected missing name in StructScan to fail, but it did not.") } rows.Close() // now try various things with unsafe set. db = db.Unsafe() pps = []PersonPlus{} err = db.Select(&pps, "SELECT * FROM person") if err != nil { t.Error(err) } // test Get pp = PersonPlus{} err = db.Get(&pp, "SELECT * FROM person LIMIT 1") if err != nil { t.Error(err) } // test naked StructScan pps = []PersonPlus{} rowsx, err := db.Queryx("SELECT * FROM person LIMIT 1") if err != nil { t.Fatal(err) } rowsx.Next() err = StructScan(rowsx, &pps) if err != nil { t.Error(err) } rowsx.Close() }) } func TestEmbeddedStructs(t *testing.T) { RunWithSchema(defaultSchema, t, func(db *DB, t *testing.T) { loadDefaultFixture(db, t) peopleAndPlaces := []PersonPlace{} err := db.Select( &peopleAndPlaces, `SELECT person.*, place.* FROM person natural join place`) if err != nil { t.Fatal(err) } for _, pp := range peopleAndPlaces { if len(pp.Person.FirstName) == 0 { t.Errorf("Expected non zero lengthed first name.") } if len(pp.Place.Country) == 0 { t.Errorf("Expected non zero lengthed country.") } } // test embedded structs with StructScan rows, err := db.Queryx( `SELECT person.*, place.* FROM person natural join place`) if err != nil { t.Error(err) } perp := PersonPlace{} rows.Next() err = rows.StructScan(&perp) if err != nil { t.Error(err) } if len(perp.Person.FirstName) == 0 { t.Errorf("Expected non zero lengthed first name.") } if len(perp.Place.Country) == 0 { t.Errorf("Expected non zero lengthed country.") } rows.Close() // test the same for embedded pointer structs peopleAndPlacesPtrs := []PersonPlacePtr{} err = db.Select( &peopleAndPlacesPtrs, `SELECT person.*, place.* FROM person natural join place`) if err != nil { t.Fatal(err) } for _, pp := range peopleAndPlacesPtrs { if len(pp.Person.FirstName) == 0 { t.Errorf("Expected non zero lengthed first name.") } if len(pp.Place.Country) == 0 { t.Errorf("Expected non zero lengthed country.") } } // test "non embedded" struct namespace collapsing.. nes := []NonEmbedded{} err = db.Select(&nes, `select person.*, place.* FROM person natural join place`) if err != nil { t.Fatal(err) } for _, ne := range nes { if len(ne.Person.FirstName) == 0 { t.Errorf("Expected non zero lengthed first name.") } if len(ne.Place.Country) == 0 { t.Errorf("Expected non zero lengthed country.") } } // test "deep nesting" l3s := []Loop3{} err = db.Select(&l3s, `select * from person`) if err != nil { t.Fatal(err) } for _, l3 := range l3s { if len(l3.Loop2.Loop1.Person.FirstName) == 0 { t.Errorf("Expected non zero lengthed first name.") } } // test "embed conflicts" ec := []EmbedConflict{} err = db.Select(&ec, `select * from person`) // I'm torn between erroring here or having some kind of working behavior // in order to allow for more flexibility in destination structs if err != nil { t.Errorf("Was not expecting an error on embed conflicts.") } }) } func TestNilReceiver(t *testing.T) { RunWithSchema(defaultSchema, t, func(db *DB, t *testing.T) { loadDefaultFixture(db, t) var p *Person err := db.Get(p, "SELECT * FROM person LIMIT 1") if err == nil { t.Error("Expected error when getting into nil struct ptr.") } var pp *[]Person err = db.Select(pp, "SELECT * FROM person") if err == nil { t.Error("Expected an error when selecting into nil slice ptr.") } }) } func TestNamedQuery(t *testing.T) { var schema = Schema{ create: ` CREATE TABLE person ( first_name text NULL, last_name text NULL, email text NULL );`, drop: `drop table person;`, } RunWithSchema(schema, t, func(db *DB, t *testing.T) { type Person struct { FirstName sql.NullString `db:"first_name"` LastName sql.NullString `db:"last_name"` Email sql.NullString } p := Person{ FirstName: sql.NullString{"ben", true}, LastName: sql.NullString{"doe", true}, Email: sql.NullString{"ben@doe.com", true}, } q1 := `INSERT INTO person (first_name, last_name, email) VALUES (:first_name, :last_name, :email)` _, err := db.NamedExec(q1, p) if err != nil { log.Fatal(err) } p2 := &Person{} rows, err := db.NamedQuery("SELECT * FROM person WHERE first_name=:first_name", p) if err != nil { log.Fatal(err) } for rows.Next() { err = rows.StructScan(p2) if err != nil { t.Error(err) } if p2.FirstName.String != "ben" { t.Error("Expected first name of `ben`, got " + p2.FirstName.String) } if p2.LastName.String != "doe" { t.Error("Expected first name of `doe`, got " + p2.LastName.String) } } }) } func TestScanError(t *testing.T) { var schema = Schema{ create: ` CREATE TABLE kv ( k text, v integer );`, drop: `drop table kv;`, } RunWithSchema(schema, t, func(db *DB, t *testing.T) { type WrongTypes struct { K int V string } _, err := db.Exec(db.Rebind("INSERT INTO kv (k, v) VALUES (?, ?)"), "hi", 1) if err != nil { t.Error(err) } rows, err := db.Queryx("SELECT * FROM kv") if err != nil { t.Error(err) } for rows.Next() { var wt WrongTypes err := rows.StructScan(&wt) if err == nil { t.Errorf("%s: Scanning wrong types into keys should have errored.", db.DriverName()) } } }) } func TestUsage(t *testing.T) { RunWithSchema(defaultSchema, t, func(db *DB, t *testing.T) { loadDefaultFixture(db, t) slicemembers := []SliceMember{} err := db.Select(&slicemembers, "SELECT * FROM place ORDER BY telcode ASC") if err != nil { t.Fatal(err) } people := []Person{} err = db.Select(&people, "SELECT * FROM person ORDER BY first_name ASC") if err != nil { t.Fatal(err) } jason, john := people[0], people[1] if jason.FirstName != "Jason" { t.Errorf("Expecting FirstName of Jason, got %s", jason.FirstName) } if jason.LastName != "Moiron" { t.Errorf("Expecting LastName of Moiron, got %s", jason.LastName) } if jason.Email != "jmoiron@jmoiron.net" { t.Errorf("Expecting Email of jmoiron@jmoiron.net, got %s", jason.Email) } if john.FirstName != "John" || john.LastName != "Doe" || john.Email != "johndoeDNE@gmail.net" { t.Errorf("John Doe's person record not what expected: Got %v\n", john) } jason = Person{} err = db.Get(&jason, db.Rebind("SELECT * FROM person WHERE first_name=?"), "Jason") if err != nil { t.Fatal(err) } if jason.FirstName != "Jason" { t.Errorf("Expecting to get back Jason, but got %v\n", jason.FirstName) } err = db.Get(&jason, db.Rebind("SELECT * FROM person WHERE first_name=?"), "Foobar") if err == nil { t.Errorf("Expecting an error, got nil\n") } if err != sql.ErrNoRows { t.Errorf("Expected sql.ErrNoRows, got %v\n", err) } // The following tests check statement reuse, which was actually a problem // due to copying being done when creating Stmt's which was eventually removed stmt1, err := db.Preparex(db.Rebind("SELECT * FROM person WHERE first_name=?")) if err != nil { t.Fatal(err) } jason = Person{} row := stmt1.QueryRowx("DoesNotExist") row.Scan(&jason) row = stmt1.QueryRowx("DoesNotExist") row.Scan(&jason) err = stmt1.Get(&jason, "DoesNotExist User") if err == nil { t.Error("Expected an error") } err = stmt1.Get(&jason, "DoesNotExist User 2") stmt2, err := db.Preparex(db.Rebind("SELECT * FROM person WHERE first_name=?")) if err != nil { t.Fatal(err) } jason = Person{} tx, err := db.Beginx() if err != nil { t.Fatal(err) } tstmt2 := tx.Stmtx(stmt2) row2 := tstmt2.QueryRowx("Jason") err = row2.StructScan(&jason) if err != nil { t.Error(err) } tx.Commit() places := []*Place{} err = db.Select(&places, "SELECT telcode FROM place ORDER BY telcode ASC") usa, singsing, honkers := places[0], places[1], places[2] if usa.TelCode != 1 || honkers.TelCode != 852 || singsing.TelCode != 65 { t.Errorf("Expected integer telcodes to work, got %#v", places) } placesptr := []PlacePtr{} err = db.Select(&placesptr, "SELECT * FROM place ORDER BY telcode ASC") if err != nil { t.Error(err) } //fmt.Printf("%#v\n%#v\n%#v\n", placesptr[0], placesptr[1], placesptr[2]) // if you have null fields and use SELECT *, you must use sql.Null* in your struct // this test also verifies that you can use either a []Struct{} or a []*Struct{} places2 := []Place{} err = db.Select(&places2, "SELECT * FROM place ORDER BY telcode ASC") usa, singsing, honkers = &places2[0], &places2[1], &places2[2] // this should return a type error that &p is not a pointer to a struct slice p := Place{} err = db.Select(&p, "SELECT * FROM place ORDER BY telcode ASC") if err == nil { t.Errorf("Expected an error, argument to select should be a pointer to a struct slice") } // this should be an error pl := []Place{} err = db.Select(pl, "SELECT * FROM place ORDER BY telcode ASC") if err == nil { t.Errorf("Expected an error, argument to select should be a pointer to a struct slice, not a slice.") } if usa.TelCode != 1 || honkers.TelCode != 852 || singsing.TelCode != 65 { t.Errorf("Expected integer telcodes to work, got %#v", places) } stmt, err := db.Preparex(db.Rebind("SELECT country, telcode FROM place WHERE telcode > ? ORDER BY telcode ASC")) if err != nil { t.Error(err) } places = []*Place{} err = stmt.Select(&places, 10) if len(places) != 2 { t.Error("Expected 2 places, got 0.") } if err != nil { t.Fatal(err) } singsing, honkers = places[0], places[1] if singsing.TelCode != 65 || honkers.TelCode != 852 { t.Errorf("Expected the right telcodes, got %#v", places) } rows, err := db.Queryx("SELECT * FROM place") if err != nil { t.Fatal(err) } place := Place{} for rows.Next() { err = rows.StructScan(&place) if err != nil { t.Fatal(err) } } rows, err = db.Queryx("SELECT * FROM place") if err != nil { t.Fatal(err) } m := map[string]interface{}{} for rows.Next() { err = rows.MapScan(m) if err != nil { t.Fatal(err) } _, ok := m["country"] if !ok { t.Errorf("Expected key `country` in map but could not find it (%#v)\n", m) } } rows, err = db.Queryx("SELECT * FROM place") if err != nil { t.Fatal(err) } for rows.Next() { s, err := rows.SliceScan() if err != nil { t.Error(err) } if len(s) != 3 { t.Errorf("Expected 3 columns in result, got %d\n", len(s)) } } // test advanced querying // test that NamedExec works with a map as well as a struct _, err = db.NamedExec("INSERT INTO person (first_name, last_name, email) VALUES (:first, :last, :email)", map[string]interface{}{ "first": "Bin", "last": "Smuth", "email": "bensmith@allblacks.nz", }) if err != nil { t.Fatal(err) } // ensure that if the named param happens right at the end it still works // ensure that NamedQuery works with a map[string]interface{} rows, err = db.NamedQuery("SELECT * FROM person WHERE first_name=:first", map[string]interface{}{"first": "Bin"}) if err != nil { t.Fatal(err) } ben := &Person{} for rows.Next() { err = rows.StructScan(ben) if err != nil { t.Fatal(err) } if ben.FirstName != "Bin" { t.Fatal("Expected first name of `Bin`, got " + ben.FirstName) } if ben.LastName != "Smuth" { t.Fatal("Expected first name of `Smuth`, got " + ben.LastName) } } ben.FirstName = "Ben" ben.LastName = "Smith" // Insert via a named query using the struct _, err = db.NamedExec("INSERT INTO person (first_name, last_name, email) VALUES (:first_name, :last_name, :email)", ben) if err != nil { t.Fatal(err) } rows, err = db.NamedQuery("SELECT * FROM person WHERE first_name=:first_name", ben) if err != nil { t.Fatal(err) } for rows.Next() { err = rows.StructScan(ben) if err != nil { t.Fatal(err) } if ben.FirstName != "Ben" { t.Fatal("Expected first name of `Ben`, got " + ben.FirstName) } if ben.LastName != "Smith" { t.Fatal("Expected first name of `Smith`, got " + ben.LastName) } } // ensure that Get does not panic on emppty result set person := &Person{} err = db.Get(person, "SELECT * FROM person WHERE first_name=$1", "does-not-exist") if err == nil { t.Fatal("Should have got an error for Get on non-existant row.") } // lets test prepared statements some more stmt, err = db.Preparex(db.Rebind("SELECT * FROM person WHERE first_name=?")) if err != nil { t.Fatal(err) } rows, err = stmt.Queryx("Ben") if err != nil { t.Fatal(err) } for rows.Next() { err = rows.StructScan(ben) if err != nil { t.Fatal(err) } if ben.FirstName != "Ben" { t.Fatal("Expected first name of `Ben`, got " + ben.FirstName) } if ben.LastName != "Smith" { t.Fatal("Expected first name of `Smith`, got " + ben.LastName) } } john = Person{} stmt, err = db.Preparex(db.Rebind("SELECT * FROM person WHERE first_name=?")) if err != nil { t.Error(err) } err = stmt.Get(&john, "John") if err != nil { t.Error(err) } // test name mapping NameMapper = strings.ToUpper rsa := CPlace{} err = db.Get(&rsa, "SELECT * FROM capplace;") if err != nil { fmt.Println(db.DriverName()) t.Error(err) } NameMapper = strings.ToLower }) } type Product struct { ProductID int } // tests that sqlx will not panic when the wrong driver is passed because // of an automatic nil dereference in sqlx.Open(), which was fixed. func TestDoNotPanicOnConnect(t *testing.T) { _, err := Connect("bogus", "hehe") if err == nil { t.Errorf("Should return error when using bogus driverName") } } func TestRebind(t *testing.T) { q1 := `INSERT INTO foo (a, b, c, d, e, f, g, h, i) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` q2 := `INSERT INTO foo (a, b, c) VALUES (?, ?, "foo"), ("Hi", ?, ?)` s1 := Rebind(DOLLAR, q1) s2 := Rebind(DOLLAR, q2) if s1 != `INSERT INTO foo (a, b, c, d, e, f, g, h, i) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)` { t.Errorf("q1 failed") } if s2 != `INSERT INTO foo (a, b, c) VALUES ($1, $2, "foo"), ("Hi", $3, $4)` { t.Errorf("q2 failed") } } func TestBindMap(t *testing.T) { // Test that it works.. q1 := `INSERT INTO foo (a, b, c, d) VALUES (:name, :age, :first, :last)` am := map[string]interface{}{ "name": "Jason Moiron", "age": 30, "first": "Jason", "last": "Moiron", } bq, args, _ := BindMap(QUESTION, q1, am) expect := `INSERT INTO foo (a, b, c, d) VALUES (?, ?, ?, ?)` if bq != expect { t.Errorf("Interpolation of query failed: got `%v`, expected `%v`\n", bq, expect) } if args[0].(string) != "Jason Moiron" { t.Errorf("Expected `Jason Moiron`, got %v\n", args[0]) } if args[1].(int) != 30 { t.Errorf("Expected 30, got %v\n", args[1]) } if args[2].(string) != "Jason" { t.Errorf("Expected Jason, got %v\n", args[2]) } if args[3].(string) != "Moiron" { t.Errorf("Expected Moiron, got %v\n", args[3]) } } func TestBindStruct(t *testing.T) { var err error q1 := `INSERT INTO foo (a, b, c, d) VALUES (:name, :age, :first, :last)` type tt struct { Name string Age int First string Last string } type tt2 struct { Field1 string `db:"field_1"` Field2 string `db:"field_2"` } type tt3 struct { tt2 Name string } am := tt{"Jason Moiron", 30, "Jason", "Moiron"} bq, args, _ := BindStruct(QUESTION, q1, am) expect := `INSERT INTO foo (a, b, c, d) VALUES (?, ?, ?, ?)` if bq != expect { t.Errorf("Interpolation of query failed: got `%v`, expected `%v`\n", bq, expect) } if args[0].(string) != "Jason Moiron" { t.Errorf("Expected `Jason Moiron`, got %v\n", args[0]) } if args[1].(int) != 30 { t.Errorf("Expected 30, got %v\n", args[1]) } if args[2].(string) != "Jason" { t.Errorf("Expected Jason, got %v\n", args[2]) } if args[3].(string) != "Moiron" { t.Errorf("Expected Moiron, got %v\n", args[3]) } am2 := tt2{"Hello", "World"} bq, args, _ = BindStruct(QUESTION, "INSERT INTO foo (a, b) VALUES (:field_2, :field_1)", am2) expect = `INSERT INTO foo (a, b) VALUES (?, ?)` if bq != expect { t.Errorf("Interpolation of query failed: got `%v`, expected `%v`\n", bq, expect) } if args[0].(string) != "World" { t.Errorf("Expected 'World', got %s\n", args[0].(string)) } if args[1].(string) != "Hello" { t.Errorf("Expected 'Hello', got %s\n", args[1].(string)) } am3 := tt3{Name: "Hello!"} am3.Field1 = "Hello" am3.Field2 = "World" bq, args, err = BindStruct(QUESTION, "INSERT INTO foo (a, b, c) VALUES (:name, :field_1, :field_2)", am3) if err != nil { t.Fatal(err) } expect = `INSERT INTO foo (a, b, c) VALUES (?, ?, ?)` if bq != expect { t.Errorf("Interpolation of query failed: got `%v`, expected `%v`\n", bq, expect) } if args[0].(string) != "Hello!" { t.Errorf("Expected 'Hello!', got %s\n", args[0].(string)) } if args[1].(string) != "Hello" { t.Errorf("Expected 'Hello', got %s\n", args[1].(string)) } if args[2].(string) != "World" { t.Errorf("Expected 'World', got %s\n", args[0].(string)) } } func BenchmarkBindStruct(b *testing.B) { b.StopTimer() q1 := `INSERT INTO foo (a, b, c, d) VALUES (:name, :age, :first, :last)` type t struct { Name string Age int First string Last string } am := t{"Jason Moiron", 30, "Jason", "Moiron"} b.StartTimer() for i := 0; i < b.N; i++ { BindStruct(DOLLAR, q1, am) //bindMap(QUESTION, q1, am) } } func BenchmarkBindMap(b *testing.B) { b.StopTimer() q1 := `INSERT INTO foo (a, b, c, d) VALUES (:name, :age, :first, :last)` am := map[string]interface{}{ "name": "Jason Moiron", "age": 30, "first": "Jason", "last": "Moiron", } b.StartTimer() for i := 0; i < b.N; i++ { BindMap(DOLLAR, q1, am) //bindMap(QUESTION, q1, am) } } func BenchmarkRebind(b *testing.B) { b.StopTimer() q1 := `INSERT INTO foo (a, b, c, d, e, f, g, h, i) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)` q2 := `INSERT INTO foo (a, b, c) VALUES (?, ?, "foo"), ("Hi", ?, ?)` b.StartTimer() for i := 0; i < b.N; i++ { Rebind(DOLLAR, q1) Rebind(DOLLAR, q2) } } func BenchmarkRebindBuffer(b *testing.B) { b.StopTimer() q1 := `INSERT INTO foo (a, b, c, d, e, f, g, h, i) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)` q2 := `INSERT INTO foo (a, b, c) VALUES (?, ?, "foo"), ("Hi", ?, ?)` b.StartTimer() for i := 0; i < b.N; i++ { rebindBuff(DOLLAR, q1) rebindBuff(DOLLAR, q2) } } func TestGetFieldMap(t *testing.T) { testingTable := map[reflect.Type]fieldMap{ reflect.TypeOf(new(Person)): {"first_name": 0, "last_name": 1, "email": 2, "added_at": 3}, reflect.TypeOf(new(Place)): {"country": 0, "city": 1, "telcode": 2}, reflect.TypeOf(new(PersonPlace)): { "first_name": 0, "last_name": 1, "email": 2, "added_at": 3, "country": 4, "city": 5, "telcode": 6}, reflect.TypeOf(new(PersonPlacePtr)): { "first_name": 0, "last_name": 1, "email": 2, "added_at": 3, "country": 4, "city": 5, "telcode": 6}, } for typ, expected := range testingTable { fields, err := getFieldMap(typ) if err != nil { t.Fatal(err) } if !reflect.DeepEqual(fields, expected) { t.Fatalf("Fieldmap error: got `%v`, expected `%v`", fields, expected) } } } sqlx-sqlx-v1.0/types/000077500000000000000000000000001232764233400146665ustar00rootroot00000000000000sqlx-sqlx-v1.0/types/types.go000066400000000000000000000043011232764233400163570ustar00rootroot00000000000000package types import ( "bytes" "compress/gzip" "database/sql/driver" "encoding/json" "errors" "io/ioutil" ) type GzippedText []byte func (g GzippedText) Value() (driver.Value, error) { b := make([]byte, 0, len(g)) buf := bytes.NewBuffer(b) w := gzip.NewWriter(buf) w.Write(g) w.Close() return buf.Bytes(), nil } func (g *GzippedText) Scan(src interface{}) error { var source []byte switch src.(type) { case string: source = []byte(src.(string)) case []byte: source = src.([]byte) default: return errors.New("Incompatible type for GzippedText") } reader, err := gzip.NewReader(bytes.NewReader(source)) defer reader.Close() b, err := ioutil.ReadAll(reader) if err != nil { return err } *g = GzippedText(b) return nil } // JsonText is a json.RawMessage, which is a []byte underneath. // Value() validates the json format in the source, and returns an error if // the json is not valid. Scan does no validation. JsonText additionally // implements `Unmarshal`, which unmarshals the json within to an interface{} type JsonText json.RawMessage // Returns the *j as the JSON encoding of j. func (j *JsonText) MarshalJSON() ([]byte, error) { return *j, nil } // UnmarshalJSON sets *j to a copy of data func (j *JsonText) UnmarshalJSON(data []byte) error { if j == nil { return errors.New("JsonText: UnmarshalJSON on nil pointer") } *j = append((*j)[0:0], data...) return nil } // Value returns j as a value. This does a validating unmarshal into another // RawMessage. If j is invalid json, it returns an error. func (j JsonText) Value() (driver.Value, error) { var m json.RawMessage var err = j.Unmarshal(&m) if err != nil { return []byte{}, err } return []byte(j), nil } // Scan stores the src in *j. No validation is done. func (j *JsonText) Scan(src interface{}) error { var source []byte switch src.(type) { case string: source = []byte(src.(string)) case []byte: source = src.([]byte) default: return errors.New("Incompatible type for JsonText") } *j = JsonText(append((*j)[0:0], source...)) return nil } // Unmarshal unmarshal's the json in j to v, as in json.Unmarshal. func (j *JsonText) Unmarshal(v interface{}) error { return json.Unmarshal([]byte(*j), v) } sqlx-sqlx-v1.0/types/types_test.go000066400000000000000000000016541232764233400174260ustar00rootroot00000000000000package types import "testing" func TestGzipText(t *testing.T) { g := GzippedText("Hello, world") v, err := g.Value() if err != nil { t.Errorf("Was not expecting an error") } err = (&g).Scan(v) if err != nil { t.Errorf("Was not expecting an error") } if string(g) != "Hello, world" { t.Errorf("Was expecting the string we sent in (Hello World), got %s", string(g)) } } func TestJsonText(t *testing.T) { j := JsonText(`{"foo": 1, "bar": 2}`) v, err := j.Value() if err != nil { t.Errorf("Was not expecting an error") } err = (&j).Scan(v) if err != nil { t.Errorf("Was not expecting an error") } m := map[string]interface{}{} j.Unmarshal(&m) if m["foo"].(float64) != 1 || m["bar"].(float64) != 2 { t.Errorf("Expected valid json but got some garbage instead? %#v", m) } j = JsonText(`{"foo": 1, invalid, false}`) v, err = j.Value() if err == nil { t.Errorf("Was expecting invalid json to fail!") } }