// noteUnusedDriverStatement notes that si is no longer used and should // be closed whenever possible (when c is next not in use), unless c is // already closed. func (db *DB) noteUnusedDriverStatement(c driver.Conn, si driver.Stmt) { db.mu.Lock() defer db.mu.Unlock() if db.outConn[c] { db.onConnPut[c] = append(db.onConnPut[c], func() { si.Close() }) } else { si.Close() } }
// noteUnusedDriverStatement notes that si is no longer used and should // be closed whenever possible (when c is next not in use), unless c is // already closed. func (db *DB) noteUnusedDriverStatement(c *driverConn, si driver.Stmt) { db.mu.Lock() defer db.mu.Unlock() if c.inUse { c.onPut = append(c.onPut, func() { si.Close() }) } else { c.Lock() defer c.Unlock() if !c.finalClosed { si.Close() } } }
func benchPreparedMockQuery(b *testing.B, c *conn, stmt driver.Stmt) { rows, err := stmt.Query(nil) if err != nil { b.Fatal(err) } defer rows.Close() var dest [1]driver.Value for { if err := rows.Next(dest[:]); err != nil { if err == io.EOF { break } b.Fatal(err) } } }
func ctxDriverStmtQuery(ctx context.Context, si driver.Stmt, nvdargs []driver.NamedValue) (driver.Rows, error) { if siCtx, is := si.(driver.StmtQueryContext); is { return siCtx.QueryContext(ctx, nvdargs) } dargs, err := namedValueToValue(nvdargs) if err != nil { return nil, err } if ctx.Done() == context.Background().Done() { return si.Query(dargs) } type R struct { err error panic interface{} rowsi driver.Rows } rc := make(chan R, 1) go func() { r := R{} defer func() { if v := recover(); v != nil { r.panic = v } rc <- r }() r.rowsi, r.err = si.Query(dargs) }() select { case <-ctx.Done(): go func() { <-rc close(rc) }() return nil, ctx.Err() case r := <-rc: if r.panic != nil { panic(r.panic) } return r.rowsi, r.err } }
func ctxDriverStmtExec(ctx context.Context, si driver.Stmt, nvdargs []driver.NamedValue) (driver.Result, error) { if siCtx, is := si.(driver.StmtExecContext); is { return siCtx.ExecContext(ctx, nvdargs) } dargs, err := namedValueToValue(nvdargs) if err != nil { return nil, err } resi, err := si.Exec(dargs) if err == nil { select { default: case <-ctx.Done(): return resi, ctx.Err() } } return resi, err }
func resultFromStatement(si driver.Stmt, args ...interface{}) (Result, error) { // -1 means the driver doesn't know how to count the number of // placeholders, so we won't sanity check input here and instead let the // driver deal with errors. if want := si.NumInput(); want != -1 && len(args) != want { return nil, fmt.Errorf("sql: expected %d arguments, got %d", want, len(args)) } dargs, err := driverArgs(si, args) if err != nil { return nil, err } resi, err := si.Exec(dargs) if err != nil { return nil, err } return result{resi}, nil }
func ctxDriverStmtQuery(ctx context.Context, si driver.Stmt, nvdargs []driver.NamedValue) (driver.Rows, error) { if siCtx, is := si.(driver.StmtQueryContext); is { return siCtx.QueryContext(ctx, nvdargs) } dargs, err := namedValueToValue(nvdargs) if err != nil { return nil, err } rowsi, err := si.Query(dargs) if err == nil { select { default: case <-ctx.Done(): rowsi.Close() return nil, ctx.Err() } } return rowsi, err }
func ctxDriverStmtExec(ctx context.Context, si driver.Stmt, dargs []driver.Value) (driver.Result, error) { if siCtx, is := si.(driver.StmtExecContext); is { return siCtx.ExecContext(ctx, dargs) } if ctx.Done() == context.Background().Done() { return si.Exec(dargs) } type R struct { err error panic interface{} resi driver.Result } rc := make(chan R, 1) go func() { r := R{} defer func() { if v := recover(); v != nil { r.panic = v } rc <- r }() r.resi, r.err = si.Exec(dargs) }() select { case <-ctx.Done(): go func() { <-rc close(rc) }() return nil, ctx.Err() case r := <-rc: if r.panic != nil { panic(r.panic) } return r.resi, r.err } }
func rowsiFromStatement(si driver.Stmt, args ...interface{}) (driver.Rows, error) { // -1 means the driver doesn't know how to count the number of // placeholders, so we won't sanity check input here and instead let the // driver deal with errors. if want := si.NumInput(); want != -1 && len(args) != want { return nil, fmt.Errorf("sql: statement expects %d inputs; got %d", si.NumInput(), len(args)) } dargs, err := driverArgs(si, args) if err != nil { return nil, err } rowsi, err := si.Query(dargs) if err != nil { return nil, err } return rowsi, nil }
// NewVar calls NewVar on the underlying *oracle.Cursor. // This allows out binds, and if value is a pointer, then GetValue is not needed. func NewVar(stmt driver.Stmt, value interface{}) (*oracle.Variable, error) { if stmt, ok := stmt.(varCreator); ok { return stmt.NewVar(value) } return nil, errgo.New("stmt must be a varCreator") }