| // +build go1.8 | |
| // 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 ( | |
| "context" | |
| "database/sql" | |
| "encoding/json" | |
| "fmt" | |
| "log" | |
| "strings" | |
| "testing" | |
| "time" | |
| _ "github.com/go-sql-driver/mysql" | |
| "github.com/jmoiron/sqlx/reflectx" | |
| _ "github.com/lib/pq" | |
| _ "github.com/mattn/go-sqlite3" | |
| ) | |
| func MultiExecContext(ctx context.Context, e ExecerContext, 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.ExecContext(ctx, s) | |
| if err != nil { | |
| fmt.Println(err, s) | |
| } | |
| } | |
| } | |
| func RunWithSchemaContext(ctx context.Context, schema Schema, t *testing.T, test func(ctx context.Context, db *DB, t *testing.T)) { | |
| runner := func(ctx context.Context, db *DB, t *testing.T, create, drop string) { | |
| defer func() { | |
| MultiExecContext(ctx, db, drop) | |
| }() | |
| MultiExecContext(ctx, db, create) | |
| test(ctx, db, t) | |
| } | |
| if TestPostgres { | |
| create, drop := schema.Postgres() | |
| runner(ctx, pgdb, t, create, drop) | |
| } | |
| if TestSqlite { | |
| create, drop := schema.Sqlite3() | |
| runner(ctx, sldb, t, create, drop) | |
| } | |
| if TestMysql { | |
| create, drop := schema.MySQL() | |
| runner(ctx, mysqldb, t, create, drop) | |
| } | |
| } | |
| func loadDefaultFixtureContext(ctx context.Context, db *DB, t *testing.T) { | |
| tx := db.MustBeginTx(ctx, nil) | |
| tx.MustExecContext(ctx, tx.Rebind("INSERT INTO person (first_name, last_name, email) VALUES (?, ?, ?)"), "Jason", "Moiron", "jmoiron@jmoiron.net") | |
| tx.MustExecContext(ctx, tx.Rebind("INSERT INTO person (first_name, last_name, email) VALUES (?, ?, ?)"), "John", "Doe", "johndoeDNE@gmail.net") | |
| tx.MustExecContext(ctx, tx.Rebind("INSERT INTO place (country, city, telcode) VALUES (?, ?, ?)"), "United States", "New York", "1") | |
| tx.MustExecContext(ctx, tx.Rebind("INSERT INTO place (country, telcode) VALUES (?, ?)"), "Hong Kong", "852") | |
| tx.MustExecContext(ctx, tx.Rebind("INSERT INTO place (country, telcode) VALUES (?, ?)"), "Singapore", "65") | |
| if db.DriverName() == "mysql" { | |
| tx.MustExecContext(ctx, tx.Rebind("INSERT INTO capplace (`COUNTRY`, `TELCODE`) VALUES (?, ?)"), "Sarf Efrica", "27") | |
| } else { | |
| tx.MustExecContext(ctx, tx.Rebind("INSERT INTO capplace (\"COUNTRY\", \"TELCODE\") VALUES (?, ?)"), "Sarf Efrica", "27") | |
| } | |
| tx.MustExecContext(ctx, tx.Rebind("INSERT INTO employees (name, id) VALUES (?, ?)"), "Peter", "4444") | |
| tx.MustExecContext(ctx, tx.Rebind("INSERT INTO employees (name, id, boss_id) VALUES (?, ?, ?)"), "Joe", "1", "4444") | |
| tx.MustExecContext(ctx, tx.Rebind("INSERT INTO employees (name, id, boss_id) VALUES (?, ?, ?)"), "Martin", "2", "4444") | |
| tx.Commit() | |
| } | |
| // Test a new backwards compatible feature, that missing scan destinations | |
| // will silently scan into sql.RawText rather than failing/panicing | |
| func TestMissingNamesContextContext(t *testing.T) { | |
| RunWithSchemaContext(context.Background(), defaultSchema, t, func(ctx context.Context, db *DB, t *testing.T) { | |
| loadDefaultFixtureContext(ctx, 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.SelectContext(ctx, &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.GetContext(ctx, &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.QueryContext(ctx, "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.SelectContext(ctx, &pps, "SELECT * FROM person") | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| // test Get | |
| pp = PersonPlus{} | |
| err = db.GetContext(ctx, &pp, "SELECT * FROM person LIMIT 1") | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| // test naked StructScan | |
| pps = []PersonPlus{} | |
| rowsx, err := db.QueryxContext(ctx, "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() | |
| // test Named stmt | |
| if !isUnsafe(db) { | |
| t.Error("Expected db to be unsafe, but it isn't") | |
| } | |
| nstmt, err := db.PrepareNamedContext(ctx, `SELECT * FROM person WHERE first_name != :name`) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| // its internal stmt should be marked unsafe | |
| if !nstmt.Stmt.unsafe { | |
| t.Error("expected NamedStmt to be unsafe but its underlying stmt did not inherit safety") | |
| } | |
| pps = []PersonPlus{} | |
| err = nstmt.SelectContext(ctx, &pps, map[string]interface{}{"name": "Jason"}) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if len(pps) != 1 { | |
| t.Errorf("Expected 1 person back, got %d", len(pps)) | |
| } | |
| // test it with a safe db | |
| db.unsafe = false | |
| if isUnsafe(db) { | |
| t.Error("expected db to be safe but it isn't") | |
| } | |
| nstmt, err = db.PrepareNamedContext(ctx, `SELECT * FROM person WHERE first_name != :name`) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| // it should be safe | |
| if isUnsafe(nstmt) { | |
| t.Error("NamedStmt did not inherit safety") | |
| } | |
| nstmt.Unsafe() | |
| if !isUnsafe(nstmt) { | |
| t.Error("expected newly unsafed NamedStmt to be unsafe") | |
| } | |
| pps = []PersonPlus{} | |
| err = nstmt.SelectContext(ctx, &pps, map[string]interface{}{"name": "Jason"}) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if len(pps) != 1 { | |
| t.Errorf("Expected 1 person back, got %d", len(pps)) | |
| } | |
| }) | |
| } | |
| func TestEmbeddedStructsContextContext(t *testing.T) { | |
| type Loop1 struct{ Person } | |
| type Loop2 struct{ Loop1 } | |
| type Loop3 struct{ Loop2 } | |
| RunWithSchemaContext(context.Background(), defaultSchema, t, func(ctx context.Context, db *DB, t *testing.T) { | |
| loadDefaultFixtureContext(ctx, db, t) | |
| peopleAndPlaces := []PersonPlace{} | |
| err := db.SelectContext( | |
| ctx, | |
| &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.QueryxContext( | |
| ctx, | |
| `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.SelectContext( | |
| ctx, | |
| &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 "deep nesting" | |
| l3s := []Loop3{} | |
| err = db.SelectContext(ctx, &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.SelectContext(ctx, &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 TestJoinQueryContext(t *testing.T) { | |
| type Employee struct { | |
| Name string | |
| ID int64 | |
| // BossID is an id into the employee table | |
| BossID sql.NullInt64 `db:"boss_id"` | |
| } | |
| type Boss Employee | |
| RunWithSchemaContext(context.Background(), defaultSchema, t, func(ctx context.Context, db *DB, t *testing.T) { | |
| loadDefaultFixtureContext(ctx, db, t) | |
| var employees []struct { | |
| Employee | |
| Boss `db:"boss"` | |
| } | |
| err := db.SelectContext(ctx, | |
| &employees, | |
| `SELECT employees.*, boss.id "boss.id", boss.name "boss.name" FROM employees | |
| JOIN employees AS boss ON employees.boss_id = boss.id`) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| for _, em := range employees { | |
| if len(em.Employee.Name) == 0 { | |
| t.Errorf("Expected non zero lengthed name.") | |
| } | |
| if em.Employee.BossID.Int64 != em.Boss.ID { | |
| t.Errorf("Expected boss ids to match") | |
| } | |
| } | |
| }) | |
| } | |
| func TestJoinQueryNamedPointerStructsContext(t *testing.T) { | |
| type Employee struct { | |
| Name string | |
| ID int64 | |
| // BossID is an id into the employee table | |
| BossID sql.NullInt64 `db:"boss_id"` | |
| } | |
| type Boss Employee | |
| RunWithSchemaContext(context.Background(), defaultSchema, t, func(ctx context.Context, db *DB, t *testing.T) { | |
| loadDefaultFixtureContext(ctx, db, t) | |
| var employees []struct { | |
| Emp1 *Employee `db:"emp1"` | |
| Emp2 *Employee `db:"emp2"` | |
| *Boss `db:"boss"` | |
| } | |
| err := db.SelectContext(ctx, | |
| &employees, | |
| `SELECT emp.name "emp1.name", emp.id "emp1.id", emp.boss_id "emp1.boss_id", | |
| emp.name "emp2.name", emp.id "emp2.id", emp.boss_id "emp2.boss_id", | |
| boss.id "boss.id", boss.name "boss.name" FROM employees AS emp | |
| JOIN employees AS boss ON emp.boss_id = boss.id | |
| `) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| for _, em := range employees { | |
| if len(em.Emp1.Name) == 0 || len(em.Emp2.Name) == 0 { | |
| t.Errorf("Expected non zero lengthed name.") | |
| } | |
| if em.Emp1.BossID.Int64 != em.Boss.ID || em.Emp2.BossID.Int64 != em.Boss.ID { | |
| t.Errorf("Expected boss ids to match") | |
| } | |
| } | |
| }) | |
| } | |
| func TestSelectSliceMapTimeContext(t *testing.T) { | |
| RunWithSchemaContext(context.Background(), defaultSchema, t, func(ctx context.Context, db *DB, t *testing.T) { | |
| loadDefaultFixtureContext(ctx, db, t) | |
| rows, err := db.QueryxContext(ctx, "SELECT * FROM person") | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| for rows.Next() { | |
| _, err := rows.SliceScan() | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| } | |
| rows, err = db.QueryxContext(ctx, "SELECT * FROM person") | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| for rows.Next() { | |
| m := map[string]interface{}{} | |
| err := rows.MapScan(m) | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| } | |
| }) | |
| } | |
| func TestNilReceiverContext(t *testing.T) { | |
| RunWithSchemaContext(context.Background(), defaultSchema, t, func(ctx context.Context, db *DB, t *testing.T) { | |
| loadDefaultFixtureContext(ctx, db, t) | |
| var p *Person | |
| err := db.GetContext(ctx, p, "SELECT * FROM person LIMIT 1") | |
| if err == nil { | |
| t.Error("Expected error when getting into nil struct ptr.") | |
| } | |
| var pp *[]Person | |
| err = db.SelectContext(ctx, pp, "SELECT * FROM person") | |
| if err == nil { | |
| t.Error("Expected an error when selecting into nil slice ptr.") | |
| } | |
| }) | |
| } | |
| func TestNamedQueryContext(t *testing.T) { | |
| var schema = Schema{ | |
| create: ` | |
| CREATE TABLE place ( | |
| id integer PRIMARY KEY, | |
| name text NULL | |
| ); | |
| CREATE TABLE person ( | |
| first_name text NULL, | |
| last_name text NULL, | |
| email text NULL | |
| ); | |
| CREATE TABLE placeperson ( | |
| first_name text NULL, | |
| last_name text NULL, | |
| email text NULL, | |
| place_id integer NULL | |
| ); | |
| CREATE TABLE jsperson ( | |
| "FIRST" text NULL, | |
| last_name text NULL, | |
| "EMAIL" text NULL | |
| );`, | |
| drop: ` | |
| drop table person; | |
| drop table jsperson; | |
| drop table place; | |
| drop table placeperson; | |
| `, | |
| } | |
| RunWithSchemaContext(context.Background(), schema, t, func(ctx context.Context, 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{String: "ben", Valid: true}, | |
| LastName: sql.NullString{String: "doe", Valid: true}, | |
| Email: sql.NullString{String: "ben@doe.com", Valid: true}, | |
| } | |
| q1 := `INSERT INTO person (first_name, last_name, email) VALUES (:first_name, :last_name, :email)` | |
| _, err := db.NamedExecContext(ctx, q1, p) | |
| if err != nil { | |
| log.Fatal(err) | |
| } | |
| p2 := &Person{} | |
| rows, err := db.NamedQueryContext(ctx, "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) | |
| } | |
| } | |
| // these are tests for #73; they verify that named queries work if you've | |
| // changed the db mapper. This code checks both NamedQuery "ad-hoc" style | |
| // queries and NamedStmt queries, which use different code paths internally. | |
| old := *db.Mapper | |
| type JSONPerson struct { | |
| FirstName sql.NullString `json:"FIRST"` | |
| LastName sql.NullString `json:"last_name"` | |
| Email sql.NullString | |
| } | |
| jp := JSONPerson{ | |
| FirstName: sql.NullString{String: "ben", Valid: true}, | |
| LastName: sql.NullString{String: "smith", Valid: true}, | |
| Email: sql.NullString{String: "ben@smith.com", Valid: true}, | |
| } | |
| db.Mapper = reflectx.NewMapperFunc("json", strings.ToUpper) | |
| // prepare queries for case sensitivity to test our ToUpper function. | |
| // postgres and sqlite accept "", but mysql uses ``; since Go's multi-line | |
| // strings are `` we use "" by default and swap out for MySQL | |
| pdb := func(s string, db *DB) string { | |
| if db.DriverName() == "mysql" { | |
| return strings.Replace(s, `"`, "`", -1) | |
| } | |
| return s | |
| } | |
| q1 = `INSERT INTO jsperson ("FIRST", last_name, "EMAIL") VALUES (:FIRST, :last_name, :EMAIL)` | |
| _, err = db.NamedExecContext(ctx, pdb(q1, db), jp) | |
| if err != nil { | |
| t.Fatal(err, db.DriverName()) | |
| } | |
| // Checks that a person pulled out of the db matches the one we put in | |
| check := func(t *testing.T, rows *Rows) { | |
| jp = JSONPerson{} | |
| for rows.Next() { | |
| err = rows.StructScan(&jp) | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| if jp.FirstName.String != "ben" { | |
| t.Errorf("Expected first name of `ben`, got `%s` (%s) ", jp.FirstName.String, db.DriverName()) | |
| } | |
| if jp.LastName.String != "smith" { | |
| t.Errorf("Expected LastName of `smith`, got `%s` (%s)", jp.LastName.String, db.DriverName()) | |
| } | |
| if jp.Email.String != "ben@smith.com" { | |
| t.Errorf("Expected first name of `doe`, got `%s` (%s)", jp.Email.String, db.DriverName()) | |
| } | |
| } | |
| } | |
| ns, err := db.PrepareNamed(pdb(` | |
| SELECT * FROM jsperson | |
| WHERE | |
| "FIRST"=:FIRST AND | |
| last_name=:last_name AND | |
| "EMAIL"=:EMAIL | |
| `, db)) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| rows, err = ns.QueryxContext(ctx, jp) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| check(t, rows) | |
| // Check exactly the same thing, but with db.NamedQuery, which does not go | |
| // through the PrepareNamed/NamedStmt path. | |
| rows, err = db.NamedQueryContext(ctx, pdb(` | |
| SELECT * FROM jsperson | |
| WHERE | |
| "FIRST"=:FIRST AND | |
| last_name=:last_name AND | |
| "EMAIL"=:EMAIL | |
| `, db), jp) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| check(t, rows) | |
| db.Mapper = &old | |
| // Test nested structs | |
| type Place struct { | |
| ID int `db:"id"` | |
| Name sql.NullString `db:"name"` | |
| } | |
| type PlacePerson struct { | |
| FirstName sql.NullString `db:"first_name"` | |
| LastName sql.NullString `db:"last_name"` | |
| Email sql.NullString | |
| Place Place `db:"place"` | |
| } | |
| pl := Place{ | |
| Name: sql.NullString{String: "myplace", Valid: true}, | |
| } | |
| pp := PlacePerson{ | |
| FirstName: sql.NullString{String: "ben", Valid: true}, | |
| LastName: sql.NullString{String: "doe", Valid: true}, | |
| Email: sql.NullString{String: "ben@doe.com", Valid: true}, | |
| } | |
| q2 := `INSERT INTO place (id, name) VALUES (1, :name)` | |
| _, err = db.NamedExecContext(ctx, q2, pl) | |
| if err != nil { | |
| log.Fatal(err) | |
| } | |
| id := 1 | |
| pp.Place.ID = id | |
| q3 := `INSERT INTO placeperson (first_name, last_name, email, place_id) VALUES (:first_name, :last_name, :email, :place.id)` | |
| _, err = db.NamedExecContext(ctx, q3, pp) | |
| if err != nil { | |
| log.Fatal(err) | |
| } | |
| pp2 := &PlacePerson{} | |
| rows, err = db.NamedQueryContext(ctx, ` | |
| SELECT | |
| first_name, | |
| last_name, | |
| email, | |
| place.id AS "place.id", | |
| place.name AS "place.name" | |
| FROM placeperson | |
| INNER JOIN place ON place.id = placeperson.place_id | |
| WHERE | |
| place.id=:place.id`, pp) | |
| if err != nil { | |
| log.Fatal(err) | |
| } | |
| for rows.Next() { | |
| err = rows.StructScan(pp2) | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| if pp2.FirstName.String != "ben" { | |
| t.Error("Expected first name of `ben`, got " + pp2.FirstName.String) | |
| } | |
| if pp2.LastName.String != "doe" { | |
| t.Error("Expected first name of `doe`, got " + pp2.LastName.String) | |
| } | |
| if pp2.Place.Name.String != "myplace" { | |
| t.Error("Expected place name of `myplace`, got " + pp2.Place.Name.String) | |
| } | |
| if pp2.Place.ID != pp.Place.ID { | |
| t.Errorf("Expected place name of %v, got %v", pp.Place.ID, pp2.Place.ID) | |
| } | |
| } | |
| }) | |
| } | |
| func TestNilInsertsContext(t *testing.T) { | |
| var schema = Schema{ | |
| create: ` | |
| CREATE TABLE tt ( | |
| id integer, | |
| value text NULL DEFAULT NULL | |
| );`, | |
| drop: "drop table tt;", | |
| } | |
| RunWithSchemaContext(context.Background(), schema, t, func(ctx context.Context, db *DB, t *testing.T) { | |
| type TT struct { | |
| ID int | |
| Value *string | |
| } | |
| var v, v2 TT | |
| r := db.Rebind | |
| db.MustExecContext(ctx, r(`INSERT INTO tt (id) VALUES (1)`)) | |
| db.GetContext(ctx, &v, r(`SELECT * FROM tt`)) | |
| if v.ID != 1 { | |
| t.Errorf("Expecting id of 1, got %v", v.ID) | |
| } | |
| if v.Value != nil { | |
| t.Errorf("Expecting NULL to map to nil, got %s", *v.Value) | |
| } | |
| v.ID = 2 | |
| // NOTE: this incidentally uncovered a bug which was that named queries with | |
| // pointer destinations would not work if the passed value here was not addressable, | |
| // as reflectx.FieldByIndexes attempts to allocate nil pointer receivers for | |
| // writing. This was fixed by creating & using the reflectx.FieldByIndexesReadOnly | |
| // function. This next line is important as it provides the only coverage for this. | |
| db.NamedExecContext(ctx, `INSERT INTO tt (id, value) VALUES (:id, :value)`, v) | |
| db.GetContext(ctx, &v2, r(`SELECT * FROM tt WHERE id=2`)) | |
| if v.ID != v2.ID { | |
| t.Errorf("%v != %v", v.ID, v2.ID) | |
| } | |
| if v2.Value != nil { | |
| t.Errorf("Expecting NULL to map to nil, got %s", *v.Value) | |
| } | |
| }) | |
| } | |
| func TestScanErrorContext(t *testing.T) { | |
| var schema = Schema{ | |
| create: ` | |
| CREATE TABLE kv ( | |
| k text, | |
| v integer | |
| );`, | |
| drop: `drop table kv;`, | |
| } | |
| RunWithSchemaContext(context.Background(), schema, t, func(ctx context.Context, 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.QueryxContext(ctx, "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()) | |
| } | |
| } | |
| }) | |
| } | |
| // FIXME: this function is kinda big but it slows things down to be constantly | |
| // loading and reloading the schema.. | |
| func TestUsageContext(t *testing.T) { | |
| RunWithSchemaContext(context.Background(), defaultSchema, t, func(ctx context.Context, db *DB, t *testing.T) { | |
| loadDefaultFixtureContext(ctx, db, t) | |
| slicemembers := []SliceMember{} | |
| err := db.SelectContext(ctx, &slicemembers, "SELECT * FROM place ORDER BY telcode ASC") | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| people := []Person{} | |
| err = db.SelectContext(ctx, &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.GetContext(ctx, &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.GetContext(ctx, &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.PreparexContext(ctx, 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.GetContext(ctx, &jason, "DoesNotExist User") | |
| if err == nil { | |
| t.Error("Expected an error") | |
| } | |
| err = stmt1.GetContext(ctx, &jason, "DoesNotExist User 2") | |
| if err == nil { | |
| t.Fatal(err) | |
| } | |
| stmt2, err := db.PreparexContext(ctx, 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.SelectContext(ctx, &places, "SELECT telcode FROM place ORDER BY telcode ASC") | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| 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.SelectContext(ctx, &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.SelectContext(ctx, &places2, "SELECT * FROM place ORDER BY telcode ASC") | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| 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.SelectContext(ctx, &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.SelectContext(ctx, 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.PreparexContext(ctx, db.Rebind("SELECT country, telcode FROM place WHERE telcode > ? ORDER BY telcode ASC")) | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| places = []*Place{} | |
| err = stmt.SelectContext(ctx, &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.QueryxContext(ctx, "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.QueryxContext(ctx, "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.QueryxContext(ctx, "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.NamedExecContext(ctx, "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.NamedQueryContext(ctx, "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" | |
| ben.Email = "binsmuth@allblacks.nz" | |
| // Insert via a named query using the struct | |
| _, err = db.NamedExecContext(ctx, "INSERT INTO person (first_name, last_name, email) VALUES (:first_name, :last_name, :email)", ben) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| rows, err = db.NamedQueryContext(ctx, "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.GetContext(ctx, 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-existent row.") | |
| } | |
| // lets test prepared statements some more | |
| stmt, err = db.PreparexContext(ctx, db.Rebind("SELECT * FROM person WHERE first_name=?")) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| rows, err = stmt.QueryxContext(ctx, "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.PreparexContext(ctx, db.Rebind("SELECT * FROM person WHERE first_name=?")) | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| err = stmt.GetContext(ctx, &john, "John") | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| // test name mapping | |
| // THIS USED TO WORK BUT WILL NO LONGER WORK. | |
| db.MapperFunc(strings.ToUpper) | |
| rsa := CPlace{} | |
| err = db.GetContext(ctx, &rsa, "SELECT * FROM capplace;") | |
| if err != nil { | |
| t.Error(err, "in db:", db.DriverName()) | |
| } | |
| db.MapperFunc(strings.ToLower) | |
| // create a copy and change the mapper, then verify the copy behaves | |
| // differently from the original. | |
| dbCopy := NewDb(db.DB, db.DriverName()) | |
| dbCopy.MapperFunc(strings.ToUpper) | |
| err = dbCopy.GetContext(ctx, &rsa, "SELECT * FROM capplace;") | |
| if err != nil { | |
| fmt.Println(db.DriverName()) | |
| t.Error(err) | |
| } | |
| err = db.GetContext(ctx, &rsa, "SELECT * FROM cappplace;") | |
| if err == nil { | |
| t.Error("Expected no error, got ", err) | |
| } | |
| // test base type slices | |
| var sdest []string | |
| rows, err = db.QueryxContext(ctx, "SELECT email FROM person ORDER BY email ASC;") | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| err = scanAll(rows, &sdest, false) | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| // test Get with base types | |
| var count int | |
| err = db.GetContext(ctx, &count, "SELECT count(*) FROM person;") | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| if count != len(sdest) { | |
| t.Errorf("Expected %d == %d (count(*) vs len(SELECT ..)", count, len(sdest)) | |
| } | |
| // test Get and Select with time.Time, #84 | |
| var addedAt time.Time | |
| err = db.GetContext(ctx, &addedAt, "SELECT added_at FROM person LIMIT 1;") | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| var addedAts []time.Time | |
| err = db.SelectContext(ctx, &addedAts, "SELECT added_at FROM person;") | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| // test it on a double pointer | |
| var pcount *int | |
| err = db.GetContext(ctx, &pcount, "SELECT count(*) FROM person;") | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| if *pcount != count { | |
| t.Errorf("expected %d = %d", *pcount, count) | |
| } | |
| // test Select... | |
| sdest = []string{} | |
| err = db.SelectContext(ctx, &sdest, "SELECT first_name FROM person ORDER BY first_name ASC;") | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| expected := []string{"Ben", "Bin", "Jason", "John"} | |
| for i, got := range sdest { | |
| if got != expected[i] { | |
| t.Errorf("Expected %d result to be %s, but got %s", i, expected[i], got) | |
| } | |
| } | |
| var nsdest []sql.NullString | |
| err = db.SelectContext(ctx, &nsdest, "SELECT city FROM place ORDER BY city ASC") | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| for _, val := range nsdest { | |
| if val.Valid && val.String != "New York" { | |
| t.Errorf("expected single valid result to be `New York`, but got %s", val.String) | |
| } | |
| } | |
| }) | |
| } | |
| // 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 TestDoNotPanicOnConnectContext(t *testing.T) { | |
| _, err := ConnectContext(context.Background(), "bogus", "hehe") | |
| if err == nil { | |
| t.Errorf("Should return error when using bogus driverName") | |
| } | |
| } | |
| func TestEmbeddedMapsContext(t *testing.T) { | |
| var schema = Schema{ | |
| create: ` | |
| CREATE TABLE message ( | |
| string text, | |
| properties text | |
| );`, | |
| drop: `drop table message;`, | |
| } | |
| RunWithSchemaContext(context.Background(), schema, t, func(ctx context.Context, db *DB, t *testing.T) { | |
| messages := []Message{ | |
| {"Hello, World", PropertyMap{"one": "1", "two": "2"}}, | |
| {"Thanks, Joy", PropertyMap{"pull": "request"}}, | |
| } | |
| q1 := `INSERT INTO message (string, properties) VALUES (:string, :properties);` | |
| for _, m := range messages { | |
| _, err := db.NamedExecContext(ctx, q1, m) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| } | |
| var count int | |
| err := db.GetContext(ctx, &count, "SELECT count(*) FROM message") | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if count != len(messages) { | |
| t.Fatalf("Expected %d messages in DB, found %d", len(messages), count) | |
| } | |
| var m Message | |
| err = db.GetContext(ctx, &m, "SELECT * FROM message LIMIT 1;") | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if m.Properties == nil { | |
| t.Fatal("Expected m.Properties to not be nil, but it was.") | |
| } | |
| }) | |
| } | |
| func TestIssue197Context(t *testing.T) { | |
| // this test actually tests for a bug in database/sql: | |
| // https://github.com/golang/go/issues/13905 | |
| // this potentially makes _any_ named type that is an alias for []byte | |
| // unsafe to use in a lot of different ways (basically, unsafe to hold | |
| // onto after loading from the database). | |
| t.Skip() | |
| type mybyte []byte | |
| type Var struct{ Raw json.RawMessage } | |
| type Var2 struct{ Raw []byte } | |
| type Var3 struct{ Raw mybyte } | |
| RunWithSchemaContext(context.Background(), defaultSchema, t, func(ctx context.Context, db *DB, t *testing.T) { | |
| var err error | |
| var v, q Var | |
| if err = db.GetContext(ctx, &v, `SELECT '{"a": "b"}' AS raw`); err != nil { | |
| t.Fatal(err) | |
| } | |
| if err = db.GetContext(ctx, &q, `SELECT 'null' AS raw`); err != nil { | |
| t.Fatal(err) | |
| } | |
| var v2, q2 Var2 | |
| if err = db.GetContext(ctx, &v2, `SELECT '{"a": "b"}' AS raw`); err != nil { | |
| t.Fatal(err) | |
| } | |
| if err = db.GetContext(ctx, &q2, `SELECT 'null' AS raw`); err != nil { | |
| t.Fatal(err) | |
| } | |
| var v3, q3 Var3 | |
| if err = db.QueryRowContext(ctx, `SELECT '{"a": "b"}' AS raw`).Scan(&v3.Raw); err != nil { | |
| t.Fatal(err) | |
| } | |
| if err = db.QueryRowContext(ctx, `SELECT '{"c": "d"}' AS raw`).Scan(&q3.Raw); err != nil { | |
| t.Fatal(err) | |
| } | |
| t.Fail() | |
| }) | |
| } | |
| func TestInContext(t *testing.T) { | |
| // some quite normal situations | |
| type tr struct { | |
| q string | |
| args []interface{} | |
| c int | |
| } | |
| tests := []tr{ | |
| {"SELECT * FROM foo WHERE x = ? AND v in (?) AND y = ?", | |
| []interface{}{"foo", []int{0, 5, 7, 2, 9}, "bar"}, | |
| 7}, | |
| {"SELECT * FROM foo WHERE x in (?)", | |
| []interface{}{[]int{1, 2, 3, 4, 5, 6, 7, 8}}, | |
| 8}, | |
| } | |
| for _, test := range tests { | |
| q, a, err := In(test.q, test.args...) | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| if len(a) != test.c { | |
| t.Errorf("Expected %d args, but got %d (%+v)", test.c, len(a), a) | |
| } | |
| if strings.Count(q, "?") != test.c { | |
| t.Errorf("Expected %d bindVars, got %d", test.c, strings.Count(q, "?")) | |
| } | |
| } | |
| // too many bindVars, but no slices, so short circuits parsing | |
| // i'm not sure if this is the right behavior; this query/arg combo | |
| // might not work, but we shouldn't parse if we don't need to | |
| { | |
| orig := "SELECT * FROM foo WHERE x = ? AND y = ?" | |
| q, a, err := In(orig, "foo", "bar", "baz") | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| if len(a) != 3 { | |
| t.Errorf("Expected 3 args, but got %d (%+v)", len(a), a) | |
| } | |
| if q != orig { | |
| t.Error("Expected unchanged query.") | |
| } | |
| } | |
| tests = []tr{ | |
| // too many bindvars; slice present so should return error during parse | |
| {"SELECT * FROM foo WHERE x = ? and y = ?", | |
| []interface{}{"foo", []int{1, 2, 3}, "bar"}, | |
| 0}, | |
| // empty slice, should return error before parse | |
| {"SELECT * FROM foo WHERE x = ?", | |
| []interface{}{[]int{}}, | |
| 0}, | |
| // too *few* bindvars, should return an error | |
| {"SELECT * FROM foo WHERE x = ? AND y in (?)", | |
| []interface{}{[]int{1, 2, 3}}, | |
| 0}, | |
| } | |
| for _, test := range tests { | |
| _, _, err := In(test.q, test.args...) | |
| if err == nil { | |
| t.Error("Expected an error, but got nil.") | |
| } | |
| } | |
| RunWithSchemaContext(context.Background(), defaultSchema, t, func(ctx context.Context, db *DB, t *testing.T) { | |
| loadDefaultFixtureContext(ctx, db, t) | |
| //tx.MustExecContext(ctx, tx.Rebind("INSERT INTO place (country, city, telcode) VALUES (?, ?, ?)"), "United States", "New York", "1") | |
| //tx.MustExecContext(ctx, tx.Rebind("INSERT INTO place (country, telcode) VALUES (?, ?)"), "Hong Kong", "852") | |
| //tx.MustExecContext(ctx, tx.Rebind("INSERT INTO place (country, telcode) VALUES (?, ?)"), "Singapore", "65") | |
| telcodes := []int{852, 65} | |
| q := "SELECT * FROM place WHERE telcode IN(?) ORDER BY telcode" | |
| query, args, err := In(q, telcodes) | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| query = db.Rebind(query) | |
| places := []Place{} | |
| err = db.SelectContext(ctx, &places, query, args...) | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| if len(places) != 2 { | |
| t.Fatalf("Expecting 2 results, got %d", len(places)) | |
| } | |
| if places[0].TelCode != 65 { | |
| t.Errorf("Expecting singapore first, but got %#v", places[0]) | |
| } | |
| if places[1].TelCode != 852 { | |
| t.Errorf("Expecting hong kong second, but got %#v", places[1]) | |
| } | |
| }) | |
| } | |
| func TestEmbeddedLiteralsContext(t *testing.T) { | |
| var schema = Schema{ | |
| create: ` | |
| CREATE TABLE x ( | |
| k text | |
| );`, | |
| drop: `drop table x;`, | |
| } | |
| RunWithSchemaContext(context.Background(), schema, t, func(ctx context.Context, db *DB, t *testing.T) { | |
| type t1 struct { | |
| K *string | |
| } | |
| type t2 struct { | |
| Inline struct { | |
| F string | |
| } | |
| K *string | |
| } | |
| db.MustExecContext(ctx, db.Rebind("INSERT INTO x (k) VALUES (?), (?), (?);"), "one", "two", "three") | |
| target := t1{} | |
| err := db.GetContext(ctx, &target, db.Rebind("SELECT * FROM x WHERE k=?"), "one") | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| if *target.K != "one" { | |
| t.Error("Expected target.K to be `one`, got ", target.K) | |
| } | |
| target2 := t2{} | |
| err = db.GetContext(ctx, &target2, db.Rebind("SELECT * FROM x WHERE k=?"), "one") | |
| if err != nil { | |
| t.Error(err) | |
| } | |
| if *target2.K != "one" { | |
| t.Errorf("Expected target2.K to be `one`, got `%v`", target2.K) | |
| } | |
| }) | |
| } |